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.
168 Commits
16 Branches
14GB
Tree: d7ec8f7122
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd7ec8f7122'
${ noResults }
Carla/source/backend/native/zynaddsubfx/UI/ResonanceUI.fl

399 lines
11KB
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 <FL/Fl_Box.H>} {public

  10. } 

  11. 

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

  13. } 

  14. 

  15. decl {\#include <FL/Fl_Value_Output.H>} {public

  16. } 

  17. 

  18. decl {\#include <math.h>} {} 

  19. 

  20. decl {\#include <stdio.h>} {} 

  21. 

  22. decl {\#include <stdlib.h>} {} 

  23. 

  24. decl {\#include <string.h>} {} 

  25. 

  26. decl {\#include "../Synth/Resonance.h"} {public

  27. } 

  28. 

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

  30. } 

  31. 

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

  33. } 

  34. 

  35. class ResonanceGraph {open : {public Fl_Box}

  36. } {

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

  38.     code {respar=NULL;

  39. cbwidget=NULL;

  40. applybutton=NULL;} {}

  41.   }

  42.   Function {init(Resonance *respar_,Fl_Value_Output *khzvalue_,Fl_Value_Output *dbvalue_)} {} {

  43.     code {respar=respar_;

  44. khzvalue=khzvalue_;

  45. dbvalue=dbvalue_;

  46. oldx=-1;

  47. khzval=-1;} {}

  48.   }

  49.   Function {draw_freq_line(float freq,int type)} {open

  50.   } {

  51.     code {float freqx=respar->getfreqpos(freq);

  52. switch(type){

  53.   case 0:fl_line_style(FL_SOLID);break;

  54.   case 1:fl_line_style(FL_DOT);break;

  55.   case 2:fl_line_style(FL_DASH);break;

  56. }; 

  57. 

  58. 

  59. if ((freqx>0.0)&&(freqx<1.0))

  60.    fl_line(x()+(int) (freqx*w()),y(),

  61.    x()+(int) (freqx*w()),y()+h());} {}

  62.   }

  63.   Function {draw()} {open

  64.   } {

  65.     code {int ox=x(),oy=y(),lx=w(),ly=h(),i,ix,iy,oiy;

  66. float freqx;

  67. 

  68. fl_color(FL_DARK1);

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

  70. 

  71. 

  72. //draw the lines

  73. fl_color(FL_GRAY);

  74. 

  75. fl_line_style(FL_SOLID);

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

  77. 

  78. freqx=respar->getfreqpos(1000.0);

  79. if ((freqx>0.0)&&(freqx<1.0))

  80.    fl_line(ox+(int) (freqx*lx),oy,

  81.     ox+(int) (freqx*lx),oy+ly);

  82. 

  83. for (i=1;i<10;i++){

  84.    if(i==1){

  85.      draw_freq_line(i*100.0,0);

  86.      draw_freq_line(i*1000.0,0);

  87.    }else 

  88.     if (i==5){

  89.       draw_freq_line(i*100.0,2);

  90.       draw_freq_line(i*1000.0,2);

  91.     }else{

  92.       draw_freq_line(i*100.0,1);

  93.       draw_freq_line(i*1000.0,1);

  94.     };

  95. };

  96. 

  97. draw_freq_line(10000.0,0);

  98. draw_freq_line(20000.0,1);

  99. 

  100. fl_line_style(FL_DOT);

  101. int GY=10;if (ly<GY*3) GY=-1;

  102. for (i=1;i<GY;i++){

  103.    int tmp=(int)(ly/(float)GY*i);

  104.    fl_line(ox+2,oy+tmp,ox+lx-2,oy+tmp);

  105. };

  106. 

  107. 

  108. 

  109. //draw the data

  110. fl_color(FL_RED);

  111. fl_line_style(FL_SOLID,2);

  112. fl_begin_line();

  113. oiy=(int)(respar->Prespoints[0]/128.0*ly);

  114. for (i=1;i<N_RES_POINTS;i++){

  115.    ix=(int)(i*1.0/N_RES_POINTS*lx);

  116.    iy=(respar->Prespoints[i]/128.0*ly);

  117.    fl_vertex(ox+ix,oy+ly-oiy);

  118.    oiy=iy;

  119. };

  120. fl_end_line();

  121. fl_line_style(FL_SOLID,0);} {selected

  122.     }

  123.   }

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

  125.   } {

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

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

  128. if ( (x_>=0)&&(x_<w()) && (y_>=0)&&(y_<h())){

  129.    khzvalue->value(respar->getfreqx(x_*1.0/w())/1000.0);

  130.    dbvalue->value((1.0-y_*2.0/h())*respar->PmaxdB);

  131. };

  132. 

  133. if ((event==FL_PUSH)||(event==FL_DRAG)){

  134.   int leftbutton=1;

  135.   if (Fl::event_button()==FL_RIGHT_MOUSE) leftbutton=0;

  136.   if (x_<0) x_=0;if (y_<0) y_=0;

  137.   if (x_>=w()) x_=w();if (y_>=h()-1) y_=h()-1;

  138. 

  139.   if ((oldx<0)||(oldx==x_)){

  140.     int sn=(int)(x_*1.0/w()*N_RES_POINTS);

  141.     int sp=127-(int)(y_*1.0/h()*127);

  142.     if (leftbutton!=0) respar->setpoint(sn,sp);

  143.         else respar->setpoint(sn,64);

  144.   } else {

  145.     int x1=oldx;

  146.     int x2=x_;

  147.     int y1=oldy;

  148.     int y2=y_;

  149.     if (oldx>x_){

  150.       x1=x_;y1=y_;

  151.       x2=oldx;y2=oldy;

  152.     };

  153.    for (int i=0;i<x2-x1;i++){

  154.       int sn=(int)((i+x1)*1.0/w()*N_RES_POINTS);

  155.       float yy=(y2-y1)*1.0/(x2-x1)*i;

  156.       int sp=127-(int)((y1+yy)/h()*127);

  157.       if (leftbutton!=0) respar->setpoint(sn,sp);

  158.          else respar->setpoint(sn,64);

  159.     };

  160.   };

  161. 

  162.   oldx=x_;oldy=y_;

  163.   redraw();

  164. };

  165. 

  166. if (event==FL_RELEASE) {

  167. 	oldx=-1;

  168. 	if (cbwidget!=NULL) {

  169. 		cbwidget->do_callback();

  170. 		if (applybutton!=NULL) {

  171. 			applybutton->color(FL_RED);

  172. 			applybutton->redraw();

  173. 

  174. 		};

  175. 	};

  176. };

  177. 

  178. return(1);} {}

  179.   }

  180.   Function {setcbwidget(Fl_Widget *cbwidget,Fl_Widget *applybutton)} {} {

  181.     code {this->cbwidget=cbwidget;

  182. this->applybutton=applybutton;} {}

  183.   }

  184.   decl {Fl_Value_Output *khzvalue;} {}

  185.   decl {Fl_Value_Output *dbvalue;} {}

  186.   decl {Resonance *respar;} {}

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

  188.   decl {float khzval;} {public

  189.   }

  190.   decl {Fl_Widget *cbwidget,*applybutton;} {}

  191. } 

  192. 

  193. class ResonanceUI {open : PresetsUI_

  194. } {

  195.   Function {make_window()} {open

  196.   } {

  197.     Fl_Window resonancewindow {

  198.       label Resonance open

  199.       xywh {120 70 780 305} type Double hide

  200.     } {

  201.       Fl_Value_Output khzvalue {

  202.         label kHz

  203.         xywh {415 264 45 18} labelsize 12 align 8 minimum 0.001 maximum 48 step 0.01 textfont 1 textsize 12

  204.         code0 {//this widget must be before the calling widgets}

  205.       }

  206.       Fl_Value_Output dbvalue {

  207.         label dB

  208.         xywh {415 282 45 18} labelsize 12 align 8 minimum -150 maximum 150 step 0.1 textfont 1 textsize 12

  209.         code0 {//this widget must be before the calling widgets}

  210.       }

  211.       Fl_Group {} {

  212.         xywh {6 5 768 256} box BORDER_BOX

  213.         code0 {rg=new ResonanceGraph(o->x(),o->y(),o->w(),o->h(),"");}

  214.         code1 {rg->init(respar,khzvalue,dbvalue);}

  215.         code2 {rg->show();}

  216.       } {}

  217.       Fl_Button {} {

  218.         label Close

  219.         callback {resonancewindow->hide();}

  220.         xywh {690 283 84 17} box THIN_UP_BOX

  221.       }

  222.       Fl_Button {} {

  223.         label Zero

  224.         callback {for (int i=0;i<N_RES_POINTS;i++) 

  225.    respar->setpoint(i,64);

  226. resonancewindow->redraw();

  227. redrawPADnoteApply();}

  228.         tooltip {Clear the resonance function} xywh {491 264 66 15} box THIN_UP_BOX labelfont 1 labelsize 12

  229.       }

  230.       Fl_Button {} {

  231.         label Smooth

  232.         callback {respar->smooth();

  233. resonancewindow->redraw();

  234. redrawPADnoteApply();}

  235.         tooltip {Smooth the resonance function} xywh {491 282 66 18} box THIN_UP_BOX labelfont 1 labelsize 12

  236.       }

  237.       Fl_Check_Button enabled {

  238.         label Enable

  239.         callback {respar->Penabled=(int) o->value();

  240. redrawPADnoteApply();}

  241.         xywh {6 270 78 27} box THIN_UP_BOX down_box DOWN_BOX

  242.         code0 {o->value(respar->Penabled);}

  243.       }

  244.       Fl_Roller maxdb {

  245.         callback {maxdbvo->value(o->value());

  246. respar->PmaxdB=(int) o->value();

  247. redrawPADnoteApply();}

  248.         xywh {90 282 84 15} type Horizontal minimum 1 maximum 90 step 1 value 30

  249.       }

  250.       Fl_Value_Output maxdbvo {

  251.         label {Max.}

  252.         callback {o->value(respar->PmaxdB);}

  253.         tooltip {The Maximum amplitude (dB)} xywh {126 264 24 18} labelsize 12 minimum 1 maximum 127 step 1 value 30 textfont 1 textsize 12

  254.         code0 {o->value(respar->PmaxdB);}

  255.       }

  256.       Fl_Box {} {

  257.         label dB

  258.         xywh {150 264 24 18}

  259.       }

  260.       Fl_Value_Output centerfreqvo {

  261.         label {C.f.}

  262.         callback {o->value(respar->getcenterfreq()/1000.0);}

  263.         tooltip {Center Frequency (kHz)} xywh {210 264 33 18} labelsize 12 when 3 minimum 1 maximum 10 step 0.01 value 1 textfont 1 textsize 12

  264.         code0 {o->value(respar->getcenterfreq()/1000.0);}

  265.       }

  266.       Fl_Value_Output octavesfreqvo {

  267.         label {Oct.}

  268.         callback {o->value(respar->getoctavesfreq());}

  269.         tooltip {No. of octaves} xywh {210 282 33 18} labelsize 12 when 3 minimum 1 maximum 127 step 1 value 30 textfont 1 textsize 12

  270.         code0 {o->value(respar->getoctavesfreq());}

  271.       }

  272.       Fl_Button {} {

  273.         label RND2

  274.         callback {respar->randomize(1);

  275. resonancewindow->redraw();

  276. redrawPADnoteApply();}

  277.         tooltip {Randomize the resonance function} xywh {566 276 42 12} box THIN_UP_BOX labelfont 1 labelsize 10

  278.       }

  279.       Fl_Button {} {

  280.         label RND1

  281.         callback {respar->randomize(0);

  282. resonancewindow->redraw();

  283. redrawPADnoteApply();}

  284.         tooltip {Randomize the resonance function} xywh {566 264 42 12} box THIN_UP_BOX labelfont 1 labelsize 10

  285.       }

  286.       Fl_Button {} {

  287.         label RND3

  288.         callback {respar->randomize(2);

  289. resonancewindow->redraw();

  290. redrawPADnoteApply();}

  291.         tooltip {Randomize the resonance function} xywh {566 288 42 12} box THIN_UP_BOX labelfont 1 labelsize 10

  292.       }

  293.       Fl_Check_Button p1st {

  294.         label {P.1st}

  295.         callback {respar->Pprotectthefundamental=(int) o->value();

  296. redrawPADnoteApply();}

  297.         tooltip {Protect the fundamental frequency (do not damp the first harmonic)} xywh {365 285 45 15} down_box DOWN_BOX labelsize 10

  298.         code0 {o->value(respar->Pprotectthefundamental);}

  299.       }

  300.       Fl_Button {} {

  301.         label InterpP

  302.         callback {int type;

  303. if (Fl::event_button()==FL_LEFT_MOUSE) type=0;

  304.        else type=1;

  305. respar->interpolatepeaks(type);

  306. resonancewindow->redraw();

  307. redrawPADnoteApply();}

  308.         tooltip {Interpolate the peaks} xywh {365 265 46 15} box THIN_UP_BOX labelfont 1 labelsize 10

  309.       }

  310.       Fl_Dial centerfreq {

  311.         label {C.f.}

  312.         callback {respar->Pcenterfreq=(int)o->value();

  313. centerfreqvo->do_callback();

  314. rg->redraw();

  315. redrawPADnoteApply();}

  316.         xywh {245 265 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  317.         code0 {o->value(respar->Pcenterfreq);}

  318.         class WidgetPDial

  319.       }

  320.       Fl_Dial octavesfreq {

  321.         label {Oct.}

  322.         callback {respar->Poctavesfreq=(int)o->value();

  323. octavesfreqvo->do_callback();

  324. rg->redraw();

  325. redrawPADnoteApply();}

  326.         xywh {280 265 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  327.         code0 {o->value(respar->Poctavesfreq);}

  328.         class WidgetPDial

  329.       }

  330.       Fl_Button {} {

  331.         label C

  332.         callback {presetsui->copy(respar);}

  333.         xywh {625 275 25 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 11 labelcolor 7

  334.       }

  335.       Fl_Button {} {

  336.         label P

  337.         callback {presetsui->paste(respar,this);}

  338.         xywh {655 275 25 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 11 labelcolor 7

  339.       }

  340.       Fl_Button applybutton {

  341.         label Apply

  342.         callback {applybutton->color(FL_GRAY);

  343. applybutton->redraw();

  344. if (cbapplywidget!=NULL) {

  345. 	cbapplywidget->do_callback();

  346. 	cbapplywidget->color(FL_GRAY);

  347. 	cbapplywidget->redraw();

  348. };}

  349.         xywh {690 265 85 15} box THIN_UP_BOX labelfont 1 labelsize 11

  350.       }

  351.     }

  352.   }

  353.   Function {ResonanceUI(Resonance *respar_)} {} {

  354.     code {respar=respar_;

  355. cbwidget=NULL;

  356. cbapplywidget=NULL;

  357. make_window();

  358. applybutton->hide();} {}

  359.   }

  360.   Function {~ResonanceUI()} {} {

  361.     code {resonancewindow->hide();} {}

  362.   }

  363.   Function {redrawPADnoteApply()} {} {

  364.     code {if (cbwidget!=NULL) {

  365. 	cbwidget->do_callback();

  366. 	applybutton->color(FL_RED);

  367. 	applybutton->redraw();

  368. };} {}

  369.   }

  370.   Function {setcbwidget(Fl_Widget *cbwidget,Fl_Widget *cbapplywidget)} {} {

  371.     code {this->cbwidget=cbwidget;

  372. this->cbapplywidget=cbapplywidget;

  373. rg->setcbwidget(cbwidget,applybutton);

  374. applybutton->show();} {}

  375.   }

  376.   Function {refresh()} {} {

  377.     code {redrawPADnoteApply();

  378. 

  379. enabled->value(respar->Penabled);

  380. 

  381. maxdb->value(respar->PmaxdB);

  382. maxdbvo->value(respar->PmaxdB);

  383. 

  384. centerfreqvo->value(respar->getcenterfreq()/1000.0);

  385. octavesfreqvo->value(respar->getoctavesfreq());

  386. 

  387. centerfreq->value(respar->Pcenterfreq);

  388. octavesfreq->value(respar->Poctavesfreq);

  389. 

  390. p1st->value(respar->Pprotectthefundamental);

  391. 

  392. rg->redraw();} {}

  393.   }

  394.   decl {Resonance *respar;} {public

  395.   }

  396.   decl {ResonanceGraph *rg;} {}

  397.   decl {Fl_Widget *cbwidget,*cbapplywidget;} {}

  398. }