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.
643 Commits
2 Branches
36MB
Tree: f5f37f00ba
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f5f37f00ba'
${ noResults }
Cadence/c++/carla-backend/plugins/zynaddsubfx/UI/VirKeyboard.fl

500 lines
14KB
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 <stdlib.h>} {public local

  12. } 

  13. 

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

  15. } 

  16. 

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

  18. } 

  19. 

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

  21. } 

  22. 

  23. decl {\#include "../Misc/Master.h"} {public local

  24. } 

  25. 

  26. decl {\#include "../Misc/Util.h"} {public local

  27. } 

  28. 

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

  30. } 

  31. 

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

  33. } 

  34. 

  35. decl {\#ifdef NTK_GUI

  36.      \#include "FL/Fl_Shared_Image.H"

  37.      \#endif} {public local

  38. } 

  39. 

  40. decl {const int keyspos[12]={0,-1,1,-2,2,3,-4,4,-5,5,-6,6};} {private local

  41. } 

  42. 

  43. decl {const int keysoct1qwerty[]={'q','2','w','3','e','r','5','t','6','y','7','u','i','9','o','0','p','[','=',']','\\\\',FL_Enter,0};} {private local

  44. } 

  45. 

  46. decl {const int keysoct2qwerty[]={'z','s','x','d','c','v','g','b','h','n','j','m',',','l','.',';','/',0};} {private local

  47. } 

  48. 

  49. decl {const int keysoct1dw[]={'\\'','2',',','3','.','p','5','y','6','f','7','g','c','9','r','0','l','/',']','=','\\\\',FL_Enter,0};} {private local

  50. } 

  51. 

  52. decl {const int keysoct2dw[]={';','o','q','e','j','k','i','x','d','b','h','m','w','n','v','s','z',0};} {private local

  53. } 

  54. 

  55. decl {const int keysoct1qwertz[]={'q','2','w','3','e','r','5','t','6','z','7','u','i','9','o','0','p',252,'\\'','+','\\\\',FL_Enter,0};} {private local

  56. } 

  57. 

  58. decl {const int keysoct2qwertz[]={'y','s','x','d','c','v','g','b','h','n','j','m',',','l','.',246,'-',0};} {private local

  59. } 

  60. 

  61. decl {const int keysoct1az[]={'a',233,'z','\\"','e','r','(','t','-','y',232,'u','i',231,'o',224,'p',65106,'=','$',0};} {private local

  62. } 

  63. 

  64. decl {const int keysoct2az[]={'w','s','x','d','c','v','g','b','h','n','j',',',';','l',':','m','!',0};} {private local

  65. } 

  66. 

  67. class VirKeys {: {public Fl_Box}

  68. } {

  69.   decl {static const int N_OCT=6;} {private local

  70.   }

  71.   decl {static const int SIZE_WHITE=14;} {private local

  72.   }

  73.   decl {static const int SIZE_BLACK=8;} {private local

  74.   }

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

  76.     code {master=NULL;} {}

  77.   }

  78.   Function {init(Master *master_)} {} {

  79.     code {master=master_;

  80. for (int i=0;i<N_OCT*12+1;i++) pressed[i]=0;

  81. midich=0;

  82. midivel=100;

  83. midioct=2;

  84. 

  85. keyoct1=3;

  86. keyoct2=2;

  87. rndvelocity=0;} {}

  88.   }

  89.   Function {draw()} {} {

  90.     code {int ox=x(),oy=y(),lx=w(),ly=h()-1,i;

  91. 

  92. \#ifdef NTK_GUI

  93.  Fl_Image *white_up = Fl_Shared_Image::get( PIXMAP_PATH "white_key.png" );

  94.  Fl_Image *white_down = Fl_Shared_Image::get( PIXMAP_PATH "white_key_pressed.png" );

  95.  Fl_Image *black_up = Fl_Shared_Image::get( PIXMAP_PATH "black_key.png" );

  96.  Fl_Image *black_down = Fl_Shared_Image::get( PIXMAP_PATH "black_key_pressed.png" );

  97. 

  98. 

  99. //On error fetch everything from source directory

  100. if(!(white_up&&white_down&&black_up&&black_down)) {

  101.     white_up   = Fl_Shared_Image::get(SOURCE_DIR "/../../pixmaps/white_key.png");   

  102.     white_down = Fl_Shared_Image::get(SOURCE_DIR "/../../pixmaps/white_key_pressed.png");

  103.     black_up   = Fl_Shared_Image::get(SOURCE_DIR "/../../pixmaps/black_key.png");

  104.     black_down = Fl_Shared_Image::get(SOURCE_DIR "/../../pixmaps/black_key_pressed.png");

  105. }

  106. 

  107. Fl_Image *key;

  108. 

  109. for (i=0;i<N_OCT*12;i++) {

  110.    int noct=i/12;

  111.    int kv=keyspos[i%12];

  112. 

  113.    if (kv>=0){//white keys

  114.      if (pressed[i]==0)

  115.          key = white_up;

  116.         else

  117.          key = white_down;

  118. 

  119.       key->draw( ox + (kv + 7 * noct ) * white_up->w() + 3, oy );

  120.    } 

  121. }

  122. 

  123. for (i=0;i<N_OCT*12;i++){

  124.    int noct=i/12;

  125.    int kv=keyspos[i%12];

  126. 

  127.    if ( kv < 0 ) {

  128.      kv=keyspos[(i+1)%12];

  129.      if (pressed[i]==0)

  130.        key = black_up;

  131.      else

  132.        key = black_down;

  133. 

  134.        key->draw( ox + (kv + 7 * noct ) * white_up->w() - black_up->w() / 2 + 2, oy );

  135.    }

  136. }

  137. \#else

  138. if (damage()!=1){

  139.  fl_color(250,240,230);

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

  141. 

  142.  fl_color(FL_BLACK);

  143.  fl_line(ox,oy,ox+lx,oy);

  144.  fl_line(ox,oy+ly,ox+lx,oy+ly);

  145.  for (i=0;i<N_OCT*7+1;i++){

  146.    fl_line(ox+i*SIZE_WHITE,oy,ox+i*SIZE_WHITE,oy+ly);

  147.    int ik=i%7;

  148.    if ((ik==1)||(ik==2)||(ik==4)||(ik==5)||(ik==6)) 

  149.      fl_rectf(ox+i*SIZE_WHITE-SIZE_BLACK/2,oy,

  150.               SIZE_BLACK+1,ly*3/5);

  151.  }

  152. }

  153. 

  154. 

  155. for (i=0;i<N_OCT*12;i++){

  156.   // if (pressed[i]==0) continue;

  157. 

  158.    int noct=i/12;

  159.    int kv=keyspos[i%12];

  160. 

  161.    if (kv>=0){//white keys

  162.      if (pressed[i]==0) fl_color(250,240,230);

  163.         else fl_color(FL_BLUE);

  164.      fl_rectf(ox+(kv+7*noct)*SIZE_WHITE+3,oy+ly*3/5+2,

  165.        SIZE_WHITE-4,ly*2/5-3);

  166.    } else {//black keys

  167.      kv=keyspos[(i+1)%12];

  168.      if (pressed[i]==0) fl_color(FL_BLACK);

  169.         else fl_color(FL_BLUE);

  170.      fl_rectf(ox+(kv+7*noct)*SIZE_WHITE-SIZE_BLACK/2+2,oy+2,

  171.               SIZE_BLACK-3,ly*3/5-5);

  172.    }

  173. }

  174. \#endif

  175. } {}

  176.   }

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

  178.   } {

  179.     code {int i;

  180. int ly=h();

  181. int x_=Fl::event_x()-x();

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

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

  184.   return(0);

  185. };

  186. 

  187. 

  188. if ((event==FL_PUSH)||(event==FL_DRAG)||(event==FL_RELEASE)){

  189.    int kpos=-1;

  190.   

  191.    if (y_>ly*3/5){//white keys

  192.        int pos=x_/SIZE_WHITE;

  193.        if (pos<0) return(1);

  194.        for (i=0;i<12;i++) {

  195.           if (pos%7==keyspos[i]) {

  196.              kpos=pos/7*12+i;

  197.              break;

  198.           };

  199.        };

  200.    } else {//black keys

  201.        int pos=(x_+SIZE_WHITE/2)/SIZE_WHITE;

  202.        if (pos<0) return(1);

  203.        for (i=1;i<12;i++) {

  204.           if (pos%7==-keyspos[i]) {

  205.              kpos=pos/7*12+i;

  206.              break;

  207.           };

  208.        };

  209.    };

  210. 

  211.    if ((kpos!=-1)&&((event==FL_PUSH)||(event==FL_DRAG))&&

  212.        (Fl::event_shift()==0)) {

  213.         presskey(kpos,1,1);

  214.    };

  215. 

  216.    if ((event==FL_PUSH)&&(Fl::event_shift()!=0)) {

  217.        if (pressed[kpos]==0) presskey(kpos,0,1);

  218.           else relasekey(kpos,1);

  219.    };

  220.    if ((event==FL_RELEASE)&&(Fl::event_shift()==0))

  221.         relaseallkeys(1);

  222.    take_focus();

  223. };

  224. 

  225. 

  226. const int *keysoct1=keysoct1qwerty;

  227. const int *keysoct2=keysoct2qwerty;

  228. 

  229. if (config.cfg.VirKeybLayout==2) {

  230. 	keysoct1=keysoct1dw;

  231. 	keysoct2=keysoct2dw;

  232. }else if (config.cfg.VirKeybLayout==3) {

  233. 	keysoct1=keysoct1qwertz;

  234. 	keysoct2=keysoct2qwertz;

  235. }else if (config.cfg.VirKeybLayout==4) {

  236. 	keysoct1=keysoct1az;

  237. 	keysoct2=keysoct2az;

  238. };

  239. 

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

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

  242.    int kpos=-1;

  243.    for (i=0;keysoct1[i]!=0;i++) if (key==keysoct1[i]) kpos=i+12*keyoct1;

  244.    for (i=0;keysoct2[i]!=0;i++) if (key==keysoct2[i]) kpos=i+12*keyoct2;

  245. 

  246. 

  247. 

  248. 

  249.    if (kpos==-1) return(0);

  250.    if ((event==FL_KEYUP) && (Fl::event_key(key)==0) && (Fl::get_key(key)!=0)) return(0);

  251.    if (event==FL_KEYDOWN) presskey(kpos,0,2);

  252.       else relasekey(kpos,2);

  253. };

  254. 

  255. return(1);} {}

  256.   }

  257.   Function {presskey(int nk,int exclusive,int type)} {} {

  258.     code {//Exclusive means that multiple keys can be pressed at once

  259. //when the user uses the shift key

  260. if (nk>=N_OCT*12) return;

  261. if ((nk<0)&&(exclusive==0)) {

  262.   relaseallkeys(type);

  263.   return;

  264. };

  265. if (nk<0) return;

  266. if (pressed[nk]!=0) return;//the key is already pressed

  267. 

  268. if (exclusive!=0) relaseallkeys(type);

  269. pressed[nk]=type;

  270. 

  271. damage(1);

  272. float vel=midivel;

  273. if (rndvelocity!=0){

  274.   vel=midivel*(127.0-rndvelocity)/127.0+RND*rndvelocity;

  275. };

  276. 

  277. pthread_mutex_lock(&master->mutex);

  278. master->noteOn(midich,nk+midioct*12,(int)vel);

  279. pthread_mutex_unlock(&master->mutex);} {}

  280.   }

  281.   Function {relasekey(int nk,int type)} {} {

  282.     code {if ((nk<0)||(nk>=N_OCT*12)) return;

  283. if (pressed[nk]==0) return;//the key is not pressed

  284. if ((type!=0)&&(pressed[nk]!=type)) return;

  285. 

  286. pressed[nk]=0;

  287. 

  288. 

  289. damage(1);

  290. 

  291. pthread_mutex_lock(&master->mutex);

  292. master->noteOff(midich,nk+12*midioct);

  293. pthread_mutex_unlock(&master->mutex);} {}

  294.   }

  295.   Function {relaseallkeys(int type)} {} {

  296.     code {for (int i=0;i<N_OCT*12;i++) relasekey(i,type);} {}

  297.   }

  298.   decl {Master *master;} {private local

  299.   }

  300.   decl {int pressed[N_OCT*12+1];} {private local

  301.   }

  302.   decl {unsigned char midich;} {public local

  303.   }

  304.   decl {unsigned char midivel;} {public local

  305.   }

  306.   decl {char midioct,keyoct1,keyoct2;} {public local

  307.   }

  308.   decl {unsigned char rndvelocity;} {public local

  309.   }

  310. } 

  311. 

  312. class VirKeyboard {open

  313. } {

  314.   Function {make_window()} {open

  315.   } {

  316.     Fl_Window virkeyboardwindow {

  317.       label {Virtual Keyboard - ZynAddSubFX}

  318.       callback {relaseallkeys();

  319. virkeyboardwindow->hide();} open

  320.       xywh {97 574 650 130} type Double visible

  321.     } {

  322.       Fl_Box virkeys {

  323.         label Keyboard

  324.         xywh {10 10 590 80} box FLAT_BOX color 17

  325.         code0 {o->init(master);}

  326.         class VirKeys

  327.       }

  328.       Fl_Counter {} {

  329.         label {"qwer.." Oct}

  330.         callback {relaseallkeys();

  331. virkeys->keyoct1=(int) o->value();

  332. virkeys->take_focus();}

  333.         tooltip {keys "q2w3er5t6y..." octave} xywh {380 95 45 15} type Simple labelsize 10 align 4 when 6 minimum 0 maximum 5 step 1 textfont 1 textsize 10

  334.         code0 {o->value(virkeys->keyoct1);}

  335.       }

  336.       Fl_Counter {} {

  337.         label {"zxcv.." Oct}

  338.         callback {relaseallkeys();

  339. virkeys->keyoct2=(int) o->value();

  340. virkeys->take_focus();}

  341.         tooltip {keys "zsxdcvgbh..." octave} xywh {380 110 45 15} type Simple labelsize 10 align 4 when 6 minimum 0 maximum 5 step 1 textfont 1 textsize 10

  342.         code0 {o->value(virkeys->keyoct2);}

  343.       }

  344.       Fl_Value_Slider {} {

  345.         label Vel

  346.         callback {virkeys->midivel=(int) o->value();

  347. virkeys->take_focus();} selected

  348.         tooltip Velocity xywh {95 105 100 15} type {Horz Knob} box NO_BOX labelsize 10 align 5 minimum 1 maximum 127 step 1

  349.         code0 {o->value(virkeys->midivel);}

  350.       }

  351.       Fl_Counter {} {

  352.         label {Oct.}

  353.         callback {relaseallkeys();

  354. virkeys->midioct=(int) o->value();

  355. virkeys->take_focus();}

  356.         tooltip {Midi Octave} xywh {255 100 55 20} type Simple labelsize 11 align 4 when 6 minimum 0 maximum 5 step 1 textfont 1 textsize 11

  357.         code0 {o->value(virkeys->midioct);}

  358.       }

  359.       Fl_Button {} {

  360.         label Close

  361.         callback {relaseallkeys();

  362. virkeyboardwindow->hide();}

  363.         xywh {545 105 55 20} box THIN_UP_BOX

  364.       }

  365.       Fl_Value_Slider {} {

  366.         label Cval

  367.         callback {int ctl=midictl;

  368. 

  369. pthread_mutex_lock(&master->mutex);

  370. master->setController(virkeys->midich,ctl,(int) o->value());

  371. pthread_mutex_unlock(&master->mutex);

  372. virkeys->take_focus();}

  373.         tooltip {Controller value} xywh {605 10 15 115} type {Vert Fill} box ENGRAVED_BOX selection_color 229 labelsize 8 align 5 minimum 127 maximum 0 step 1 value 64 textsize 7

  374.       }

  375.       Fl_Choice {} {

  376.         label Controller

  377.         callback {switch((int) o->value()+1){

  378.    case 1: midictl=C_modwheel; break;

  379.    case 2: midictl=C_volume; break;

  380.    case 3: midictl=C_panning; break;

  381.    case 4: midictl=C_expression; break;

  382.    case 5: midictl=C_sustain; break;

  383.    case 6: midictl=C_portamento; break;

  384.    case 7: midictl=C_filterq; break;

  385.    case 8: midictl=C_filtercutoff; break;

  386.    case 9: midictl=C_bandwidth; break;

  387.    case 10: midictl=C_fmamp; break;

  388.    case 11: midictl=C_resonance_center; break;

  389.    case 12: midictl=C_resonance_bandwidth; break;

  390.    default: midictl=C_NULL; break;

  391. 

  392. };

  393. 

  394. 

  395. 

  396. virkeys->take_focus();}

  397.         xywh {435 105 100 15} down_box BORDER_BOX labelsize 10 align 5 when 6 textfont 1 textsize 10

  398.         code0 {midictl=C_filtercutoff;o->value(7);}

  399.       } {

  400.         MenuItem {} {

  401.           label {01: Mod.Wheel}

  402.           xywh {0 0 100 20} labelfont 1 labelsize 10

  403.         }

  404.         MenuItem {} {

  405.           label {07: Volume}

  406.           xywh {10 10 100 20} labelfont 1 labelsize 10

  407.         }

  408.         MenuItem {} {

  409.           label {10: Panning}

  410.           xywh {20 20 100 20} labelfont 1 labelsize 10

  411.         }

  412.         MenuItem {} {

  413.           label {11: Expression}

  414.           xywh {30 30 100 20} labelfont 1 labelsize 10

  415.         }

  416.         MenuItem {} {

  417.           label {64: Sustain}

  418.           xywh {40 40 100 20} labelfont 1 labelsize 10

  419.         }

  420.         MenuItem {} {

  421.           label {65: Portamento}

  422.           xywh {50 50 100 20} labelfont 1 labelsize 10

  423.         }

  424.         MenuItem {} {

  425.           label {71: Filter Q}

  426.           xywh {60 60 100 20} labelfont 1 labelsize 10

  427.         }

  428.         MenuItem {} {

  429.           label {74: Filter Freq.}

  430.           xywh {70 70 100 20} labelfont 1 labelsize 10

  431.         }

  432.         MenuItem {} {

  433.           label {75: Bandwidth}

  434.           xywh {80 80 100 20} labelfont 1 labelsize 10

  435.         }

  436.         MenuItem {} {

  437.           label {76: FM Gain}

  438.           xywh {90 90 100 20} labelfont 1 labelsize 10

  439.         }

  440.         MenuItem {} {

  441.           label {77: Res. c. freq}

  442.           xywh {100 100 100 20} labelfont 1 labelsize 10

  443.         }

  444.         MenuItem {} {

  445.           label {78: Res. bw.}

  446.           xywh {110 110 100 20} labelfont 1 labelsize 10

  447.         }

  448.       }

  449.       Fl_Roller pitchwheelroller {

  450.         label Pwh

  451.         callback {pthread_mutex_lock(&master->mutex);

  452. master->setController(virkeys->midich,C_pitchwheel,-(int) o->value());

  453. pthread_mutex_unlock(&master->mutex);

  454. virkeys->take_focus();}

  455.         tooltip {Pitch Wheel} xywh {625 10 20 95} box UP_BOX labelsize 8 align 1 when 3 minimum -8192 maximum 8192 step 64

  456.       }

  457.       Fl_Button {} {

  458.         label R

  459.         callback {pitchwheelroller->value(0);

  460. pitchwheelroller->do_callback();}

  461.         tooltip {Reset Pitch Bend} xywh {625 110 20 15} box THIN_UP_BOX labelfont 1

  462.       }

  463.       Fl_Dial {} {

  464.         label Vrnd

  465.         callback {virkeys->rndvelocity=(int) o->value();}

  466.         tooltip {Velocity Randomness} xywh {205 105 20 20} box ROUND_UP_BOX labelsize 10 align 129 maximum 127 step 1

  467.         code0 {o->value(virkeys->rndvelocity);}

  468.         class WidgetPDial

  469.       }

  470.       Fl_Choice partrcv {

  471.         label {MIDI Ch.}

  472.         callback {relaseallkeys();

  473. virkeys->midich=(int) o->value();

  474. virkeys->take_focus();} open

  475.         tooltip {Send to Midi Channel} xywh {20 105 65 20} down_box BORDER_BOX labelsize 10 align 5 textfont 1 textsize 10

  476.         code0 {char nrstr[10]; for(int i=0;i<NUM_MIDI_CHANNELS;i++){sprintf(nrstr,"Chn%d",i+1);if (i!=9) o->add(nrstr); else o->add("Drum10");};}

  477.         code1 {o->value(virkeys->midich);}

  478.       } {}

  479.     }

  480.   }

  481.   Function {VirKeyboard(Master *master_)} {} {

  482.     code {master=master_;

  483. midictl=75;

  484. make_window();} {}

  485.   }

  486.   Function {~VirKeyboard()} {} {

  487.     code {delete virkeyboardwindow;} {}

  488.   }

  489.   Function {show()} {} {

  490.     code {virkeyboardwindow->show();} {}

  491.   }

  492.   Function {relaseallkeys()} {} {

  493.     code {virkeys->relaseallkeys(0);} {}

  494.   }

  495.   decl {Master *master;} {private local

  496.   }

  497.   decl {int midictl;} {private local

  498.   }

  499. }