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.
979 Commits
16 Branches
14GB
Tree: 23b50976d6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '23b50976d6'
${ noResults }
Carla/source/modules/carla_native/zynaddsubfx/UI/MicrotonalUI.fl

271 lines
10KB
Raw Blame History 

  1. # data file for the Fltk User Interface Designer (fluid)

  2. version 1.0106 

  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 <stdio.h>} {public

  13. } 

  14. 

  15. decl {\#include <string.h>} {public

  16. } 

  17. 

  18. decl {\#include <FL/Fl_File_Chooser.H>} {public

  19. } 

  20. 

  21. decl {\#include <FL/fl_ask.H>} {public

  22. } 

  23. 

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

  25. } 

  26. 

  27. class MicrotonalUI {} {

  28.   Function {make_window()} {} {

  29.     Fl_Window microtonaluiwindow {

  30.       label Scales

  31.       xywh {99 164 405 450} type Double hide

  32.     } {

  33.       Fl_Group {} {

  34.         tooltip {Center where the note's freqs. are turned upside-down} xywh {249 2 155 45} box ENGRAVED_FRAME

  35.       } {

  36.         Fl_Check_Button {} {

  37.           label {Invert keys}

  38.           callback {microtonal->Pinvertupdown=(int) o->value();

  39. if (microtonal->Pinvertupdown==0) centerinvertcounter->deactivate();

  40.    else centerinvertcounter->activate();}

  41.           tooltip {Turn upside-down the note frequencies} xywh {254 13 55 30} down_box DOWN_BOX labelfont 1 labelsize 11 align 148

  42.           code0 {o->value(microtonal->Pinvertupdown);}

  43.         }

  44.         Fl_Counter centerinvertcounter {

  45.           label Center

  46.           callback {microtonal->Pinvertupdowncenter=(int) o->value();}

  47.           xywh {319 13 80 20} labelfont 1 labelsize 11 align 130 minimum 0 maximum 127 step 1 textfont 1

  48.           code0 {o->lstep(microtonal->getoctavesize());}

  49.           code1 {o->value(microtonal->Pinvertupdowncenter);}

  50.           code2 {if (microtonal->Pinvertupdown==0) o->deactivate();}

  51.         }

  52.       }

  53.       Fl_Group microtonalgroup {selected

  54.         xywh {3 49 402 398} box ENGRAVED_FRAME

  55.         code0 {if (microtonal->Penabled==0) o->deactivate();}

  56.       } {

  57.         Fl_Button applybutton {

  58.           label Retune

  59.           callback {apply();}

  60.           tooltip {Retune the synth accorging to the inputs from "Tunnings" and "Keyboard Mappings"} xywh {8 413 107 28} box THIN_UP_BOX labeltype EMBOSSED_LABEL labelfont 1 labelsize 13

  61.         }

  62.         Fl_Value_Output octavesizeoutput {

  63.           label {nts./oct.}

  64.           callback {o->value(microtonal->getoctavesize());}

  65.           tooltip {Notes/Octave} xywh {150 423 35 17} labelsize 10 align 5 maximum 500 step 1 value 12 textfont 1

  66.           code0 {o->value(microtonal->getoctavesize());}

  67.         }

  68.         Fl_Input nameinput {

  69.           label {Name:}

  70.           callback {snprintf((char *)microtonal->Pname,MICROTONAL_MAX_NAME_LEN,"%s",o->value());}

  71.           xywh {8 64 285 25} labelfont 1 labelsize 11 align 5

  72.           code0 {o->insert((char *)microtonal->Pname);}

  73.         }

  74.         Fl_Input tuningsinput {

  75.           label {Tunings:}

  76.           xywh {8 144 182 264} type Multiline labelfont 1 labelsize 11 align 5 when 2

  77.           code0 {updateTuningsInput();}

  78.         }

  79.         Fl_Input commentinput {

  80.           label {Comment:}

  81.           callback {snprintf((char *)microtonal->Pcomment,MICROTONAL_MAX_NAME_LEN,"%s",o->value());}

  82.           xywh {8 104 391 25} labelfont 1 labelsize 11 align 5

  83.           code0 {o->insert((char *)microtonal->Pcomment);}

  84.         }

  85.         Fl_Counter {} {

  86.           label Shift

  87.           callback {microtonal->Pscaleshift=(int) o->value()+64;}

  88.           xywh {313 69 70 20} type Simple labelsize 11 align 1 minimum -63 maximum 64 step 1 textfont 1

  89.           code0 {o->value(microtonal->Pscaleshift-64);}

  90.         }

  91.         Fl_Button {} {

  92.           label {Import .SCL file}

  93.           callback {const char *filename;

  94. filename=fl_file_chooser("Open:","(*.scl)",NULL,0);

  95. if (filename==NULL) return;

  96. int result=microtonal->loadscl(filename);

  97. if (result==0) {

  98.        updateTuningsInput();

  99.        nameinput->cut(0,nameinput->maximum_size());

  100.        nameinput->insert((char *)microtonal->Pname);

  101.        nameinput->position(0);

  102.        commentinput->cut(0,commentinput->maximum_size());

  103.        commentinput->insert((char *)microtonal->Pname);

  104.        commentinput->position(0);

  105.        tuningsinput->position(0);

  106.        octavesizeoutput->do_callback();

  107.      } else {

  108. 	fl_alert("Error: Could not load the file.");   

  109.      };}

  110.           tooltip {Inport Scala .scl file (tunnings)} xywh {243 411 84 15} box THIN_UP_BOX labelfont 1 labelsize 10

  111.         }

  112.         Fl_Group keymappinggroup {

  113.           label {Keyboard Mapping} open

  114.           xywh {193 144 206 264} box ENGRAVED_BOX labelfont 1 labelsize 11

  115.         } {

  116.           Fl_Input mappinginput {

  117.             xywh {250 147 146 258} type Multiline labelfont 1 labelsize 11 align 5 when 2

  118.             code0 {updateMappingInput();}

  119.           }

  120.           Fl_Counter firstnotecounter {

  121.             label {First note}

  122.             callback {microtonal->Pfirstkey=(int) o->value();}

  123.             tooltip {First MIDI note number} xywh {199 195 42 18} type Simple labelsize 10 align 5 minimum 0 maximum 127 step 1 textfont 1 textsize 11

  124.             code0 {o->value(microtonal->Pfirstkey);}

  125.           }

  126.           Fl_Counter lastnotecounter {

  127.             label {Last note}

  128.             callback {microtonal->Plastkey=(int) o->value();}

  129.             tooltip {Last MIDI note number} xywh {199 225 42 18} type Simple labelsize 10 align 5 minimum 0 maximum 127 step 1 value 127 textfont 1 textsize 11

  130.             code0 {o->value(microtonal->Plastkey);}

  131.           }

  132.           Fl_Counter middlenotecounter {

  133.             label {Midle note}

  134.             callback {microtonal->Pmiddlenote=(int) o->value();}

  135.             tooltip {Midle note (where scale degree 0 is mapped to)} xywh {199 267 42 18} type Simple labelsize 10 align 5 minimum 0 maximum 127 step 1 value 60 textfont 1 textsize 11

  136.             code0 {o->value(microtonal->Pmiddlenote);}

  137.           }

  138.           Fl_Value_Output mapsizeoutput {

  139.             label {Map Size}

  140.             callback {o->value(microtonal->Pmapsize);}

  141.             xywh {201 382 44 20} labelsize 10 align 5 maximum 500 step 1 value 12 textfont 1

  142.             code0 {o->value(microtonal->Pmapsize);}

  143.           }

  144.         }

  145.         Fl_Check_Button mappingenabledbutton {

  146.           label ON

  147.           callback {int x=(int) o->value();

  148. microtonal->Pmappingenabled=x;

  149. if (x==0) keymappinggroup->deactivate();

  150.  else keymappinggroup->activate();

  151. o->show();}

  152.           tooltip {Enable the Mapping (otherwise the mapping is linear)} xywh {198 150 48 21} box FLAT_BOX down_box DOWN_BOX labelfont 1

  153.           code0 {o->value(microtonal->Pmappingenabled);}

  154.           code1 {if (microtonal->Pmappingenabled==0) keymappinggroup->deactivate();}

  155.         }

  156.         Fl_Button {} {

  157.           label {Import .kbm file}

  158.           callback {const char *filename;

  159. filename=fl_file_chooser("Open:","(*.kbm)",NULL,0);

  160. if (filename==NULL) return;

  161. int result=microtonal->loadkbm(filename);

  162. if (result==0) {

  163.        updateMappingInput();

  164.        mappinginput->position(0);

  165.        mapsizeoutput->do_callback();

  166.        firstnotecounter->value(microtonal->Pfirstkey);

  167.        lastnotecounter->value(microtonal->Plastkey);

  168.        middlenotecounter->value(microtonal->Pmiddlenote);

  169.        mapsizeoutput->do_callback();

  170.        mappingenabledbutton->value(microtonal->Pmappingenabled);

  171.        mappingenabledbutton->do_callback();

  172.        afreqinput->value(microtonal->PAfreq);

  173.        anotecounter->value(microtonal->PAnote);

  174.        anotecounter->do_callback();

  175.      } else {

  176. 	fl_alert("Error: Could not load the file.");   

  177.      };}

  178.           tooltip {Inport Scala .kbm file (keyboard mapping)} xywh {243 428 84 16} box THIN_UP_BOX labelfont 1 labelsize 10

  179.         }

  180.       }

  181.       Fl_Group {} {

  182.         xywh {108 2 140 45} box ENGRAVED_FRAME

  183.       } {

  184.         Fl_Counter anotecounter {

  185.           label {"A" Note}

  186.           callback {microtonal->PAnote=(int) o->value();

  187. if (microtonal->getnotefreq(microtonal->PAnote,0)<0.0) o->textcolor(FL_RED);

  188.  else o->textcolor(FL_BLACK);

  189. 

  190. o->redraw();}

  191.           tooltip {The "A" note (the reference note for which freq. ("A" freq) is given)} xywh {173 17 65 20} labelfont 1 labelsize 10 align 129 minimum 0 maximum 127 step 1 value 69 textfont 1 textsize 10

  192.           code0 {o->lstep(12);}

  193.           code1 {o->value(microtonal->PAnote);}

  194.         }

  195.         Fl_Value_Input afreqinput {

  196.           label {"A" Freq.}

  197.           callback {microtonal->PAfreq=o->value();}

  198.           tooltip {The freq. of "A" note (default=440.0)} xywh {118 17 45 20} labelfont 1 labelsize 10 align 1 minimum 1 maximum 20000 step 0.001 value 440 textfont 1 textsize 10

  199.           code0 {o->value(microtonal->PAfreq);}

  200.         }

  201.       }

  202.       Fl_Button {} {

  203.         label Close

  204.         callback {microtonaluiwindow->hide();}

  205.         xywh {333 413 67 28} box THIN_UP_BOX

  206.       }

  207.       Fl_Check_Button {} {

  208.         label {Enable Microtonal}

  209.         callback {microtonal->Penabled=(int) o->value();

  210. if (microtonal->Penabled==0) microtonalgroup->deactivate();

  211.    else microtonalgroup->activate();}

  212.         xywh {3 3 102 45} box UP_BOX down_box DOWN_BOX labelfont 1 labelsize 11 align 148

  213.         code0 {o->value(microtonal->Penabled);}

  214.       }

  215.     }

  216.   }

  217.   Function {updateTuningsInput()} {} {

  218.     code {char *tmpbuf=new char[100];

  219. 

  220. tuningsinput->cut(0,tuningsinput->maximum_size());

  221. 

  222. for (int i=0;i<microtonal->getoctavesize();i++){

  223.    if (i!=0) tuningsinput->insert("\\n");

  224.    microtonal->tuningtoline(i,tmpbuf,100);

  225.    tuningsinput->insert(tmpbuf);

  226. };

  227. 

  228. delete []tmpbuf;} {}

  229.   }

  230.   Function {updateMappingInput()} {} {

  231.     code {char *tmpbuf=new char[100];

  232. 

  233. mappinginput->cut(0,tuningsinput->maximum_size());

  234. 

  235. for (int i=0;i<microtonal->Pmapsize;i++){

  236.    if (i!=0) mappinginput->insert("\\n");

  237.    if ((microtonal->Pmapping[i])==-1)

  238.         snprintf(tmpbuf,100,"x");

  239.    else snprintf(tmpbuf,100,"%d",microtonal->Pmapping[i]);

  240.    mappinginput->insert(tmpbuf);

  241. };

  242. 

  243. delete []tmpbuf;} {}

  244.   }

  245.   Function {MicrotonalUI(Microtonal *microtonal_)} {} {

  246.     code {microtonal=microtonal_;

  247. 

  248. make_window();} {}

  249.   }

  250.   Function {~MicrotonalUI()} {} {

  251.     code {microtonaluiwindow->hide();

  252. delete(microtonaluiwindow);} {}

  253.   }

  254.   Function {show()} {} {

  255.     code {microtonaluiwindow->show();} {}

  256.   }

  257.   Function {apply()} {} {

  258.     code {int err=microtonal->texttotunings(tuningsinput->value());

  259. if (err>=0) fl_alert("Parse Error: The input may contain only numbers (like 232.59)\\n or divisions (like 121/64).");

  260. if (err==-2) fl_alert("Parse Error: The input is empty.");

  261. octavesizeoutput->do_callback();

  262. 

  263. microtonal->texttomapping(mappinginput->value());

  264. mapsizeoutput->do_callback();

  265. anotecounter->do_callback();

  266. 

  267. //applybutton->color(FL_GRAY);} {}

  268.   }

  269.   decl {Microtonal *microtonal;} {}

  270. }