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.
2722 Commits
16 Branches
14GB
Tree: 59e65ff67a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '59e65ff67a'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/UI/VirKeyboard.fl

488 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. \#ifdef CARLA_VERSION_STRING

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

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

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

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

  84. \#else

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

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

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

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

  89.  \#endif

  90. 

  91. 

  92. //On error fetch everything from source directory

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

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

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

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

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

  98. }

  99. 

  100. Fl_Image *key;

  101. 

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

  103.    int noct=i/12;

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

  105. 

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

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

  108.          key = white_up;

  109.         else

  110.          key = white_down;

  111. 

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

  113.    } 

  114. }

  115. 

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

  117.    int noct=i/12;

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

  119. 

  120.    if ( kv < 0 ) {

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

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

  123.        key = black_up;

  124.      else

  125.        key = black_down;

  126. 

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

  128.    }

  129. }

  130. \#else

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

  132.  fl_color(250,240,230);

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

  134. 

  135.  fl_color(FL_BLACK);

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

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

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

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

  140.    int ik=i%7;

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

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

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

  144.  }

  145. }

  146. 

  147. 

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

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

  150. 

  151.    int noct=i/12;

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

  153. 

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

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

  156.         else fl_color(FL_BLUE);

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

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

  159.    } else {//black keys

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

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

  162.         else fl_color(FL_BLUE);

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

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

  165.    }

  166. }

  167. \#endif} {}

  168.   }

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

  170.   } {

  171.     code {int i;

  172. int ly=h();

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

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

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

  176.   return(0);

  177. };

  178. 

  179. 

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

  181.    int kpos=-1;

  182.   

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

  184.        int pos=x_/SIZE_WHITE;

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

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

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

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

  189.              break;

  190.           };

  191.        };

  192.    } else {//black keys

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

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

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

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

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

  198.              break;

  199.           };

  200.        };

  201.    };

  202. 

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

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

  205.         presskey(kpos,1,1);

  206.    };

  207. 

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

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

  210.           else relasekey(kpos,1);

  211.    };

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

  213.         relaseallkeys(1);

  214.    take_focus();

  215. };

  216. 

  217. 

  218. const int *keysoct1=keysoct1qwerty;

  219. const int *keysoct2=keysoct2qwerty;

  220. 

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

  222. 	keysoct1=keysoct1dw;

  223. 	keysoct2=keysoct2dw;

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

  225. 	keysoct1=keysoct1qwertz;

  226. 	keysoct2=keysoct2qwertz;

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

  228. 	keysoct1=keysoct1az;

  229. 	keysoct2=keysoct2az;

  230. };

  231. 

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

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

  234.    int kpos=-1;

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

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

  237. 

  238. 

  239. 

  240. 

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

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

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

  244.       else relasekey(kpos,2);

  245. };

  246. 

  247. return(1);} {}

  248.   }

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

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

  251. //when the user uses the shift key

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

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

  254.   relaseallkeys(type);

  255.   return;

  256. };

  257. if (nk<0) return;

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

  259. 

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

  261. pressed[nk]=type;

  262. 

  263. damage(1);

  264. float vel=midivel;

  265. if (rndvelocity!=0){

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

  267. };

  268. 

  269. pthread_mutex_lock(&master->mutex);

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

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

  272.   }

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

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

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

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

  277. 

  278. pressed[nk]=0;

  279. 

  280. 

  281. damage(1);

  282. 

  283. pthread_mutex_lock(&master->mutex);

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

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

  286.   }

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

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

  289.   }

  290.   decl {Master *master;} {}

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

  292.   decl {unsigned char midich;} {public

  293.   }

  294.   decl {unsigned char midivel;} {public

  295.   }

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

  297.   }

  298.   decl {unsigned char rndvelocity;} {public

  299.   }

  300. } 

  301. 

  302. class VirKeyboard {open

  303. } {

  304.   Function {make_window()} {open

  305.   } {

  306.     Fl_Window virkeyboardwindow {

  307.       label {Virtual Keyboard - ZynAddSubFX}

  308.       callback {relaseallkeys();

  309. virkeyboardwindow->hide();} open

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

  311.     } {

  312.       Fl_Box virkeys {

  313.         label Keyboard

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

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

  316.         class VirKeys

  317.       }

  318.       Fl_Counter {} {

  319.         label {"qwer.." Oct}

  320.         callback {relaseallkeys();

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

  322. virkeys->take_focus();}

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

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

  325.       }

  326.       Fl_Counter {} {

  327.         label {"zxcv.." Oct}

  328.         callback {relaseallkeys();

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

  330. virkeys->take_focus();}

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

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

  333.       }

  334.       Fl_Value_Slider {} {

  335.         label Vel

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

  337. virkeys->take_focus();} selected

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

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

  340.       }

  341.       Fl_Counter {} {

  342.         label {Oct.}

  343.         callback {relaseallkeys();

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

  345. virkeys->take_focus();}

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

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

  348.       }

  349.       Fl_Button {} {

  350.         label Close

  351.         callback {relaseallkeys();

  352. virkeyboardwindow->hide();}

  353.         xywh {545 105 55 20} box THIN_UP_BOX

  354.       }

  355.       Fl_Value_Slider {} {

  356.         label Cval

  357.         callback {int ctl=midictl;

  358. 

  359. pthread_mutex_lock(&master->mutex);

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

  361. pthread_mutex_unlock(&master->mutex);

  362. virkeys->take_focus();}

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

  364.       }

  365.       Fl_Choice {} {

  366.         label Controller

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

  368.    case 1: midictl=C_modwheel; break;

  369.    case 2: midictl=C_volume; break;

  370.    case 3: midictl=C_panning; break;

  371.    case 4: midictl=C_expression; break;

  372.    case 5: midictl=C_sustain; break;

  373.    case 6: midictl=C_portamento; break;

  374.    case 7: midictl=C_filterq; break;

  375.    case 8: midictl=C_filtercutoff; break;

  376.    case 9: midictl=C_bandwidth; break;

  377.    case 10: midictl=C_fmamp; break;

  378.    case 11: midictl=C_resonance_center; break;

  379.    case 12: midictl=C_resonance_bandwidth; break;

  380.    default: midictl=C_NULL; break;

  381. 

  382. };

  383. 

  384. 

  385. 

  386. virkeys->take_focus();}

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

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

  389.       } {

  390.         MenuItem {} {

  391.           label {01: Mod.Wheel}

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

  393.         }

  394.         MenuItem {} {

  395.           label {07: Volume}

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

  397.         }

  398.         MenuItem {} {

  399.           label {10: Panning}

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

  401.         }

  402.         MenuItem {} {

  403.           label {11: Expression}

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

  405.         }

  406.         MenuItem {} {

  407.           label {64: Sustain}

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

  409.         }

  410.         MenuItem {} {

  411.           label {65: Portamento}

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

  413.         }

  414.         MenuItem {} {

  415.           label {71: Filter Q}

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

  417.         }

  418.         MenuItem {} {

  419.           label {74: Filter Freq.}

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

  421.         }

  422.         MenuItem {} {

  423.           label {75: Bandwidth}

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

  425.         }

  426.         MenuItem {} {

  427.           label {76: FM Gain}

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

  429.         }

  430.         MenuItem {} {

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

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

  433.         }

  434.         MenuItem {} {

  435.           label {78: Res. bw.}

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

  437.         }

  438.       }

  439.       Fl_Roller pitchwheelroller {

  440.         label Pwh

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

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

  443. pthread_mutex_unlock(&master->mutex);

  444. virkeys->take_focus();}

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

  446.       }

  447.       Fl_Button {} {

  448.         label R

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

  450. pitchwheelroller->do_callback();}

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

  452.       }

  453.       Fl_Dial {} {

  454.         label Vrnd

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

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

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

  458.         class WidgetPDial

  459.       }

  460.       Fl_Choice partrcv {

  461.         label {MIDI Ch.}

  462.         callback {relaseallkeys();

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

  464. virkeys->take_focus();} open

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

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

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

  468.       } {}

  469.     }

  470.   }

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

  472.     code {master=master_;

  473. midictl=75;

  474. make_window();} {}

  475.   }

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

  477.     code {delete virkeyboardwindow;} {}

  478.   }

  479.   Function {show()} {} {

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

  481.   }

  482.   Function {relaseallkeys()} {} {

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

  484.   }

  485.   decl {Master *master;} {}

  486.   decl {int midictl;} {}

  487. }