non
/
paulstretch_cpp
mirror of https://github.com/original-male/paulstretch_cpp
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
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.
1 Commit
1 Branch
119KB
Tree: 1a9012c39a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1a9012c39a'
${ noResults }
paulstretch_cpp/GUI.fl

934 lines
29KB
Raw Blame History 

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

  2. version 1.0110 

  3. header_name {.h} 

  4. code_name {.cxx}

  5. decl {//Copyright (c) Nasca Octavian Paul. Released under GNU General Public License version 2} {public

  6. } 

  7. 

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

  9. 

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

  11. } 

  12. 

  13. decl {\#include <FL/Fl_Group.H>} {public

  14. } 

  15. 

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

  17. } 

  18. 

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

  20. } 

  21. 

  22. decl {\#include <FL/Fl_Value_Input.H>} {public

  23. } 

  24. 

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

  26. } 

  27. 

  28. decl {\#include<sys/stat.h>} {} 

  29. 

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

  31. 

  32. decl {\#include <string>} {} 

  33. 

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

  35. 

  36. decl {\#include "Control.h"} {public

  37. } 

  38. 

  39. decl {\#include "FreeEditUI.h"} {public

  40. } 

  41. 

  42. decl {\#include "version.h"} {public

  43. } 

  44. 

  45. Function {hex4n(char c)} {return_type int

  46. } {

  47.   code {if (c>96) c-=32;

  48. if ((c>='0')||(c<='9')) return (c-'0');

  49. if ((c>='A')||(c<='F')) return (c-'A')+10;

  50. 

  51. return 0;} {}

  52. } 

  53. 

  54. Function {unescape(std::string s)} {return_type {std::string}

  55. } {

  56.   code {std::string result;

  57. int slen=s.size();

  58. s+="    ";

  59. int sk=0;

  60. while (sk<slen){

  61. 	char c=s[sk];

  62. 	if (c=='%'){

  63. 		char c1=s[++sk];

  64. 		char c2=s[++sk];

  65. 		result+=(char)(16*hex4n(c1)+hex4n(c2));

  66. 		sk++;

  67. 	}else{

  68. 		result+=c;

  69. 		sk++;

  70. 	};

  71. };

  72. 

  73. 

  74. //printf("%s\\n%s\\n",s.c_str(),result.c_str());

  75. return result;} {}

  76. } 

  77. 

  78. class DDBox {: {public Fl_Box}

  79. } {

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

  81.   } {

  82.     code {new_drag_file=false;} {}

  83.   }

  84.   Function {handle(int event)} {open return_type int

  85.   } {

  86.     code {if ((event==FL_DND_ENTER)||(event==FL_DND_DRAG)||(event==FL_DND_RELEASE)) return 1;

  87. if (event==FL_PASTE){

  88. 	const char *url=Fl::event_text();

  89. 	if (strstr(url,"file://")!=url) return 0;//is not a file

  90. 	std::string filename=url+7;

  91. 	for (int i=0;i<filename.size();i++) if (filename[i]<32) filename[i]=0;

  92. 	drag_file=unescape(filename);

  93. 	new_drag_file=true;

  94. 	return 1;

  95. };

  96. return Fl_Box::handle(event);} {}

  97.   }

  98.   decl {std::string drag_file;} {public

  99.   }

  100.   decl {bool new_drag_file;} {public

  101.   }

  102. } 

  103. 

  104. class GUI {open

  105. } {

  106.   decl {enum Mode {STOP,PLAY,PAUSE,FREEZE};} {}

  107.   Function {GUI()} {} {

  108.     code {playing_for_button=false;

  109. eof_for_button=false;

  110. rendering=false;

  111. make_window();

  112. tick(this);

  113. refresh();

  114. set_mode(STOP);} {}

  115.   }

  116.   Function {~GUI()} {} {

  117.     code {Fl::remove_timeout(tick,this);} {}

  118.   }

  119.   Function {open_input_file(const char *filename)} {open

  120.   } {

  121.     code {const char *ext=fl_filename_ext(filename);

  122. FILE_TYPE intype=FILE_WAV;

  123. if ((strcmp(ext,".ogg")==0)||(strcmp(ext,".OGG")==0)||(strcmp(ext,".Ogg")==0)) intype=FILE_VORBIS;

  124. if ((strcmp(ext,".mp3")==0)||(strcmp(ext,".MP3")==0)||(strcmp(ext,".Mp3")==0)) intype=FILE_MP3;

  125. bool result=control.set_input_filename(filename,intype);

  126. if (result) {

  127. 	infilename_output->copy_label(control.get_input_filename_and_info().c_str());

  128. } else {

  129. 	infilename_output->copy_label("");

  130. 	fl_alert("Error: Could not open audio file:\\n%s",filename);

  131. };

  132. refresh();} {}

  133.   }

  134.   Function {render()} {open

  135.   } {

  136.     code {render_button->deactivate();

  137. rendering=true;

  138. render_percent_slider->value(0);

  139. render_percent_slider->activate();

  140. cancel_render_button->activate();

  141. //char defaultfile[FL_PATH_MAX];

  142. //fl_filename_absolute(defaultfile,control.get_recommanded_output_filename().c_str());

  143. Fl_File_Chooser *fc=new Fl_File_Chooser(NULL,"Wave files (*.wav)\\tOgg Vorbis (*.ogg)",Fl_File_Chooser::CREATE,"Render to audio file...");

  144. 

  145. fc->preview(0);

  146. fc->filter_value(0);

  147. fc->ok_label("Render");

  148. fc->show();

  149. while (fc->visible()){

  150. 	Fl::wait();

  151. };

  152. 

  153. const char *newfile = fc->value();

  154.   if (newfile != NULL) {  	

  155.   	if (file_exists(newfile)){

  156.   		if (!fl_choice("The file exists. \\nOverwrite it?","No","Yes",NULL)) return;

  157.   	};

  158. 

  159. 	FILE_TYPE type=FILE_WAV;

  160. 	if (fc->filter_value()==1)  type=FILE_VORBIS;

  161. 	const char *ext=fl_filename_ext(newfile);

  162. 	std::string outfilename=newfile;

  163. 	if (strlen(ext)==0){

  164. 		if (type==FILE_VORBIS) outfilename+=".ogg";

  165. 			else outfilename+=".wav";

  166. 	};

  167. 	render_percent_slider->copy_label(outfilename.c_str());

  168. 	FILE_TYPE intype=FILE_WAV;

  169. 	{

  170. 		const char *ext=fl_filename_ext(control.get_input_filename().c_str());

  171.  		if ((strcmp(ext,".ogg")==0)||(strcmp(ext,".OGG")==0)||(strcmp(ext,".Ogg")==0)) intype=FILE_VORBIS;

  172.  		if ((strcmp(ext,".MP3")==0)||(strcmp(ext,".mp3")==0)||(strcmp(ext,".Mp3")==0)) intype=FILE_MP3;

  173.   	};

  174. 	const char *outstr=control.Render(control.get_input_filename(),outfilename,type,intype,

  175. 		selection_pos1->value()/100.0,selection_pos2->value()/100.0).c_str();

  176. 	if (strlen(outstr)!=0) fl_alert("%s",outstr);

  177.   };

  178. 

  179. delete fc;

  180. render_button->activate();

  181. render_percent_slider->value(0);

  182. render_percent_slider->deactivate();

  183. render_percent_slider->label("");

  184. cancel_render_button->deactivate();

  185. rendering=false;} {}

  186.   }

  187.   Function {make_window()} {open private

  188.   } {

  189.     Fl_Window window {

  190.       label {Paul's Extreme Sound Stretch} open

  191.       xywh {54 265 995 550} type Double resizable

  192.       code0 {if(strlen(VERSION)<2) {o->color(FL_BLUE); o->label("VERSION NOT SET!!!!!!!!!!!!");};} visible

  193.     } {

  194.       Fl_Menu_Bar {} {open

  195.         xywh {0 0 1015 20}

  196.       } {

  197.         Submenu {} {

  198.           label File open

  199.           xywh {0 0 63 20}

  200.         } {

  201.           MenuItem {} {

  202.             label {Open audio file...}

  203.             callback {char *newfile = fl_file_chooser("Open Audio(ogg,wav,mp3) File?", NULL, NULL);

  204.   if (newfile != NULL) {

  205.   	open_input_file(newfile);

  206.   	

  207.   };

  208.   selection_pos1->value(0.0);

  209.   selection_pos2->value(100.0);

  210. 

  211.   refresh();}

  212.             xywh {0 0 30 20}

  213.           }

  214.           MenuItem render_menu {

  215.             label {Render and save audio file...}

  216.             callback {selection_pos1->value(0.0);

  217. selection_pos2->value(100.0);

  218. tabs_widget->value(write_to_file_group);

  219. render();}

  220.             xywh {10 10 30 20} deactivate divider

  221.           }

  222.           MenuItem {} {

  223.             label {Open Parameters...}

  224.             callback {char *newfile = fl_file_chooser("Open Parameter File?", "PaulStretch XML (*.psx)\\tAll Files (*)", NULL);

  225.   if (newfile != NULL) {

  226. 	set_mode(STOP);

  227. 	control.stopplay();

  228.  

  229.   	if (!control.load_parameters(newfile)){

  230.   		fl_alert("Error: Could not load parameter file:\\n%s",newfile);

  231.   	};

  232.   };

  233.   refreshgui();

  234.   refresh();}

  235.             xywh {10 10 30 20}

  236.           }

  237.           MenuItem {} {

  238.             label {Save Parameters...}

  239.             callback {char *newfile = fl_file_chooser("Save Parameters(paulstretch) File?", "PaulStretch XML (*.psx)\\tAll Files (*)", NULL);

  240.   if (newfile != NULL) {

  241.   	if (file_exists(newfile)){

  242.   		if (!fl_choice("The file exists. \\nOverwrite it?","No","Yes",NULL)) return;

  243.   	};

  244.   	control.save_parameters(newfile);

  245.   };

  246.   refresh();}

  247.             xywh {20 20 30 20} divider

  248.           }

  249.           MenuItem {} {

  250.             label Exit

  251.             callback {window->hide();}

  252.             xywh {0 0 30 20}

  253.           }

  254.         }

  255.         Submenu {} {

  256.           label About

  257.           xywh {15 15 63 20}

  258.         } {

  259.           MenuItem {} {

  260.             label {About...}

  261.             callback {aboutwindow->show();}

  262.             xywh {15 15 30 20}

  263.           }

  264.         }

  265.       }

  266.       Fl_Tabs tabs_widget {open

  267.         xywh {5 50 985 420} box BORDER_BOX

  268.       } {

  269.         Fl_Group {} {

  270.           label Parameters open selected

  271.           xywh {5 70 985 400}

  272.         } {

  273.           Fl_Slider stretch_slider {

  274.             label {Stretch:}

  275.             callback {refresh();

  276. control.update_player_stretch();}

  277.             xywh {10 89 975 15} type {Horz Knob} box FLAT_BOX align 6 value 0.29

  278.           }

  279.           Fl_Slider fftsize_slider {

  280.             label {Window Size:}

  281.             callback {refresh();

  282. o->labelcolor(FL_BLUE);}

  283.             xywh {10 155 975 15} type {Horz Knob} box FLAT_BOX align 6 value 0.47

  284.           }

  285.           Fl_Choice mode_choice {

  286.             label {Mode:}

  287.             callback {refresh();}

  288.             xywh {850 110 135 20} down_box BORDER_BOX

  289.           } {

  290.             MenuItem {} {

  291.               label Stretch

  292.               xywh {10 10 30 20}

  293.             }

  294.             MenuItem {} {

  295.               label HyperStretch

  296.               xywh {20 20 30 20}

  297.             }

  298.             MenuItem {} {

  299.               label Shorten

  300.               xywh {0 0 30 20}

  301.             }

  302.           }

  303.           Fl_Choice window_choice {

  304.             label {Type:}

  305.             callback {FFTWindow w=W_RECTANGULAR;

  306. switch(o->value()){

  307. 	case 0:

  308. 	   w=W_RECTANGULAR;

  309. 	   break;

  310. 	case 1:

  311. 	   w=W_HAMMING;

  312. 	   break;

  313. 	case 2:

  314. 	   w=W_HANN;

  315. 	   break;

  316. 	case 3:

  317. 	   w=W_BLACKMAN;

  318. 	   break;

  319. 	case 4:

  320. 	   w=W_BLACKMAN_HARRIS;

  321. 	   break;

  322. };

  323. 

  324. control.set_window_type(w);

  325. refresh();}

  326.             xywh {850 185 135 20} down_box BORDER_BOX when 1

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

  328.           } {

  329.             MenuItem {} {

  330.               label Rectangular

  331.               xywh {40 40 30 20}

  332.             }

  333.             MenuItem {} {

  334.               label Hamming

  335.               xywh {30 30 30 20}

  336.             }

  337.             MenuItem {} {

  338.               label Hann

  339.               xywh {10 10 30 20}

  340.             }

  341.             MenuItem {} {

  342.               label Blackman

  343.               xywh {20 20 30 20}

  344.             }

  345.             MenuItem {} {

  346.               label BlackmanHarris

  347.               xywh {30 30 30 20}

  348.             }

  349.           }

  350.           Fl_Button {} {

  351.             label S

  352.             callback {char tmp[100];

  353. snprintf(tmp,100,"%g",control.get_stretch());

  354. const char *result=fl_input("Enter the stretch value",tmp);

  355. if (!result) return;

  356. 

  357. double str=atof(result);

  358. if (str<1e-4) return;

  359. 

  360. double stc=control.get_stretch_control(str,mode_choice->value());

  361. 

  362. if ((stc<1e-4)||(stc>1.0)) return;

  363. stretch_slider->value(stc);

  364. stretch_slider->do_callback();}

  365.             tooltip {set the stretch to a value} xywh {780 110 20 20}

  366.           }

  367.           Fl_Box resolution_box {

  368.             xywh {10 187 790 18} box FLAT_BOX color 52 align 20

  369.           }

  370.           Fl_Group {} {

  371.             label {Stretch Multiplier} open

  372.             xywh {10 245 975 220} box THIN_UP_BOX labeltype ENGRAVED_LABEL

  373.           } {

  374.             Fl_Box stretch_free_edit {

  375.               label Graph

  376.               xywh {105 250 875 210} box FLAT_BOX color 17

  377.               code0 {o->init(&control.ppar.stretch_multiplier,&control);}

  378.               class FreeEditUI

  379.             }

  380.             Fl_Group stretch_multiplier_control {open

  381.               xywh {15 250 85 210} box BORDER_FRAME color 0 align 208

  382.               code0 {o->init(stretch_free_edit,FE_LINEAR,0,100.0,FE_LOG,0.1,50.0,1.0);}

  383.               class FreeEditControls

  384.             } {}

  385.           }

  386.         }

  387.         Fl_Group {} {

  388.           label Process

  389.           xywh {5 70 985 400} hide

  390.         } {

  391.           Fl_Group {} {open

  392.             xywh {165 75 105 65} box BORDER_BOX

  393.           } {

  394.             Fl_Check_Button pitch_shift_enabled {

  395.               label {Pitch Shift}

  396.               callback {control.ppar.pitch_shift.enabled=o->value();

  397. control.update_process_parameters();}

  398.               xywh {170 80 90 15} down_box DOWN_BOX labelfont 1

  399.             }

  400.             Fl_Counter pitch_shift_cents {

  401.               label cents

  402.               callback {control.ppar.pitch_shift.cents=(int)o->value();

  403. control.update_process_parameters();}

  404.               xywh {170 100 90 20} minimum -3600 maximum 3600 step 1

  405.               code0 {o->lstep(100);}

  406.             }

  407.           }

  408.           Fl_Group {} {open

  409.             xywh {275 75 135 100} box BORDER_BOX

  410.           } {

  411.             Fl_Check_Button octave_enabled {

  412.               label {Octave Mixer}

  413.               callback {control.ppar.octave.enabled=o->value();

  414. control.update_process_parameters();}

  415.               xywh {280 80 110 15} down_box DOWN_BOX labelfont 1

  416.             }

  417.             Fl_Slider octave_om2 {

  418.               label {-2}

  419.               callback {control.ppar.octave.om2=pow(o->value(),2.0);

  420. control.update_process_parameters();}

  421.               tooltip {2 octaves below} xywh {280 100 15 55} type {Vert Knob} minimum 1 maximum 0

  422.             }

  423.             Fl_Slider octave_om1 {

  424.               label {-1}

  425.               callback {control.ppar.octave.om1=pow(o->value(),2.0);

  426. control.update_process_parameters();}

  427.               tooltip {1 octave below} xywh {300 100 15 55} type {Vert Knob} minimum 1 maximum 0

  428.             }

  429.             Fl_Slider octave_o0 {

  430.               label 0

  431.               callback {control.ppar.octave.o0=pow(o->value(),2.0);

  432. control.update_process_parameters();}

  433.               tooltip {original (dry)} xywh {320 100 15 55} type {Vert Knob} minimum 1 maximum 0 value 1

  434.             }

  435.             Fl_Slider octave_o1 {

  436.               label 1

  437.               callback {control.ppar.octave.o1=pow(o->value(),2.0);

  438. control.update_process_parameters();}

  439.               tooltip {1 octave above} xywh {340 100 15 55} type {Vert Knob} minimum 1 maximum 0

  440.             }

  441.             Fl_Slider octave_o15 {

  442.               label {1.5}

  443.               callback {control.ppar.octave.o15=pow(o->value(),2.0);

  444. control.update_process_parameters();}

  445.               tooltip {3rd harmonic} xywh {360 100 15 55} type {Vert Knob} minimum 1 maximum 0

  446.             }

  447.             Fl_Slider octave_o2 {

  448.               label 2

  449.               callback {control.ppar.octave.o2=pow(o->value(),2.0);

  450. control.update_process_parameters();}

  451.               tooltip {2 octaves above} xywh {380 100 15 55} type {Vert Knob} minimum 1 maximum 0

  452.             }

  453.           }

  454.           Fl_Group {} {open

  455.             xywh {165 140 105 65} box BORDER_BOX

  456.           } {

  457.             Fl_Check_Button freq_shift_enabled {

  458.               label {Freq Shift}

  459.               callback {control.ppar.freq_shift.enabled=o->value();

  460. control.update_process_parameters();}

  461.               xywh {170 145 90 15} down_box DOWN_BOX labelfont 1

  462.             }

  463.             Fl_Counter freq_shift_Hz {

  464.               label Hz

  465.               callback {control.ppar.freq_shift.Hz=(int)o->value();

  466. control.update_process_parameters();}

  467.               xywh {170 165 90 20} minimum -10000 maximum 10000 step 1

  468.               code0 {o->lstep(100);}

  469.             }

  470.           }

  471.           Fl_Group {} {open

  472.             xywh {605 75 120 65} box BORDER_BOX

  473.           } {

  474.             Fl_Check_Button compressor_enabled {

  475.               label Compress

  476.               callback {control.ppar.compressor.enabled=o->value();

  477. control.update_process_parameters();}

  478.               xywh {610 80 90 15} down_box DOWN_BOX labelfont 1

  479.             }

  480.             Fl_Slider compressor_power {

  481.               label Power

  482.               callback {control.ppar.compressor.power=o->value();

  483. control.update_process_parameters();}

  484.               xywh {610 100 110 15} type {Horz Knob}

  485.             }

  486.           }

  487.           Fl_Slider {} {

  488.             label Volume

  489.             callback {REALTYPE x=o->value();

  490. x=pow(10.0,pow(x,1.5)-1.0)-0.1;

  491. control.set_volume(x);}

  492.             xywh {605 155 120 40} type {Horz Knob} labelfont 1 minimum 0.3 maximum 1.6 value 1

  493.           }

  494.           Fl_Group {} {open

  495.             xywh {415 75 185 100} box BORDER_BOX

  496.           } {

  497.             Fl_Check_Button filter_enabled {

  498.               label Filter

  499.               callback {control.ppar.filter.enabled=o->value();

  500. control.update_process_parameters();}

  501.               xywh {420 80 70 15} down_box DOWN_BOX labelfont 1

  502.             }

  503.             Fl_Value_Input filter_low {

  504.               label {Freq1(Hz)}

  505.               callback {control.ppar.filter.low=o->value();

  506. control.update_process_parameters();}

  507.               xywh {420 101 100 24} align 8 maximum 10000

  508.             }

  509.             Fl_Value_Input filter_high {

  510.               label {Freq2(Hz)}

  511.               callback {control.ppar.filter.high=o->value();

  512. control.update_process_parameters();}

  513.               xywh {420 126 100 24} align 8 maximum 25000 value 22000

  514.             }

  515.             Fl_Check_Button filter_stop {

  516.               label BandStop

  517.               callback {control.ppar.filter.stop=o->value();

  518. control.update_process_parameters();}

  519.               tooltip {band-stop filter} xywh {500 80 90 15} down_box DOWN_BOX

  520.             }

  521.             Fl_Slider filter_hdamp {

  522.               label DHF

  523.               callback {control.ppar.filter.hdamp=o->value();

  524. control.update_process_parameters();}

  525.               tooltip {Damp High Frequency} xywh {420 155 140 15} type {Horz Knob} align 8

  526.             }

  527.           }

  528.           Fl_Group {} {open

  529.             xywh {10 75 150 120} box BORDER_BOX

  530.           } {

  531.             Fl_Check_Button harmonics_enabled {

  532.               label Harmonics

  533.               callback {control.ppar.harmonics.enabled=o->value();

  534. control.update_process_parameters();}

  535.               xywh {15 80 95 15} down_box DOWN_BOX labelfont 1

  536.             }

  537.             Fl_Value_Input harmonics_freq {

  538.               label {F.Freq(Hz)}

  539.               callback {control.ppar.harmonics.freq=o->value();

  540. control.update_process_parameters();}

  541.               tooltip {fundamental frequency} xywh {15 101 65 24} align 8 minimum 1 maximum 20000 value 440

  542.             }

  543.             Fl_Value_Input harmonics_bandwidth {

  544.               label {BW(cents)}

  545.               callback {control.ppar.harmonics.bandwidth=o->value();

  546. control.update_process_parameters();}

  547.               tooltip {bandwidth (cents)} xywh {15 126 65 24} align 8 minimum 0.1 maximum 200 value 25

  548.             }

  549.             Fl_Check_Button harmonics_gauss {

  550.               label Gauss

  551.               callback {control.ppar.harmonics.gauss=o->value();

  552. control.update_process_parameters();}

  553.               tooltip {smooth the harmonics} xywh {85 155 65 15} down_box DOWN_BOX

  554.             }

  555.             Fl_Counter harmonics_nharmonics {

  556.               label {no.hrm.}

  557.               callback {control.ppar.harmonics.nharmonics=(int)o->value();

  558. control.update_process_parameters();}

  559.               tooltip {number of harmonics} xywh {15 155 56 20} type Simple minimum 1 maximum 100 step 1 value 10

  560.             }

  561.           }

  562.           Fl_Group {} {open

  563.             xywh {275 180 325 40} box BORDER_BOX

  564.           } {

  565.             Fl_Check_Button spread_enabled {

  566.               label Spread

  567.               callback {control.ppar.spread.enabled=o->value();

  568. control.update_process_parameters();}

  569.               xywh {280 185 90 15} down_box DOWN_BOX labelfont 1

  570.             }

  571.             Fl_Slider spread_bandwidth {

  572.               label Bandwidth

  573.               callback {control.ppar.spread.bandwidth=o->value();

  574. control.update_process_parameters();}

  575.               xywh {360 185 230 15} type {Horz Knob} value 0.3

  576.             }

  577.           }

  578.           Fl_Group {} {

  579.             label ArbitraryFilter

  580.             xywh {10 245 975 220} box THIN_UP_BOX labeltype ENGRAVED_LABEL

  581.           } {

  582.             Fl_Box filter_free_edit {

  583.               label Graph

  584.               xywh {105 250 875 210} box FLAT_BOX color 206 selection_color 0

  585.               code0 {o->init(&control.ppar.free_filter,&control);}

  586.               class FreeEditUI

  587.             }

  588.             Fl_Group arbitrary_filter_control {open

  589.               xywh {15 250 85 210} box BORDER_FRAME color 0 align 208

  590.               code0 {o->init(filter_free_edit,FE_LOG,20.0,25000.0,FE_DB,-60,20,0.0);}

  591.               class FreeEditControls

  592.             } {}

  593.           }

  594.         }

  595.         Fl_Group {} {

  596.           label {Binaural beats}

  597.           xywh {5 70 985 400} box THIN_UP_BOX hide

  598.         } {

  599.           Fl_Box binaural_free_edit {

  600.             label Graph

  601.             xywh {135 75 845 390} box FLAT_BOX color 135

  602.             code0 {o->init(&control.bbpar.free_edit,&control);}

  603.             class FreeEditUI

  604.           }

  605.           Fl_Slider bbpar_mono {

  606.             label Pow

  607.             callback {control.bbpar.mono=o->value();

  608. control.update_process_parameters();}

  609.             xywh {105 75 20 190} type {Vert Knob} labelfont 1 minimum 1 maximum 0 value 0.5

  610.           }

  611.           Fl_Group binaural_beats_control {

  612.             label {FreeEdit Controls}

  613.             xywh {10 75 80 205} box BORDER_FRAME color 47 align 208

  614.             code0 {o->init(binaural_free_edit,FE_LINEAR,0,100.0,FE_LOG,0.1,50.0,8.0);}

  615.             class FreeEditControls

  616.           } {}

  617.           Fl_Choice bbpar_stereo_mode {

  618.             label {Stereo Mode}

  619.             callback {control.bbpar.stereo_mode=(BB_STEREO_MODE)o->value();

  620. control.update_process_parameters();}

  621.             xywh {10 305 110 20} down_box BORDER_BOX align 5

  622.           } {

  623.             MenuItem {} {

  624.               label LeftRight

  625.               xywh {10 10 36 21} labelfont 1

  626.             }

  627.             MenuItem {} {

  628.               label RightLeft

  629.               xywh {20 20 36 21} labelfont 1

  630.             }

  631.             MenuItem {} {

  632.               label Symmetric

  633.               xywh {30 30 36 21} labelfont 1

  634.             }

  635.           }

  636.         }

  637.         Fl_Group write_to_file_group {

  638.           label {Write to file} open

  639.           xywh {5 70 985 400} hide

  640.         } {

  641.           Fl_Button render_button {

  642.             label {Render selection...}

  643.             callback {render();}

  644.             xywh {250 95 320 30} labelfont 1 labelsize 22

  645.           }

  646.           Fl_Value_Slider render_percent_slider {

  647.             label { }

  648.             xywh {15 245 970 65} type {Horz Fill} selection_color 4 align 70 maximum 100 step 0.1 textsize 14

  649.           }

  650.           Fl_Button cancel_render_button {

  651.             label Cancel

  652.             callback {if (fl_choice("Cancel audio rendering?","No","Yes",NULL)) control.info.cancel_render=true;}

  653.             xywh {400 365 145 25} deactivate

  654.           }

  655.           Fl_Button {} {

  656.             label {selection pos1}

  657.             callback {selection_pos1->value(seek_slider->value());}

  658.             tooltip {set selection start from Player's position} xywh {20 85 110 20} align 20

  659.           }

  660.           Fl_Button {} {

  661.             label {selection pos2}

  662.             callback {selection_pos2->value(seek_slider->value());}

  663.             tooltip {set selection end from Player's position} xywh {20 110 110 20} align 20

  664.           }

  665.           Fl_Button {} {

  666.             label {select all}

  667.             callback {selection_pos1->value(0.0);

  668. selection_pos2->value(100.0);}

  669.             tooltip {select the whole sound} xywh {20 135 110 20}

  670.           }

  671.           Fl_Value_Output selection_pos1 {

  672.             label {%}

  673.             xywh {135 85 70 20} align 72 maximum 100 step 0.01 textfont 1

  674.           }

  675.           Fl_Value_Output selection_pos2 {

  676.             label {%}

  677.             xywh {135 111 70 18} align 72 maximum 100 step 0.01 value 100 textfont 1

  678.           }

  679.           Fl_Check_Button {} {

  680.             label 32bit

  681.             callback {control.wav32bit=o->value();}

  682.             xywh {250 135 100 15} down_box DOWN_BOX

  683.           }

  684.         }

  685.       }

  686.       Fl_Box infilename_output {

  687.         tooltip {drag audio file here to open it} xywh {5 24 1005 22} box FLAT_BOX color 17 align 84

  688.         class DDBox

  689.       }

  690.       Fl_Group {} {

  691.         xywh {5 475 985 70} box BORDER_BOX

  692.       } {

  693.         Fl_Group {} {open

  694.           xywh {10 490 190 40} box THIN_UP_BOX color 16

  695.         } {

  696.           Fl_Button play_button {

  697.             label {@>}

  698.             callback {if (control.playing_eof()&&(seek_slider->value()>99.0)){

  699. 	seek_slider->value(0.0);

  700. 	seek_slider->do_callback();

  701. };

  702. set_mode(PLAY);

  703. playing_for_button=true;

  704. eof_for_button=true;

  705. 

  706. bool bypass=false;

  707. if (Fl::event_button()==FL_RIGHT_MOUSE) bypass=true;

  708. 

  709. control.startplay(bypass);}

  710.             tooltip Play xywh {20 500 40 20} box PLASTIC_UP_BOX

  711.           }

  712.           Fl_Button freeze_button {

  713.             label {@<-> F}

  714.             callback {control.freezeplay();

  715. set_mode(FREEZE);}

  716.             tooltip Freeze xywh {65 500 40 20} box PLASTIC_UP_BOX

  717.           }

  718.           Fl_Button {} {

  719.             label {@||}

  720.             callback {set_mode(PAUSE);

  721. control.pauseplay();}

  722.             tooltip Pause xywh {110 500 40 20} box PLASTIC_UP_BOX

  723.           }

  724.           Fl_Button {} {

  725.             label {@square}

  726.             callback {set_mode(STOP);

  727. control.stopplay();}

  728.             tooltip Stop xywh {155 500 40 20} box PLASTIC_UP_BOX

  729.           }

  730.         }

  731.         Fl_Value_Slider seek_slider {

  732.           label Percents

  733.           callback {control.set_seek_pos(o->value()/o->maximum());}

  734.           xywh {205 490 780 20} type {Horz Knob} box THIN_UP_BOX color 16 selection_color 4 align 6 maximum 100 textsize 14

  735.         }

  736.       }

  737.     }

  738.     Fl_Window aboutwindow {

  739.       label {About...}

  740.       xywh {274 354 300 170} type Double color 7 hide modal

  741.     } {

  742.       Fl_Button {} {

  743.         label OK

  744.         callback {aboutwindow->hide();}

  745.         xywh {110 140 64 20}

  746.       }

  747.       Fl_Box {} {

  748.         label {Copyright (c) 2006-2011 Nasca Octavian PAUL, Tg. Mures, Romania}

  749.         xywh {10 93 280 37} align 128

  750.       }

  751.       Fl_Box {} {

  752.         label {This is a software for extreme time stretching of the audio.}

  753.         xywh {5 53 290 32} align 128

  754.       }

  755.       Fl_Box {} {

  756.         label {Paul's Extreme Sound Stretch}

  757.         xywh {20 6 255 21} labelfont 1 align 128

  758.       }

  759.       Fl_Box {} {

  760.         label version

  761.         xywh {20 26 255 19} labelfont 1 align 128

  762.         code0 {o->label(VERSION);}

  763.       }

  764.     }

  765.   }

  766.   Function {set_mode(Mode mode)} {private

  767.   } {

  768.     code {switch (mode){

  769. 	case STOP:

  770. 		play_button->labelcolor(FL_BLACK);

  771. 		mode_choice->activate();

  772. 		freeze_button->deactivate();

  773. 	break;

  774. 

  775. 	case PAUSE:

  776. 		play_button->labelcolor(FL_BLACK);

  777. 		mode_choice->activate();

  778. 	break;

  779. 	

  780. 	case PLAY:

  781. 		play_button->labelcolor(FL_RED);

  782. 		mode_choice->deactivate();

  783. 		fftsize_slider->labelcolor(FL_BLACK);

  784. 		freeze_button->activate();

  785. 	break;

  786. 	

  787. 	case FREEZE:

  788. 		if (control.is_freeze()) freeze_button->labelcolor(FL_GREEN);

  789. 			else freeze_button->labelcolor(FL_BLACK);

  790. 	break;

  791. };

  792. window->redraw();} {}

  793.   }

  794.   Function {refresh()} {open

  795.   } {

  796.     code {double stretch_s=stretch_slider->value()/stretch_slider->maximum();

  797. 

  798. int mode=mode_choice->value();

  799. double resolution_s=fftsize_slider->value()/fftsize_slider->maximum();

  800. 

  801. control.set_stretch_controls(stretch_s,mode,resolution_s);

  802. 

  803. stretch_slider->copy_label(control.get_stretch_info().c_str());

  804. fftsize_slider->copy_label(control.get_fftsize_info().c_str());

  805. resolution_box->copy_label(control.get_fftresolution_info().c_str());

  806. 

  807. bool may_render=false;

  808. if (infilename_output->label()!=NULL){

  809. 	if (strlen(infilename_output->label())!=0)  

  810. 	  may_render=true;

  811. };

  812. if (!rendering){//do not change the status of render button while rendering

  813. 	if (may_render) {

  814. 		render_button->activate();

  815. 		render_menu->activate();

  816. 	} else {

  817. 		render_button->deactivate();

  818. 		render_menu->deactivate();

  819. 	};

  820. };} {}

  821.   }

  822.   Function {refreshgui()} {open

  823.   } {

  824.     code {stretch_slider->value(control.gui_sliders.stretch_s);

  825. fftsize_slider->value(control.gui_sliders.fftsize_s);

  826. mode_choice->value(control.gui_sliders.mode_s);

  827. window_choice->value(control.window_type);

  828. 

  829. 

  830. 

  831. pitch_shift_enabled->value(control.ppar.pitch_shift.enabled);

  832. pitch_shift_cents->value(control.ppar.pitch_shift.cents);

  833. 

  834. octave_enabled->value(control.ppar.octave.enabled);

  835. octave_om2->value(control.ppar.octave.om2);

  836. octave_om1->value(control.ppar.octave.om1);

  837. octave_o0->value(control.ppar.octave.o0);

  838. octave_o1->value(control.ppar.octave.o1);

  839. octave_o15->value(control.ppar.octave.o15);

  840. octave_o2->value(control.ppar.octave.o2);

  841. 

  842. freq_shift_enabled->value(control.ppar.freq_shift.enabled);

  843. freq_shift_Hz->value(control.ppar.freq_shift.Hz);

  844. 

  845. compressor_enabled->value(control.ppar.compressor.enabled);

  846. compressor_power->value(control.ppar.compressor.power);

  847. 

  848. filter_enabled->value(control.ppar.filter.enabled);

  849. filter_stop->value(control.ppar.filter.stop);

  850. filter_low->value(control.ppar.filter.low);

  851. filter_high->value(control.ppar.filter.high);

  852. filter_hdamp->value(control.ppar.filter.hdamp);

  853. 

  854. harmonics_enabled->value(control.ppar.harmonics.enabled);

  855. harmonics_freq->value(control.ppar.harmonics.freq);

  856. harmonics_bandwidth->value(control.ppar.harmonics.bandwidth);

  857. harmonics_nharmonics->value(control.ppar.harmonics.nharmonics);

  858. harmonics_gauss->value(control.ppar.harmonics.gauss);

  859. 

  860. spread_enabled->value(control.ppar.spread.enabled);

  861. spread_bandwidth->value(control.ppar.spread.bandwidth);

  862. 

  863. 

  864. bbpar_mono->value(control.bbpar.mono);

  865. bbpar_stereo_mode->value(control.bbpar.stereo_mode);

  866. 

  867. 

  868. stretch_multiplier_control->refresh();

  869. arbitrary_filter_control->refresh();

  870. binaural_beats_control->refresh();} {}

  871.   }

  872.   Function {tickrefresh()} {} {

  873.     code {seek_slider->value(seek_slider->maximum()*control.get_seek_pos());

  874. 

  875. if (playing_for_button&&control.playing()){

  876. 	play_button->labelcolor(FL_GREEN);

  877. 	window->redraw();

  878. 	playing_for_button=false;

  879. };

  880. if (eof_for_button&&control.playing_eof()){

  881. 	play_button->labelcolor(FL_BLACK);

  882. 	window->redraw();

  883. 	eof_for_button=false;

  884. };

  885. 

  886. if (control.info.render_percent>0.0){

  887. 	render_percent_slider->value(control.info.render_percent);

  888. };

  889. if (infilename_output->new_drag_file){

  890.     open_input_file(infilename_output->drag_file.c_str());

  891.     infilename_output->new_drag_file=false;

  892. };} {}

  893.   }

  894.   Function {tickdraw(GUI *o)} {return_type {static void}

  895.   } {

  896.     code {o->tickrefresh();} {}

  897.   }

  898.   Function {tick(void *v)} {return_type {static void}

  899.   } {

  900.     code {tickdraw((GUI *) v);

  901. Fl::add_timeout(1.0/3.0,tick,v);//3 fps} {}

  902.   }

  903.   decl {Control control;} {}

  904.   decl {bool playing_for_button;} {}

  905.   decl {bool rendering;} {}

  906.   decl {bool eof_for_button;} {}

  907. } 

  908. 

  909. Function {file_exists(const char *filename)} {return_type bool

  910. } {

  911.   code {struct stat buf;

  912. int i = stat ( filename, &buf );

  913. // File exists

  914. if ( i == 0 ) return true;

  915.   else  return false;} {}

  916. } 

  917. 

  918. Function {main(int argc, char *argv[])} {return_type int

  919. } {

  920.   code {GUI *gui=new GUI();

  921. 

  922. if (argc>1){

  923. 	gui->open_input_file(argv[1]);

  924. };

  925. gui->window->show();

  926. 

  927. 

  928. Fl::run();

  929. 

  930. delete gui;

  931. 

  932. return 0;} {}

  933. }