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.
995 Commits
16 Branches
16GB
Tree: 6194dd6a11
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6194dd6a11'
${ noResults }
Carla/source/modules/carla_native/zynaddsubfx/UI/VirKeyboard.fl

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

  10. } 

  11. 

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

  13. } 

  14. 

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

  16. } 

  17. 

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

  19. } 

  20. 

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

  22. } 

  23. 

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

  25. } 

  26. 

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

  28. } 

  29. 

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

  31. } 

  32. 

  33. decl {\#ifdef NTK_GUI

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

  35.      \#endif} {public

  36. } 

  37. 

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

  39. 

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

  41. 

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

  43. 

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

  45. 

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

  47. 

  48. 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};} {} 

  49. 

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

  51. 

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

  53. 

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

  55. 

  56. class VirKeys {: {public Fl_Box}

  57. } {

  58.   decl {static const int N_OCT=6;} {}

  59.   decl {static const int SIZE_WHITE=14;} {}

  60.   decl {static const int SIZE_BLACK=8;} {}

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

  62.     code {master=NULL;} {}

  63.   }

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

  65.     code {master=master_;

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

  67. midich=0;

  68. midivel=100;

  69. midioct=2;

  70. 

  71. keyoct1=3;

  72. keyoct2=2;

  73. rndvelocity=0;} {}

  74.   }

  75.   Function {draw()} {} {

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

  77. 

  78. \#ifdef NTK_GUI

  79.  Fl_Image *white_up = Fl_Shared_Image::get( gUiPixmapPath + "white_key.png" );

  80.  Fl_Image *white_down = Fl_Shared_Image::get( gUiPixmapPath + "white_key_pressed.png" );

  81.  Fl_Image *black_up = Fl_Shared_Image::get( gUiPixmapPath + "black_key.png" );

  82.  Fl_Image *black_down = Fl_Shared_Image::get( gUiPixmapPath + "black_key_pressed.png" );

  83. 

  84. 

  85. //On error fetch everything from source directory

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

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

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

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

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

  91. }

  92. 

  93. Fl_Image *key;

  94. 

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

  96.    int noct=i/12;

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

  98. 

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

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

  101.          key = white_up;

  102.         else

  103.          key = white_down;

  104. 

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

  106.    } 

  107. }

  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 ) {

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

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

  116.        key = black_up;

  117.      else

  118.        key = black_down;

  119. 

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

  121.    }

  122. }

  123. \#else

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

  125.  fl_color(250,240,230);

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

  127. 

  128.  fl_color(FL_BLACK);

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

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

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

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

  133.    int ik=i%7;

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

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

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

  137.  }

  138. }

  139. 

  140. 

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

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

  143. 

  144.    int noct=i/12;

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

  146. 

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

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

  149.         else fl_color(FL_BLUE);

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

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

  152.    } else {//black keys

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

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

  155.         else fl_color(FL_BLUE);

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

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

  158.    }

  159. }

  160. \#endif} {}

  161.   }

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

  163.   } {

  164.     code {int i;

  165. int ly=h();

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

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

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

  169.   return(0);

  170. };

  171. 

  172. 

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

  174.    int kpos=-1;

  175.   

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

  177.        int pos=x_/SIZE_WHITE;

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

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

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

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

  182.              break;

  183.           };

  184.        };

  185.    } else {//black keys

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

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

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

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

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

  191.              break;

  192.           };

  193.        };

  194.    };

  195. 

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

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

  198.         presskey(kpos,1,1);

  199.    };

  200. 

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

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

  203.           else relasekey(kpos,1);

  204.    };

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

  206.         relaseallkeys(1);

  207.    take_focus();

  208. };

  209. 

  210. 

  211. const int *keysoct1=keysoct1qwerty;

  212. const int *keysoct2=keysoct2qwerty;

  213. 

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

  215. 	keysoct1=keysoct1dw;

  216. 	keysoct2=keysoct2dw;

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

  218. 	keysoct1=keysoct1qwertz;

  219. 	keysoct2=keysoct2qwertz;

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

  221. 	keysoct1=keysoct1az;

  222. 	keysoct2=keysoct2az;

  223. };

  224. 

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

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

  227.    int kpos=-1;

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

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

  230. 

  231. 

  232. 

  233. 

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

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

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

  237.       else relasekey(kpos,2);

  238. };

  239. 

  240. return(1);} {}

  241.   }

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

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

  244. //when the user uses the shift key

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

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

  247.   relaseallkeys(type);

  248.   return;

  249. };

  250. if (nk<0) return;

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

  252. 

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

  254. pressed[nk]=type;

  255. 

  256. damage(1);

  257. float vel=midivel;

  258. if (rndvelocity!=0){

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

  260. };

  261. 

  262. pthread_mutex_lock(&master->mutex);

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

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

  265.   }

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

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

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

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

  270. 

  271. pressed[nk]=0;

  272. 

  273. 

  274. damage(1);

  275. 

  276. pthread_mutex_lock(&master->mutex);

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

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

  279.   }

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

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

  282.   }

  283.   decl {Master *master;} {}

  284.   decl {int pressed[N_OCT*12+1];} {}

  285.   decl {unsigned char midich;} {public

  286.   }

  287.   decl {unsigned char midivel;} {public

  288.   }

  289.   decl {char midioct,keyoct1,keyoct2;} {public

  290.   }

  291.   decl {unsigned char rndvelocity;} {public

  292.   }

  293. } 

  294. 

  295. class VirKeyboard {open

  296. } {

  297.   Function {make_window()} {open

  298.   } {

  299.     Fl_Window virkeyboardwindow {

  300.       label {Virtual Keyboard - ZynAddSubFX}

  301.       callback {relaseallkeys();

  302. virkeyboardwindow->hide();} open

  303.       xywh {100 597 650 130} type Double visible

  304.     } {

  305.       Fl_Box virkeys {

  306.         label Keyboard

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

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

  309.         class VirKeys

  310.       }

  311.       Fl_Counter {} {

  312.         label {"qwer.." Oct}

  313.         callback {relaseallkeys();

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

  315. virkeys->take_focus();}

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

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

  318.       }

  319.       Fl_Counter {} {

  320.         label {"zxcv.." Oct}

  321.         callback {relaseallkeys();

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

  323. virkeys->take_focus();}

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

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

  326.       }

  327.       Fl_Value_Slider {} {

  328.         label Vel

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

  330. virkeys->take_focus();} selected

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

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

  333.       }

  334.       Fl_Counter {} {

  335.         label {Oct.}

  336.         callback {relaseallkeys();

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

  338. virkeys->take_focus();}

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

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

  341.       }

  342.       Fl_Button {} {

  343.         label Close

  344.         callback {relaseallkeys();

  345. virkeyboardwindow->hide();}

  346.         xywh {545 105 55 20} box THIN_UP_BOX

  347.       }

  348.       Fl_Value_Slider {} {

  349.         label Cval

  350.         callback {int ctl=midictl;

  351. 

  352. pthread_mutex_lock(&master->mutex);

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

  354. pthread_mutex_unlock(&master->mutex);

  355. virkeys->take_focus();}

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

  357.       }

  358.       Fl_Choice {} {

  359.         label Controller

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

  361.    case 1: midictl=C_modwheel; break;

  362.    case 2: midictl=C_volume; break;

  363.    case 3: midictl=C_panning; break;

  364.    case 4: midictl=C_expression; break;

  365.    case 5: midictl=C_sustain; break;

  366.    case 6: midictl=C_portamento; break;

  367.    case 7: midictl=C_filterq; break;

  368.    case 8: midictl=C_filtercutoff; break;

  369.    case 9: midictl=C_bandwidth; break;

  370.    case 10: midictl=C_fmamp; break;

  371.    case 11: midictl=C_resonance_center; break;

  372.    case 12: midictl=C_resonance_bandwidth; break;

  373.    default: midictl=C_NULL; break;

  374. 

  375. };

  376. 

  377. 

  378. 

  379. virkeys->take_focus();}

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

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

  382.       } {

  383.         MenuItem {} {

  384.           label {01: Mod.Wheel}

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

  386.         }

  387.         MenuItem {} {

  388.           label {07: Volume}

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

  390.         }

  391.         MenuItem {} {

  392.           label {10: Panning}

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

  394.         }

  395.         MenuItem {} {

  396.           label {11: Expression}

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

  398.         }

  399.         MenuItem {} {

  400.           label {64: Sustain}

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

  402.         }

  403.         MenuItem {} {

  404.           label {65: Portamento}

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

  406.         }

  407.         MenuItem {} {

  408.           label {71: Filter Q}

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

  410.         }

  411.         MenuItem {} {

  412.           label {74: Filter Freq.}

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

  414.         }

  415.         MenuItem {} {

  416.           label {75: Bandwidth}

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

  418.         }

  419.         MenuItem {} {

  420.           label {76: FM Gain}

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

  422.         }

  423.         MenuItem {} {

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

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

  426.         }

  427.         MenuItem {} {

  428.           label {78: Res. bw.}

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

  430.         }

  431.       }

  432.       Fl_Roller pitchwheelroller {

  433.         label Pwh

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

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

  436. pthread_mutex_unlock(&master->mutex);

  437. virkeys->take_focus();}

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

  439.       }

  440.       Fl_Button {} {

  441.         label R

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

  443. pitchwheelroller->do_callback();}

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

  445.       }

  446.       Fl_Dial {} {

  447.         label Vrnd

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

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

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

  451.         class WidgetPDial

  452.       }

  453.       Fl_Choice partrcv {

  454.         label {MIDI Ch.}

  455.         callback {relaseallkeys();

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

  457. virkeys->take_focus();} open

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

  459.         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");};}

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

  461.       } {}

  462.     }

  463.   }

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

  465.     code {master=master_;

  466. midictl=75;

  467. make_window();} {}

  468.   }

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

  470.     code {delete virkeyboardwindow;} {}

  471.   }

  472.   Function {show()} {} {

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

  474.   }

  475.   Function {relaseallkeys()} {} {

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

  477.   }

  478.   decl {Master *master;} {}

  479.   decl {int midictl;} {}

  480. }