paulstretch_cpp

GUI.fl (31217B)

---

 # data file for the Fltk User Interface Designer (fluid)
 version 1.0110 
 header_name {.h} 
 code_name {.cxx}
 decl {//Copyright (c) Nasca Octavian Paul. Released under GNU General Public License version 2} {public
 } 
 
 decl {\#include <FL/Fl_File_Chooser.H>} {} 
 
 decl {\#include <FL/Fl_Box.H>} {public
 } 
 
 decl {\#include <FL/Fl_Group.H>} {public
 } 
 
 decl {\#include <FL/Fl_Box.H>} {public
 } 
 
 decl {\#include <FL/fl_draw.H>} {public
 } 
 
 decl {\#include <FL/Fl_Value_Input.H>} {public
 } 
 
 decl {\#include <FL/fl_ask.H>} {public
 } 
 
 decl {\#include<sys/stat.h>} {} 
 
 decl {\#include <stdio.h>} {} 
 
 decl {\#include <string>} {} 
 
 decl {\#include <math.h>} {} 
 
 decl {\#include "Control.h"} {public
 } 
 
 decl {\#include "FreeEditUI.h"} {public
 } 
 
 decl {\#include "version.h"} {public
 } 
 
 Function {hex4n(char c)} {return_type int
 } {
   code {if (c>96) c-=32;
 if ((c>='0')&&(c<='9')) return (c-'0');
 if ((c>='A')&&(c<='F')) return (c-'A')+10;
 
 return 0;} {}
 } 
 
 Function {unescape(std::string s)} {return_type {std::string}
 } {
   code {std::string result;
 int slen=s.size();
 s+="    ";
 int sk=0;
 while (sk<slen){
 	char c=s[sk];
 	if (c=='%'){
 		char c1=s[++sk];
 		char c2=s[++sk];
 		result+=(char)(16*hex4n(c1)+hex4n(c2));
 		sk++;
 	}else{
 		result+=c;
 		sk++;
 	};
 };
 
 
 //printf("%s\\n%s\\n",s.c_str(),result.c_str());
 return result;} {}
 } 
 
 class DDBox {: {public Fl_Box}
 } {
   Function {DDBox(int x, int y, int w, int h, const char *label = 0):Fl_Box(x,y,w,h,label)} {open
   } {
     code {new_drag_file=false;} {}
   }
   Function {handle(int event)} {open return_type int
   } {
     code {if ((event==FL_DND_ENTER)||(event==FL_DND_DRAG)||(event==FL_DND_RELEASE)) return 1;
 if (event==FL_PASTE){
 	const char *url=Fl::event_text();
 	if (strstr(url,"file://")!=url) return 0;//is not a file
 	std::string filename=url+7;
 	for (int i=0;i<filename.size();i++) if (filename[i]<32) filename[i]=0;
 	drag_file=unescape(filename);
 	new_drag_file=true;
 	return 1;
 };
 return Fl_Box::handle(event);} {}
   }
   decl {std::string drag_file;} {public
   }
   decl {bool new_drag_file;} {public
   }
 } 
 
 class GUI {open
 } {
   decl {enum Mode {STOP,PLAY,PAUSE,FREEZE};} {}
   Function {GUI()} {} {
     code {playing_for_button=false;
 eof_for_button=false;
 rendering=false;
 make_window();
 tick(this);
 refresh();
 set_mode(STOP);} {}
   }
   Function {~GUI()} {} {
     code {Fl::remove_timeout(tick,this);} {}
   }
   Function {open_input_file(const char *filename)} {open
   } {
     code {const char *ext=fl_filename_ext(filename);
 FILE_TYPE intype=FILE_WAV;
 if ((strcmp(ext,".ogg")==0)||(strcmp(ext,".OGG")==0)||(strcmp(ext,".Ogg")==0)) intype=FILE_VORBIS;
 if ((strcmp(ext,".mp3")==0)||(strcmp(ext,".MP3")==0)||(strcmp(ext,".Mp3")==0)) intype=FILE_MP3;
 bool result=control.set_input_filename(filename,intype);
 if (result) {
 	infilename_output->copy_label(control.get_input_filename_and_info().c_str());
 } else {
 	infilename_output->copy_label("");
 	fl_alert("Error: Could not open audio file:\\n%s",filename);
 };
 refresh();} {}
   }
   Function {render()} {open
   } {
     code {render_button->deactivate();
 rendering=true;
 render_percent_slider->value(0);
 render_percent_slider->activate();
 cancel_render_button->activate();
 //char defaultfile[FL_PATH_MAX];
 //fl_filename_absolute(defaultfile,control.get_recommanded_output_filename().c_str());
 Fl_File_Chooser *fc=new Fl_File_Chooser(NULL,"Wave files (*.wav)\\tOgg Vorbis (*.ogg)",Fl_File_Chooser::CREATE,"Render to audio file...");
 
 fc->preview(0);
 fc->filter_value(0);
 fc->ok_label("Render");
 fc->show();
 while (fc->visible()){
 	Fl::wait();
 };
 
 const char *newfile = fc->value();
   if (newfile != NULL) {  	
   	if (file_exists(newfile)){
   		if (!fl_choice("The file exists. \\nOverwrite it?","No","Yes",NULL)) return;
   	};
 
 	FILE_TYPE type=FILE_WAV;
 	if (fc->filter_value()==1)  type=FILE_VORBIS;
 	const char *ext=fl_filename_ext(newfile);
 	std::string outfilename=newfile;
 	if (strlen(ext)==0){
 		if (type==FILE_VORBIS) outfilename+=".ogg";
 			else outfilename+=".wav";
 	};
 	render_percent_slider->copy_label(outfilename.c_str());
 	FILE_TYPE intype=FILE_WAV;
 	{
 		const char *ext=fl_filename_ext(control.get_input_filename().c_str());
  		if ((strcmp(ext,".ogg")==0)||(strcmp(ext,".OGG")==0)||(strcmp(ext,".Ogg")==0)) intype=FILE_VORBIS;
  		if ((strcmp(ext,".MP3")==0)||(strcmp(ext,".mp3")==0)||(strcmp(ext,".Mp3")==0)) intype=FILE_MP3;
   	};
 	const char *outstr=control.Render(control.get_input_filename(),outfilename,type,intype,
 		selection_pos1->value()/100.0,selection_pos2->value()/100.0).c_str();
 	if (strlen(outstr)!=0) fl_alert("%s",outstr);
   };
 
 delete fc;
 render_button->activate();
 render_percent_slider->value(0);
 render_percent_slider->deactivate();
 render_percent_slider->label("");
 cancel_render_button->deactivate();
 rendering=false;} {}
   }
   Function {make_window()} {open private
   } {
     Fl_Window window {
       label {Paul's Extreme Sound Stretch} open
       xywh {192 131 995 550} type Double resizable
       code0 {if(strlen(VERSION)<2) {o->color(FL_BLUE); o->label("VERSION NOT SET!!!!!!!!!!!!");};} visible
     } {
       Fl_Menu_Bar {} {open
         xywh {0 0 1015 20}
       } {
         Submenu {} {
           label File open
           xywh {0 0 63 20}
         } {
           MenuItem {} {
             label {Open audio file...}
             callback {char *newfile = fl_file_chooser("Open Audio(ogg,wav,mp3) File?", NULL, NULL);
   if (newfile != NULL) {
   	open_input_file(newfile);
   	
   };
   selection_pos1->value(0.0);
   selection_pos2->value(100.0);
 
   refresh();}
             xywh {0 0 30 20}
           }
           MenuItem render_menu {
             label {Render and save audio file...}
             callback {selection_pos1->value(0.0);
 selection_pos2->value(100.0);
 tabs_widget->value(write_to_file_group);
 render();}
             xywh {10 10 30 20} deactivate divider
           }
           MenuItem {} {
             label {Open Parameters...}
             callback {char *newfile = fl_file_chooser("Open Parameter File?", "PaulStretch XML (*.psx)\\tAll Files (*)", NULL);
   if (newfile != NULL) {
 	set_mode(STOP);
 	control.stopplay();
  
   	if (!control.load_parameters(newfile)){
   		fl_alert("Error: Could not load parameter file:\\n%s",newfile);
   	};
   };
   refreshgui();
   refresh();}
             xywh {10 10 30 20}
           }
           MenuItem {} {
             label {Save Parameters...}
             callback {char *newfile = fl_file_chooser("Save Parameters(paulstretch) File?", "PaulStretch XML (*.psx)\\tAll Files (*)", NULL);
   if (newfile != NULL) {
   	if (file_exists(newfile)){
   		if (!fl_choice("The file exists. \\nOverwrite it?","No","Yes",NULL)) return;
   	};
   	control.save_parameters(newfile);
   };
   refresh();}
             xywh {20 20 30 20} divider
           }
           MenuItem {} {
             label Exit
             callback {window->hide();}
             xywh {0 0 30 20}
           }
         }
         Submenu {} {
           label About
           xywh {15 15 63 20}
         } {
           MenuItem {} {
             label {About...}
             callback {aboutwindow->show();}
             xywh {15 15 30 20}
           }
         }
       }
       Fl_Tabs tabs_widget {open
         xywh {5 50 985 420} box BORDER_BOX
       } {
         Fl_Group {} {
           label Parameters open
           xywh {5 70 985 400}
         } {
           Fl_Slider stretch_slider {
             label {Stretch:}
             callback {refresh();
 control.update_player_stretch();}
             xywh {10 89 975 15} type {Horz Knob} box FLAT_BOX align 6 value 0.29
           }
           Fl_Slider fftsize_slider {
             label {Window Size:}
             callback {refresh();
 o->labelcolor(FL_BLUE);}
             xywh {10 155 975 15} type {Horz Knob} box FLAT_BOX align 6 value 0.47
           }
           Fl_Choice mode_choice {
             label {Mode:}
             callback {refresh();
 control.update_player_stretch();} selected
             xywh {850 110 135 20} down_box BORDER_BOX
           } {
             MenuItem {} {
               label Stretch
               xywh {10 10 30 20}
             }
             MenuItem {} {
               label HyperStretch
               xywh {20 20 30 20}
             }
             MenuItem {} {
               label Shorten
               xywh {0 0 30 20}
             }
           }
           Fl_Choice window_choice {
             label {Type:}
             callback {FFTWindow w=W_RECTANGULAR;
 switch(o->value()){
 	case 0:
 	   w=W_RECTANGULAR;
 	   break;
 	case 1:
 	   w=W_HAMMING;
 	   break;
 	case 2:
 	   w=W_HANN;
 	   break;
 	case 3:
 	   w=W_BLACKMAN;
 	   break;
 	case 4:
 	   w=W_BLACKMAN_HARRIS;
 	   break;
 };
 
 control.set_window_type(w);
 refresh();}
             xywh {850 185 135 20} down_box BORDER_BOX when 1
             code0 {o->value(2);}
           } {
             MenuItem {} {
               label Rectangular
               xywh {40 40 30 20}
             }
             MenuItem {} {
               label Hamming
               xywh {30 30 30 20}
             }
             MenuItem {} {
               label Hann
               xywh {10 10 30 20}
             }
             MenuItem {} {
               label Blackman
               xywh {20 20 30 20}
             }
             MenuItem {} {
               label BlackmanHarris
               xywh {30 30 30 20}
             }
           }
           Fl_Button {} {
             label S
             callback {char tmp[100];
 snprintf(tmp,100,"%g",control.get_stretch());
 const char *result=fl_input("Enter the stretch value",tmp);
 if (!result) return;
 
 double str=atof(result);
 if (str<1e-4) return;
 
 double stc=control.get_stretch_control(str,mode_choice->value());
 
 if ((stc<1e-4)||(stc>1.0)) return;
 stretch_slider->value(stc);
 stretch_slider->do_callback();}
             tooltip {set the stretch to a value} xywh {780 110 20 20}
           }
           Fl_Box resolution_box {
             xywh {10 187 790 18} box FLAT_BOX color 52 align 20
           }
           Fl_Group {} {
             label {Stretch Multiplier} open
             xywh {10 245 975 220} box THIN_UP_BOX labeltype ENGRAVED_LABEL
           } {
             Fl_Box stretch_free_edit {
               label Graph
               xywh {105 250 875 210} box FLAT_BOX color 17
               code0 {o->init(&control.ppar.stretch_multiplier,&control);}
               class FreeEditUI
             }
             Fl_Group stretch_multiplier_control {open
               xywh {15 250 85 210} box BORDER_FRAME color 0 align 208
               code0 {o->init(stretch_free_edit,FE_LINEAR,0,100.0,FE_LOG,0.1,50.0,1.0);}
               class FreeEditControls
             } {}
           }
           Fl_Slider onset_slider {
             label {Onset sensitivity:}
             callback {refresh();
 control.update_player_stretch();}
             xywh {135 213 140 15} type {Horz Knob} box FLAT_BOX align 4
           }
         }
         Fl_Group {} {
           label Process open
           xywh {5 70 985 400} hide
         } {
           Fl_Group {} {open
             xywh {165 75 105 65} box BORDER_BOX
           } {
             Fl_Check_Button pitch_shift_enabled {
               label {Pitch Shift}
               callback {control.ppar.pitch_shift.enabled=o->value();
 control.update_process_parameters();}
               xywh {170 80 90 15} down_box DOWN_BOX labelfont 1
             }
             Fl_Counter pitch_shift_cents {
               label cents
               callback {control.ppar.pitch_shift.cents=(int)o->value();
 control.update_process_parameters();}
               xywh {170 100 90 20} minimum -3600 maximum 3600 step 1
               code0 {o->lstep(100);}
             }
           }
           Fl_Group {} {open
             xywh {275 75 135 100} box BORDER_BOX
           } {
             Fl_Check_Button octave_enabled {
               label {Octave Mixer}
               callback {control.ppar.octave.enabled=o->value();
 control.update_process_parameters();}
               xywh {280 80 110 15} down_box DOWN_BOX labelfont 1
             }
             Fl_Slider octave_om2 {
               label {-2}
               callback {control.ppar.octave.om2=pow(o->value(),2.0);
 control.update_process_parameters();}
               tooltip {2 octaves below} xywh {280 100 15 55} type {Vert Knob} minimum 1 maximum 0
             }
             Fl_Slider octave_om1 {
               label {-1}
               callback {control.ppar.octave.om1=pow(o->value(),2.0);
 control.update_process_parameters();}
               tooltip {1 octave below} xywh {300 100 15 55} type {Vert Knob} minimum 1 maximum 0
             }
             Fl_Slider octave_o0 {
               label 0
               callback {control.ppar.octave.o0=pow(o->value(),2.0);
 control.update_process_parameters();}
               tooltip {original (dry)} xywh {320 100 15 55} type {Vert Knob} minimum 1 maximum 0 value 1
             }
             Fl_Slider octave_o1 {
               label 1
               callback {control.ppar.octave.o1=pow(o->value(),2.0);
 control.update_process_parameters();}
               tooltip {1 octave above} xywh {340 100 15 55} type {Vert Knob} minimum 1 maximum 0
             }
             Fl_Slider octave_o15 {
               label {1.5}
               callback {control.ppar.octave.o15=pow(o->value(),2.0);
 control.update_process_parameters();}
               tooltip {3rd harmonic} xywh {360 100 15 55} type {Vert Knob} minimum 1 maximum 0
             }
             Fl_Slider octave_o2 {
               label 2
               callback {control.ppar.octave.o2=pow(o->value(),2.0);
 control.update_process_parameters();}
               tooltip {2 octaves above} xywh {380 100 15 55} type {Vert Knob} minimum 1 maximum 0
             }
           }
           Fl_Group {} {open
             xywh {165 140 105 65} box BORDER_BOX
           } {
             Fl_Check_Button freq_shift_enabled {
               label {Freq Shift}
               callback {control.ppar.freq_shift.enabled=o->value();
 control.update_process_parameters();}
               xywh {170 145 90 15} down_box DOWN_BOX labelfont 1
             }
             Fl_Counter freq_shift_Hz {
               label Hz
               callback {control.ppar.freq_shift.Hz=(int)o->value();
 control.update_process_parameters();}
               xywh {170 165 90 20} minimum -10000 maximum 10000 step 1
               code0 {o->lstep(100);}
             }
           }
           Fl_Group {} {open
             xywh {750 75 120 65} box BORDER_BOX
           } {
             Fl_Check_Button compressor_enabled {
               label Compress
               callback {control.ppar.compressor.enabled=o->value();
 control.update_process_parameters();}
               xywh {755 80 90 15} down_box DOWN_BOX labelfont 1
             }
             Fl_Slider compressor_power {
               label Power
               callback {control.ppar.compressor.power=o->value();
 control.update_process_parameters();}
               xywh {755 100 110 15} type {Horz Knob}
             }
           }
           Fl_Slider {} {
             label Volume
             callback {REALTYPE x=o->value();
 x=pow(10.0,pow(x,1.5)-1.0)-0.1;
 control.set_volume(x);}
             xywh {750 155 120 40} type {Horz Knob} labelfont 1 minimum 0.3 maximum 1.6 value 1
           }
           Fl_Group {} {open
             xywh {415 75 185 100} box BORDER_BOX
           } {
             Fl_Check_Button filter_enabled {
               label Filter
               callback {control.ppar.filter.enabled=o->value();
 control.update_process_parameters();}
               xywh {420 80 70 15} down_box DOWN_BOX labelfont 1
             }
             Fl_Value_Input filter_low {
               label {Freq1(Hz)}
               callback {control.ppar.filter.low=o->value();
 control.update_process_parameters();}
               xywh {420 101 100 24} align 8 maximum 10000
             }
             Fl_Value_Input filter_high {
               label {Freq2(Hz)}
               callback {control.ppar.filter.high=o->value();
 control.update_process_parameters();}
               xywh {420 126 100 24} align 8 maximum 25000 value 22000
             }
             Fl_Check_Button filter_stop {
               label BandStop
               callback {control.ppar.filter.stop=o->value();
 control.update_process_parameters();}
               tooltip {band-stop filter} xywh {500 80 90 15} down_box DOWN_BOX
             }
             Fl_Slider filter_hdamp {
               label DHF
               callback {control.ppar.filter.hdamp=o->value();
 control.update_process_parameters();}
               tooltip {Damp High Frequency} xywh {420 155 140 15} type {Horz Knob} align 8
             }
           }
           Fl_Group {} {open
             xywh {10 75 150 120} box BORDER_BOX
           } {
             Fl_Check_Button harmonics_enabled {
               label Harmonics
               callback {control.ppar.harmonics.enabled=o->value();
 control.update_process_parameters();}
               xywh {15 80 95 15} down_box DOWN_BOX labelfont 1
             }
             Fl_Value_Input harmonics_freq {
               label {F.Freq(Hz)}
               callback {control.ppar.harmonics.freq=o->value();
 control.update_process_parameters();}
               tooltip {fundamental frequency} xywh {15 101 65 24} align 8 minimum 1 maximum 20000 value 440
             }
             Fl_Value_Input harmonics_bandwidth {
               label {BW(cents)}
               callback {control.ppar.harmonics.bandwidth=o->value();
 control.update_process_parameters();}
               tooltip {bandwidth (cents)} xywh {15 126 65 24} align 8 minimum 0.1 maximum 200 value 25
             }
             Fl_Check_Button harmonics_gauss {
               label Gauss
               callback {control.ppar.harmonics.gauss=o->value();
 control.update_process_parameters();}
               tooltip {smooth the harmonics} xywh {85 155 65 15} down_box DOWN_BOX
             }
             Fl_Counter harmonics_nharmonics {
               label {no.hrm.}
               callback {control.ppar.harmonics.nharmonics=(int)o->value();
 control.update_process_parameters();}
               tooltip {number of harmonics} xywh {15 155 56 20} type Simple minimum 1 maximum 100 step 1 value 10
             }
           }
           Fl_Group {} {open
             xywh {275 180 325 40} box BORDER_BOX
           } {
             Fl_Check_Button spread_enabled {
               label Spread
               callback {control.ppar.spread.enabled=o->value();
 control.update_process_parameters();}
               xywh {280 185 90 15} down_box DOWN_BOX labelfont 1
             }
             Fl_Slider spread_bandwidth {
               label Bandwidth
               callback {control.ppar.spread.bandwidth=o->value();
 control.update_process_parameters();}
               xywh {360 185 230 15} type {Horz Knob} value 0.3
             }
           }
           Fl_Group {} {
             label ArbitraryFilter
             xywh {10 245 975 220} box THIN_UP_BOX labeltype ENGRAVED_LABEL
           } {
             Fl_Box filter_free_edit {
               label Graph
               xywh {105 250 875 210} box FLAT_BOX color 206 selection_color 0
               code0 {o->init(&control.ppar.free_filter,&control);}
               class FreeEditUI
             }
             Fl_Group arbitrary_filter_control {open
               xywh {15 250 85 210} box BORDER_FRAME color 0 align 208
               code0 {o->init(filter_free_edit,FE_LOG,20.0,25000.0,FE_DB,-60,20,0.0);}
               class FreeEditControls
             } {}
           }
           Fl_Group {} {open
             xywh {605 75 140 105} box BORDER_BOX
           } {
             Fl_Check_Button tonal_vs_noise_enabled {
               label {Tonal/Noise}
               callback {control.ppar.tonal_vs_noise.enabled=o->value();
 control.update_process_parameters();}
               xywh {610 80 115 20} down_box DOWN_BOX labelfont 1
             }
             Fl_Slider tonal_vs_noise_bandwidth {
               label Bandwidth
               callback {control.ppar.tonal_vs_noise.bandwidth=o->value();
 control.update_process_parameters();}
               xywh {610 141 130 15} type {Horz Knob} minimum 0.75 value 0.9
             }
             Fl_Slider tonal_vs_noise_preserve {
               label {noise <-->tonal}
               callback {control.ppar.tonal_vs_noise.preserve=o->value();
 control.update_process_parameters();}
               xywh {610 105 130 15} type {Horz Knob} minimum -1 value 0.5
             }
           }
         }
         Fl_Group {} {
           label {Binaural beats}
           xywh {5 70 985 400} box THIN_UP_BOX hide
         } {
           Fl_Box binaural_free_edit {
             label Graph
             xywh {135 75 845 390} box FLAT_BOX color 135
             code0 {o->init(&control.bbpar.free_edit,&control);}
             class FreeEditUI
           }
           Fl_Slider bbpar_mono {
             label Pow
             callback {control.bbpar.mono=o->value();
 control.update_process_parameters();}
             xywh {105 75 20 190} type {Vert Knob} labelfont 1 minimum 1 maximum 0 value 0.5
           }
           Fl_Group binaural_beats_control {
             label {FreeEdit Controls}
             xywh {10 75 80 205} box BORDER_FRAME color 47 align 208
             code0 {o->init(binaural_free_edit,FE_LINEAR,0,100.0,FE_LOG,0.1,50.0,8.0);}
             class FreeEditControls
           } {}
           Fl_Choice bbpar_stereo_mode {
             label {Stereo Mode}
             callback {control.bbpar.stereo_mode=(BB_STEREO_MODE)o->value();
 control.update_process_parameters();}
             xywh {10 305 110 20} down_box BORDER_BOX align 5
           } {
             MenuItem {} {
               label LeftRight
               xywh {10 10 36 21} labelfont 1
             }
             MenuItem {} {
               label RightLeft
               xywh {20 20 36 21} labelfont 1
             }
             MenuItem {} {
               label Symmetric
               xywh {30 30 36 21} labelfont 1
             }
           }
         }
         Fl_Group write_to_file_group {
           label {Write to file} open
           xywh {5 70 985 400} hide
         } {
           Fl_Button render_button {
             label {Render selection...}
             callback {render();}
             xywh {250 95 320 30} labelfont 1 labelsize 22
           }
           Fl_Value_Slider render_percent_slider {
             label { }
             xywh {15 245 970 65} type {Horz Fill} selection_color 4 align 70 maximum 100 step 0.1 textsize 14
           }
           Fl_Button cancel_render_button {
             label Cancel
             callback {if (fl_choice("Cancel audio rendering?","No","Yes",NULL)) control.info.cancel_render=true;}
             xywh {400 365 145 25} deactivate
           }
           Fl_Button {} {
             label {selection pos1}
             callback {selection_pos1->value(seek_slider->value());}
             tooltip {set selection start from Player's position} xywh {20 85 110 20} align 20
           }
           Fl_Button {} {
             label {selection pos2}
             callback {selection_pos2->value(seek_slider->value());}
             tooltip {set selection end from Player's position} xywh {20 110 110 20} align 20
           }
           Fl_Button {} {
             label {select all}
             callback {selection_pos1->value(0.0);
 selection_pos2->value(100.0);}
             tooltip {select the whole sound} xywh {20 135 110 20}
           }
           Fl_Value_Output selection_pos1 {
             label {%}
             xywh {135 85 70 20} align 72 maximum 100 step 0.01 textfont 1
           }
           Fl_Value_Output selection_pos2 {
             label {%}
             xywh {135 111 70 18} align 72 maximum 100 step 0.01 value 100 textfont 1
           }
           Fl_Check_Button {} {
             label 32bit
             callback {control.wav32bit=o->value();}
             xywh {250 135 100 15} down_box DOWN_BOX
           }
         }
       }
       Fl_Box infilename_output {
         tooltip {drag audio file here to open it} xywh {5 24 1005 22} box FLAT_BOX color 17 align 84
         class DDBox
       }
       Fl_Group {} {open
         xywh {5 475 985 70} box BORDER_BOX
       } {
         Fl_Group {} {open
           xywh {10 490 190 40} box THIN_UP_BOX color 16
         } {
           Fl_Button play_button {
             label {@>}
             callback {if (control.playing_eof()&&(seek_slider->value()>99.0)){
 	seek_slider->value(0.0);
 	seek_slider->do_callback();
 };
 set_mode(PLAY);
 playing_for_button=true;
 eof_for_button=true;
 
 bool bypass=false;
 if (Fl::event_button()==FL_RIGHT_MOUSE) bypass=true;
 
 control.startplay(bypass);}
             tooltip {Play - right click to play the original sound} xywh {20 500 40 20} box PLASTIC_UP_BOX
           }
           Fl_Button freeze_button {
             label {@<-> F}
             callback {control.freezeplay();
 set_mode(FREEZE);}
             tooltip Freeze xywh {65 500 40 20} box PLASTIC_UP_BOX
           }
           Fl_Button {} {
             label {@||}
             callback {set_mode(PAUSE);
 control.pauseplay();}
             tooltip Pause xywh {110 500 40 20} box PLASTIC_UP_BOX
           }
           Fl_Button {} {
             label {@square}
             callback {set_mode(STOP);
 control.stopplay();}
             tooltip Stop xywh {155 500 40 20} box PLASTIC_UP_BOX
           }
         }
         Fl_Value_Slider seek_slider {
           label Percents
           callback {control.set_seek_pos(o->value()/o->maximum());}
           xywh {205 490 780 20} type {Horz Knob} box THIN_UP_BOX color 16 selection_color 4 align 6 maximum 100 textsize 14
         }
       }
     }
     Fl_Window aboutwindow {
       label {About...}
       xywh {274 354 300 170} type Double color 7 hide modal
     } {
       Fl_Button {} {
         label OK
         callback {aboutwindow->hide();}
         xywh {110 140 64 20}
       }
       Fl_Box {} {
         label {Copyright (c) 2006-2011 Nasca Octavian PAUL, Tg. Mures, Romania}
         xywh {10 93 280 37} align 128
       }
       Fl_Box {} {
         label {This is a software for extreme time stretching of the audio.}
         xywh {5 53 290 32} align 128
       }
       Fl_Box {} {
         label {Paul's Extreme Sound Stretch}
         xywh {20 6 255 21} labelfont 1 align 128
       }
       Fl_Box {} {
         label version
         xywh {20 26 255 19} labelfont 1 align 128
         code0 {o->label(VERSION);}
       }
     }
   }
   Function {set_mode(Mode mode)} {open private
   } {
     code {switch (mode){
 	case STOP:
 		play_button->labelcolor(FL_BLACK);
 		//mode_choice->activate();
 		freeze_button->deactivate();
 	break;
 
 	case PAUSE:
 		play_button->labelcolor(FL_BLACK);
 		//mode_choice->activate();
 	break;
 	
 	case PLAY:
 		play_button->labelcolor(FL_RED);
 		//mode_choice->deactivate();
 		fftsize_slider->labelcolor(FL_BLACK);
 		freeze_button->activate();
 	break;
 	
 	case FREEZE:
 		if (control.is_freeze()) freeze_button->labelcolor(FL_GREEN);
 			else freeze_button->labelcolor(FL_BLACK);
 	break;
 };
 window->redraw();} {}
   }
   Function {refresh()} {open
   } {
     code {double stretch_s=stretch_slider->value()/stretch_slider->maximum();
 
 int mode=mode_choice->value();
 double resolution_s=fftsize_slider->value()/fftsize_slider->maximum();
 
 double onset=onset_slider->value();
 control.set_stretch_controls(stretch_s,mode,resolution_s,onset);
 
 stretch_slider->copy_label(control.get_stretch_info().c_str());
 fftsize_slider->copy_label(control.get_fftsize_info().c_str());
 resolution_box->copy_label(control.get_fftresolution_info().c_str());
 
 bool may_render=false;
 if (infilename_output->label()!=NULL){
 	if (strlen(infilename_output->label())!=0)  
 	  may_render=true;
 };
 if (!rendering){//do not change the status of render button while rendering
 	if (may_render) {
 		render_button->activate();
 		render_menu->activate();
 	} else {
 		render_button->deactivate();
 		render_menu->deactivate();
 	};
 };} {}
   }
   Function {refreshgui()} {open
   } {
     code {stretch_slider->value(control.gui_sliders.stretch_s);
 fftsize_slider->value(control.gui_sliders.fftsize_s);
 mode_choice->value(control.gui_sliders.mode_s);
 window_choice->value(control.window_type);
 onset_slider->value(control.get_onset_detection_sensitivity());
 
 
 pitch_shift_enabled->value(control.ppar.pitch_shift.enabled);
 pitch_shift_cents->value(control.ppar.pitch_shift.cents);
 
 octave_enabled->value(control.ppar.octave.enabled);
 octave_om2->value(control.ppar.octave.om2);
 octave_om1->value(control.ppar.octave.om1);
 octave_o0->value(control.ppar.octave.o0);
 octave_o1->value(control.ppar.octave.o1);
 octave_o15->value(control.ppar.octave.o15);
 octave_o2->value(control.ppar.octave.o2);
 
 freq_shift_enabled->value(control.ppar.freq_shift.enabled);
 freq_shift_Hz->value(control.ppar.freq_shift.Hz);
 
 compressor_enabled->value(control.ppar.compressor.enabled);
 compressor_power->value(control.ppar.compressor.power);
 
 filter_enabled->value(control.ppar.filter.enabled);
 filter_stop->value(control.ppar.filter.stop);
 filter_low->value(control.ppar.filter.low);
 filter_high->value(control.ppar.filter.high);
 filter_hdamp->value(control.ppar.filter.hdamp);
 
 harmonics_enabled->value(control.ppar.harmonics.enabled);
 harmonics_freq->value(control.ppar.harmonics.freq);
 harmonics_bandwidth->value(control.ppar.harmonics.bandwidth);
 harmonics_nharmonics->value(control.ppar.harmonics.nharmonics);
 harmonics_gauss->value(control.ppar.harmonics.gauss);
 
 spread_enabled->value(control.ppar.spread.enabled);
 spread_bandwidth->value(control.ppar.spread.bandwidth);
 
 
 tonal_vs_noise_enabled->value(control.ppar.tonal_vs_noise.enabled);
 tonal_vs_noise_preserve->value(control.ppar.tonal_vs_noise.preserve);
 tonal_vs_noise_bandwidth->value(control.ppar.tonal_vs_noise.bandwidth);
 
 bbpar_mono->value(control.bbpar.mono);
 bbpar_stereo_mode->value(control.bbpar.stereo_mode);
 
 
 stretch_multiplier_control->refresh();
 arbitrary_filter_control->refresh();
 binaural_beats_control->refresh();} {}
   }
   Function {tickrefresh()} {} {
     code {seek_slider->value(seek_slider->maximum()*control.get_seek_pos());
 
 if (playing_for_button&&control.playing()){
 	play_button->labelcolor(FL_GREEN);
 	window->redraw();
 	playing_for_button=false;
 };
 if (eof_for_button&&control.playing_eof()){
 	play_button->labelcolor(FL_BLACK);
 	window->redraw();
 	eof_for_button=false;
 };
 
 if (control.info.render_percent>0.0){
 	render_percent_slider->value(control.info.render_percent);
 };
 if (infilename_output->new_drag_file){
     open_input_file(infilename_output->drag_file.c_str());
     infilename_output->new_drag_file=false;
 };} {}
   }
   Function {tickdraw(GUI *o)} {return_type {static void}
   } {
     code {o->tickrefresh();} {}
   }
   Function {tick(void *v)} {return_type {static void}
   } {
     code {tickdraw((GUI *) v);
 Fl::add_timeout(1.0/3.0,tick,v);//3 fps} {}
   }
   decl {Control control;} {}
   decl {bool playing_for_button;} {}
   decl {bool rendering;} {}
   decl {bool eof_for_button;} {}
 } 
 
 Function {file_exists(const char *filename)} {return_type bool
 } {
   code {struct stat buf;
 int i = stat ( filename, &buf );
 // File exists
 if ( i == 0 ) return true;
   else  return false;} {}
 } 
 
 Function {main(int argc, char *argv[])} {open return_type int
 } {
   code {GUI *gui=new GUI();
 
 
 if (argc>1){
 	const char *filename=argv[1];
 	if (filename[0]=='-'){
 		if (argc>2) filename=argv[2];
 		else filename=NULL;
 	};
 	if (filename) gui->open_input_file(filename);
 };
 gui->window->show();
 
 
 Fl::run();
 
 delete gui;
 
 return 0;} {}
 }