path: root/src/frontend/ui_hd24connect.fl

# data file for the Fltk User Interface Designer (fluid)
version 1.0109 
header_name {.h} 
code_name {.cxx}
decl {class HD24TrackChannel;} {public
} 

decl {class TrackInfo;} {public
} 

decl {class HD24UserInterface;} {public
} 

decl {class MixerUI;} {public
} 

decl {class RecorderUI;} {public
} 

decl {class PortAudioWrapper;} {public
} 

decl {class JackWrapper;} {public
} 

decl {class hd24transferengine;} {public
} 

decl {\#define HD24DEBUG 0} {public
} 

decl {\#define BLINKRATE 25} {public
} 

decl {\#define PA_FRAMESPERBUF 512} {public
} 

decl {\#define MAXCHANNELS 24} {public
} 

decl {\#define UIREFRESH 1 /* 1=best, 10=1/10 refresh rate */} {public
} 

decl {\#define HD24MODE hd24fs::MODE_RDWR} {public
} 

decl {\#define TIMEOUT 0.03} {public
} 

decl {\#define SPLITFILESIZE_BYTES ((__uint64)(1024*1024*1024))} {public
} 

decl {\#include <config.h>} {public
} 

decl {\#include <string>} {public
} 

decl {\#include <vector>} {public
} 

decl {\#include <portwin.h>} {public
} 

decl {\#include <soundlibs.h> /* portaudio, libjack */} {public
} 

decl {\#include <iostream>} {public
} 

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

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

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

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

decl {\#include <xplat_dlfcn.h>} {public
} 

decl {\#include <sndfile.h>} {public
} 

decl {\#include <convertlib.h>} {public
} 

decl {\#include <memutils.h>} {public
} 

decl {\#include <hd24fs.h>} {public
} 

decl {\#include <hd24utils.h>} {public
} 

decl {\#include <hd24transferengine.h>} {public
} 

decl {\#include <smpte.h>} {public
} 

decl {\#include <WidgetPDial.h>} {public
} 

decl {\#include <dialog_newproject.h>} {public
} 

decl {\#include <dialog_newsong.h>} {public
} 

decl {\#include <dialog_setlocate.h>} {public
} 

decl {\#include <dialog_filesize.h>} {public
} 

decl {\#include <dialog_setlength.h>} {public
} 

decl {\#include <dialog_fromto.h>} {public
} 

decl {\#include <dialog_rename.h>} {public
} 

decl {\#include <dialog_options.h>} {public
} 

decl {\#include <dialog_choosedevice.h>} {public
} 

decl {\#include <ui_help_about.h>} {public
} 

decl {\#include <ui_mixer.h>} {public
} 

decl {\#include <time.h>} {public
} 

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

decl {\#include <ui_hd24trackchannel.h>} {public
} 

decl {\#include <ui_recorder.h>} {public
} 

decl {class HD24UserInterface;} {public
} 

decl {class HD24control;} {public
} 

decl {class SoundFileWrapper;} {public
} 

class HD24data {} {
  decl {HD24UserInterface* parentui;} {}
  decl {friend class HD24control;} {}
  decl {int ready;} {public
  }
} 

class HD24control {} {
  decl {HD24data* data;} {}
  Function {parentui(HD24UserInterface* p_parentui)} {open
  } {
    code {data->parentui=p_parentui;} {}
  }
  Function {parentui()} {open return_type {HD24UserInterface*}
  } {
    code {return data->parentui;} {}
  }
  Function {HD24control()} {open
  } {
    code {data=new HD24data();} {}
  }
  Function {~HD24control()} {open
  } {
    code {delete data;} {}
  }
  Function {ready()} {open return_type int
  } {
    code {return data->ready;} {}
  }
  Function {ready(int p_ready)} {open return_type void
  } {
    code {data->ready=p_ready;} {}
  }
} 

decl {\#include <hd24sndfile.h>} {public
} 

class HD24UserInterface {open
} {
  decl {hd24transferengine* transeng;} {}
  decl {HD24control* control;} {public
  }
  decl {PortAudioWrapper* portaudio;} {public
  }
  decl {SoundFileWrapper* soundfile;} {public
  }
  decl {JackWrapper* libjack;} {public
  }
  decl {int busy;} {public
  }
  decl {hd24fs* defaulthd24;} {}
  decl {hd24fs* currenthd24;} {public
  }
  decl {int trackselected[24];} {public
  }
  decl {hd24project* currproj;} {public
  }
  decl {hd24song* currsong;} {public
  }
  decl {Fl_Check_Button* track[24];} {public
  }
  decl {int tracksave[24]; /* to keep track[24] settings */} {public
  }
  decl {vector<string> format_outputextension;} {public
  }
  decl {vector<string> format_shortdesc;} {public
  }
  Function {deactivate_ui()} {open return_type void
  } {
    code {drivename->deactivate();
rename_drive->deactivate();
projectname->deactivate();
rename_project->deactivate();
songname->deactivate();
songinfogroup->deactivate();
tabDrive->deactivate();
rename_song->deactivate();
locatepoints->deactivate();
fromto->deactivate();
transfercanvas->deactivate();
menufile->deactivate();
tabRecorder->deactivate();
tabMixer->deactivate();
menuhelp->deactivate();} {}
  }
  Function {disable_program_controls()} {return_type void
  } {
    code {drivename->deactivate();
rename_drive->deactivate();
projectname->deactivate();
rename_project->deactivate();
songname->deactivate();
rename_song->deactivate();
transfercanvas->deactivate();
locatepoints->deactivate();
fromto->deactivate();
button_golocatepoint->deactivate();
recorder->control->disable();} {}
  }
  Function {activate_ui()} {open return_type void
  } {
    code {drivename->activate();
transfercanvas->activate();
tabRecorder->activate();
projectname->activate();
songname->activate();
songinfogroup->activate();
tabDrive->activate();
tabMixer->activate();
locatepoints->activate();
fromto->activate();
menufile->activate();
menuhelp->activate();} {}
  }
  Function {addsongtodropdown(int i)} {} {
    code {\#if (HD24DEBUG==1) 
		cout << "addsongtodropdown " << i << endl;
		cout << "set song" << endl;
\#endif
    hd24song* song=currproj->getsong(i);
\#if (HD24DEBUG==1) 
		cout << "song is set" << endl;
\#endif
    string* strsongname=Convert::int2str(i);
    *strsongname+=": ";
    string* actualname=song->songname();
    *strsongname+=*actualname;
    delete actualname;

\#if (HD24DEBUG==1) 
		cout << "song is set2" << endl;
\#endif
    songname->add(strsongname->c_str(),0,(void (*)(Fl_Widget*,void*))(&(songname_cb)),(void*)this);
\#if (HD24DEBUG==1)
	cout << "song is set3" << endl;
\#endif
    delete song;
    delete(strsongname);} {}
  }
  Function {populate_projectlist(int projectid)} {return_type void
  } {
    code {/* Set project info */
int i;
\#if (HD24DEBUG==1)
	cout << "clear project list" << endl;
\#endif
for (i=0;i<=100;i++) {
	projectname->remove(0);
}
int numprojs=0;
if (currenthd24==NULL) {
    return;
}
numprojs=currenthd24->projectcount();
for (i=1; i<=numprojs; i++) {
    hd24project* currproj=currenthd24->getproject(i);
    string* projname1=Convert::int2str(i);
	*projname1+=": ";
	string* currpname=currproj->projectname();
	*projname1+=*currpname;
    projectname->add(projname1->c_str(),0,(void (*)(Fl_Widget*,void*))(&(projectname_cb)),(void*)this);
	delete(currpname);
	delete(projname1);
    delete currproj;
}

select_project(projectid);} {}
  }
  Function {populate_songlist(int songid)} {open return_type void
  } {
    code {int i;
int numsongs=currproj->songcount();
\#if (HD24DEBUG==1) 
	cout << "populate_songlist" << endl;
\#endif
if (numsongs==0) 
{
\#if (HD24DEBUG==1) 
		cout << "no songs" << endl;
\#endif
	for (i=0;i<=100;i++) {
		songname->remove(0);
	}
	songname->add("-- Empty project --",0,NULL,(void*)this);
	songname->value(0);
	refresh(songname);
	return;
}
songname->activate();
\#if (HD24DEBUG==1) 
	cout << "clear songlist" << endl;
\#endif
for (i=0;i<=100;i++) {
	songname->remove(0);
}

songname->add("-- All songs --",0,(void (*)(Fl_Widget*,void*))(&(songname_cb)),(void*)this);

\#if (HD24DEBUG==1) 
	cout << "Add songs to dropdown" << endl;
\#endif
for (i=1; i<=numsongs; i++) {
	addsongtodropdown(i);
}
control->ready(1);
this->busy=0;
    
\#if (HD24DEBUG==1) 
	cout << "about to select last used song" << endl;
\#endif
signed long lastsong=currproj->lastsongid();
if (lastsong<1) {
	lastsong=0;
}
\#if (HD24DEBUG==1) 
	cout << "got last song id:" << lastsong << endl;
\#endif
if (lastsong==0) {
	songname->value(0);
	songname->redraw();
	return;
}
select_song(lastsong);
songname->redraw();} {}
  }
  Function {populate_drivelist(int driveid)} {open return_type void
  } {
    code {// when another drive has been selected, init dropdown lists.
for (unsigned int q=0;q<=99;q++) {
	drivename->remove(0);
}
// find out how many ADAT drives are detected.
unsigned int devcount=defaulthd24->hd24devicecount();
\#if (HD24DEBUG==1) 
	cout << "devcount=" << devcount << endl;
\#endif
unsigned int usedevcount=devcount;
if (devcount==0) usedevcount=1; // we are using a file image. 
for (unsigned int devnum=0;devnum<usedevcount;devnum++) 
{
\#if (HD24DEBUG==1) 
cout << "devnum" << devnum << endl; 
\#endif
        // currhd24 is not a spelling error. it is for local use.
       	string* idir=hd24utils::getlastdir("driveimagedir"); 
	hd24fs* currhd24 = new hd24fs(idir->c_str(),defaulthd24->mode(),devnum);
	delete idir;
	if (!(currhd24->isOpen())) {
		if (!(defaulthd24->isOpen())) {
			disable_program_controls();
		}
	}
\#if (HD24DEBUG==1) 
cout << "newfs" << devnum << endl; 
\#endif
	
	string* drivename1=Convert::int2str(devnum+1);
	
	*drivename1+=": ";
	string* volname;
	
\#if (HD24DEBUG==1) 
cout << "getvolname" << devnum << endl; 
\#endif
	
	if (devcount!=usedevcount) 
	{
		volname=currenthd24->volumename();
	} else {
		volname=currhd24->volumename();
	}
	
\#if (HD24DEBUG==1) 
cout << "gotvolname" << devnum << endl; 
\#endif
	
	*drivename1+=*volname;
	// NULL=callback
	drivename->add(drivename1->c_str(),0,(void (*)(Fl_Widget*,void*))(&(drivename_cb)),(void*)this);
	delete(currhd24);
	delete(volname);
	delete(drivename1);
}

/* Set drive info */
\#if (HD24DEBUG==1) 
cout << "set drivename dropdown value to " << driveid << endl;
\#endif
drivename->value(driveid);} {}
  }
  Function {populate_locatepoints(hd24song* locsong,Fl_Choice* lpoints)} {open return_type int
  } {
    code {int i;
int numpoints=0;
if (locsong!=NULL) 
{
 	numpoints=locsong->locatepointcount();
}

\#if (HD24DEBUG==1) 
	cout << "populate_lpoints" << endl;
\#endif
if (numpoints==0) 
{
\#if (HD24DEBUG==1) 
		cout << "no locate points." << endl;
\#endif
	for (i=0;i<=99;i++) {
		lpoints->remove(0);
	}
	lpoints->deactivate();
	refresh(lpoints);
	return numpoints;
}
lpoints->activate();
\#if (HD24DEBUG==1) 
	cout << "clear lpoints" << endl;
\#endif
for (i=0;i<=99;i++) {
	lpoints->remove(0);
}
for (i=0; i<numpoints+1; i++) {
	// locatepoint (max+1) is a virtual locate point 'END'.
\#if (HD24DEBUG==1) 
		cout << "set locate point" << endl;
\#endif
	__uint32 locatepos=locsong->getlocatepos(i);
\#if (HD24DEBUG==1) 
		cout << "locate pos "<<i<<" is " << locatepos << endl;
\#endif
    	string* locname1;
	if ((i==0)||(i==numpoints)) {
		locname1=locsong->getlocatename(i);
		
		if ((locname1->length())>0) {
			while (locname1->substr(0,1)==" ") {
			  *locname1=locname1->substr(1,locname1->length()-1);
			}
			while (locname1->substr(locname1->length()-1,1)==" ") {
			  *locname1=locname1->substr(0,locname1->length()-1);
			}
		} else {
			*locname1+="START";
		}
		*locname1+=": ";
		if (i==numpoints) {
			*locname1+="+";
		}
		string* dur=locsong->display_duration(locatepos);
		*locname1+=*dur;
		delete (dur);
	} else {
		locname1=Convert::int2str(i,2,"0");
		*locname1+=": +";
		string* dur=locsong->display_duration(locatepos);
		*locname1+=*dur;
		delete (dur);
		*locname1+="  ";		
		string* lni=locsong->getlocatename(i);
		*locname1+=*lni;
		delete(lni);
	}

\#if (HD24DEBUG==1) 
	cout << "add lpoints" << endl;
\#endif
	lpoints->add(locname1->c_str(),0,NULL,(void*)this);
	delete locname1;
	lpoints->redraw();
\#if (HD24DEBUG==1) 
	cout << "added lpoints" << endl;
\#endif
}

button_setlocatepoint->activate();
lpoints->value(0);
this->setlocbuttonlabel(0);
return numpoints;} {}
  }
  Function {init_vars()} {open return_type void
  } {
    code {\#if (HD24DEBUG == 1)
cout << "init_vars" << endl;
\#endif
//jackclient=NULL; 
//jackmtsample=NULL; 
currsong=NULL;
currproj=NULL;
//portaudiostream=NULL;
//inputParameters=new PaStreamParameters;
//outputParameters=new PaStreamParameters;
//portaudiooffset=0;
//pa_streamtime=0;
//portaudio_initialized=0;
//portaudio_mustloop=0;
//portaudio_looppos=0;
mustdisplaytimer=true;
mustdispsavemessage=false;
closingdown=false;
savemessage[0]='\\0';
refreshingui=0;
//loopmode=0;
//dispwritecountdown=0;
init_gui(0);
Fl::add_timeout(TIMEOUT,poll_callback,this);} {}
  }
  Function {ui_refresh(const char* orig)} {open
  } {
    code {/* to prevent re-refresh by selecting current project
   which will select a song which will refresh the current
   ui again...(in case of corrupt 'unexpected end of song'
   songs): */
if (refreshingui>1) return;
refreshingui++;

// init dropdown lists.
\#if (HD24DEBUG==1) 
cout << "==TRIGGER GUI REFRESH FROM "<<orig << "==" << endl;
cout << "going to clear dropdown lists" << endl; 
\#endif
for (unsigned int q=0;q<=99;q++) {
	projectname->remove(0);
	songname->remove(0);
}
int devid=0;
if ((currenthd24!=NULL)&&(currenthd24!=defaulthd24))
{
	devid=currenthd24->getdeviceid();
	if (devid<0)
	{
		devid=0;
	}
}
\#if (HD24DEBUG==1) 
cout << "going to populate drive list (" << devid << ")" << endl; 
\#endif

populate_drivelist(devid);

// following uses fsys (the default drive)
\#if (HD24DEBUG==1) 
cout << "get projcount then?" << endl; 
\#endif
string* nump=Convert::int2str(currenthd24->projectcount());
\#if (HD24DEBUG==1) 
cout << "got projcount=" << *nump <<  endl; 
\#endif
number_of_projects->value(nump->c_str());
delete (nump);
\#if (HD24DEBUG==1) 
cout << "last project id=" << currenthd24->lastprojectid() << endl;
\#endif

populate_projectlist(currenthd24->lastprojectid());


string* cat=new string("");
if (hd24utils::gencatalog(this->currenthd24,cat)==0) {
	this->catalogbuffer->remove(0,this->catalogbuffer->length()-1);
	this->catalogbuffer->append(cat->c_str());
	
//	if (this->catalog->buffer()!=NULL) {
//		free(this->catalog->buffer());
//	}
//	this->catalog->buffer(cat->c_str());
}
delete(cat);
\#if (HD24DEBUG==1) 
cout << "get version" << endl; 
\#endif
string* version1=currenthd24->version();
\#if (HD24DEBUG==1) 
cout << "got version" << endl; 
\#endif
fsversion->value(version1->c_str());
delete(version1);

calcspace();
Fl::add_timeout(TIMEOUT,poll_callback,this);

refreshingui--;} {}
  }
  Function {init_gui(int drive)} {open return_type void
  } {
    code {// int drive is for multi drive support.

// deselect all tracks on ' copy to hd24 tab' 
for (unsigned int i=1; i<=MAXCHANNELS; i++) {
   trackselected[i-1]=0;
}
// Neither jack or portaudio were found by configure.
// This means no sound is available, so hide the transport controls.
recorder->control->disable();
recorder->control->audio->mixer(this->mixer->control);

\#if (HD24DEBUG==1) 
	cout << "init_gui" << endl; 
\#endif
Fl::remove_timeout(poll_callback);
ui_refresh("init gui");
Fl::add_timeout(TIMEOUT,poll_callback,this);

populate_formats();
\#if (HD24DEBUG==1) 
	cout << "formats populated" << endl;
\#endif
fromtime->value("START");
totime->value("END");
refresh(fromtime);
refresh(totime);
\#if (HD24DEBUG==1) 
	cout << "init gui complete" << endl;
\#endif

calcspace();
showprogtitle();
            

setstatus("Ready.");} {}
  }
  Function {drivename_cb(Fl_Widget* w, void* data)} {return_type {static void}
  } {
    code {\#if (HD24DEBUG==1) 
	cout << "drivename_cb" << endl;
\#endif
HD24UserInterface *o=(HD24UserInterface *)data;
o->drivename_callback(w,data);} {}
  }
  Function {drivename_callback(Fl_Widget* w, void* data)} {return_type void
  } {
    code {\#if (HD24DEBUG==1) 
	cout << "drivename_callback" << endl;
\#endif
int choicemade=((Fl_Choice*)(w))->value();
\#if (HD24DEBUG==1) 
cout << "chose drive " << choicemade+1 << endl;
\#endif


string* idir=hd24utils::getlastdir("driveimagedir"); 
hd24fs* newcurrenthd=new hd24fs(idir->c_str(),defaulthd24->mode(),choicemade);
delete idir;
currenthd24=newcurrenthd;

init_gui(choicemade);} {}
  }
  Function {trackaction_callback(Fl_Widget* w, void* data)} {return_type void
  } {
    code {\#if (HD24DEBUG==1) 
	cout << "trackaction_callback" << endl;
\#endif
int choicemade=((Fl_Choice*)(w))->value();
if (choicemade==0) {
	((Fl_Choice*)(w))->color(1);
} else {
	((Fl_Choice*)(w))->color(7);
}
\#if (HD24DEBUG==1) 
cout << "chose item " << choicemade << endl;
\#endif} {}
  }
  Function {projectname_cb(Fl_Widget* w, void* data)} {return_type {static void}
  } {
    code {\#if (HD24DEBUG==1) 
	cout << "projectname_cb" << endl;
\#endif
HD24UserInterface *o=(HD24UserInterface *)data;
o->projectname_callback(w,data);} {}
  }
  Function {projectname_callback(Fl_Widget* w, void* data)} {return_type void
  } {
    code {\#if (HD24DEBUG==1) 
	cout << "projectname_callback" << endl;
\#endif
int choicemade=((Fl_Choice*)(w))->value();
select_project(choicemade+1);} {}
  }
  Function {songname_cb(Fl_Widget* w, void* data)} {open return_type {static void}
  } {
    code {\#if (HD24DEBUG == 1 )
	cout << "songname_cb" << endl;
\#endif
HD24UserInterface *o=(HD24UserInterface *)data;
o->songname_callback(w,data);} {}
  }
  Function {songname_callback(Fl_Widget* w, void* data)} {open return_type void
  } {
    code {\#if (HD24DEBUG==1) 
	cout << "songname_callback" << endl;
\#endif
int choicemade=((Fl_Choice*)(w))->value();
if (currproj!=NULL) delete currproj;
currproj=currenthd24->getproject(projectname->value()+1);
//songname->value(choicemade); // should not be needed
select_song(choicemade); // song id=choicemade} {}
  }
  Function {refresh(Fl_Widget * w)} {open return_type void
  } {
    code {w->deactivate();
w->activate();} {}
  }
  decl {time_t starttime,endtime} {}
  Function {calcspace()} {return_type void
  } {
    code {__uint32 rate;
__uint32 tracks;

switch (atrate->value()) {
    case 0: rate=44100; break;
    case 1: rate=48000; break;
    case 2: rate=88200; break;
    case 3: rate=96000; break;
    default: return;
}
switch (attracks->value()) {
    case 0: tracks=2; break;
    case 1: tracks=6; break;
    case 2: tracks=8; break;
    case 3: tracks=12; break;
    case 4: tracks=16; break;
    case 5: tracks=24; break;
    default: return;
}
string* strfree=currenthd24->freespace(rate,tracks);
freespace->value(strfree->c_str());
delete (strfree);} {}
  }
  Function {transferstatus(void* ui,const char* message,double pct)} {open return_type {static void}
  } {
    code {if (ui==NULL) return;
((HD24UserInterface*)ui)->statusmsg->value(message);
((HD24UserInterface*)ui)->fl_check();} {}
  }
  Function {setstatus(string message)} {open return_type void
  } {
    code {statusmsg->value(message.c_str());
fl_check();} {}
  }
  decl {/* ===File transfer stuff ===================================================== */} {}
  decl {Fl_Widget* trackaction[24];} {public
  }
  decl {int transfer_cancel;} {public
  }
  decl {Fl_Output* filename[24];} {public
  }
  Function {savemessage_callback(void* user)} {open return_type {static void}
  } {
    code {HD24UserInterface* mythis=(HD24UserInterface*)user;
string* stat=new string(mythis->savemessage);
mythis->setstatus(*stat);
//mythis->uicanvas->redraw();
mythis->statusbar->damage();
mythis->statusbar->redraw();

delete (stat);
if (mythis->mustdispsavemessage) {
Fl::repeat_timeout(.25,savemessage_callback,user);
}} {}
  }
  Function {countfiletracks(const char* filename)} {open return_type int
  } {
    code {SF_INFO sfinfo;
SNDFILE* infile=NULL;
if (strlen(filename)==0) 
{
	return 0;
}
infile=soundfile->sf_open(filename,SFM_READ,&sfinfo);
if (!infile) 
{
	return 0;
}
int numchans=sfinfo.channels;
soundfile->sf_close(infile);
return numchans;} {}
  }
  decl {char savemessage[300];} {public
  }
  Function {populate_trackaction(HD24UserInterface* ui,Fl_Widget* o,int tracknum)} {open return_type void
  } {
    code {if (tracknum<1) {
return;
}
if (tracknum>24) {
 return;
}

trackaction[tracknum-1]=o;

((Fl_Choice*)o)->clear();
((Fl_Choice*)o)->add("Erase",0,(void (*)(Fl_Widget*,void*))(&(trackaction_cb)),(void*)this);
((Fl_Choice*)o)->add("SMPTE",0,(void (*)(Fl_Widget*,void*))(&(trackaction_cb)),(void*)this);
((Fl_Choice*)o)->add("Mono",0,(void (*)(Fl_Widget*,void*))(&(trackaction_cb)),(void*)this);
// count number of tracks in file given by filename
// when >1, for each track add a line.
int numtracks=countfiletracks(filename[tracknum-1]->value());
if (numtracks>1) {
	for (int i=1; i<=numtracks; i++) {
		string strtrack="Tr.";
		string* strnum=Convert::int2str(i);
		strtrack+=*strnum;
		((Fl_Choice*)o)->add(strtrack.c_str(),0,(void (*)(Fl_Widget*,void*))(&(trackaction_cb)),(void*)this);
		delete strnum;
	}
}
((Fl_Choice*)o)->value(2); // default 0=erase, 1=SMPTE, 2=mono
((Fl_Choice*)o)->redraw();
fl_check();} {}
  }
  Function {populate_trackactionbyfile(__uint32 slotnum,int trackchoice)} {open return_type void
  } {
    code {if (slotnum<0) return;
if (slotnum>23) return;

Fl_Choice* o=(Fl_Choice*)trackaction[slotnum];
if (o==NULL) return;
for (unsigned int i=0;i<128;i++) { o->remove(0); }
o->add("Erase",0,(void (*)(Fl_Widget*,void*))(&(trackaction_cb)),(void*)this);
o->add("SMPTE",0,(void (*)(Fl_Widget*,void*))(&(trackaction_cb)),(void*)this);
o->add("Mono",0,(void (*)(Fl_Widget*,void*))(&(trackaction_cb)),(void*)this);
// count number of tracks in file given by filename
// when >1, for each track add a line.
int numtracks=countfiletracks(filename[slotnum]->value());
if (numtracks>1) {
	for (int i=1; i<=numtracks; i++) {
		string strtrack="Tr.";
		string* strnum=Convert::int2str(i);
		strtrack+=*strnum;
		o->add(strtrack.c_str(),0,(void (*)(Fl_Widget*,void*))(&(trackaction_cb)),(void*)this);
		delete strnum;
	}
}
o->value(trackchoice);
trackaction_callback(o,NULL);
o->redraw();

fl_check();} {}
  }
  Function {moveselected(__sint32 direction)} {open return_type void
  } {
    code {__uint32 firsttrack=0;
__uint32 lasttrack=0;
if (currsong==NULL) 
{
	return;
}
if (direction==-1) 
{
	firsttrack=1;
	lasttrack=currsong->logical_channels();
	if (trackselected[0]==1) 
	{
		// move up, but first track is selected
		// and already upper choice- cannot move up
		return;
	}
} 
else 
{
	if (direction==1)
	{
		lasttrack=1;
		firsttrack=currsong->logical_channels();
		
		if (trackselected[currsong->logical_channels()-1]==1) 
		{
			return;
		}
	}
}
// we need to move stuff.
if (firsttrack==0) return; // direction==0, don't move.

__uint32 tracknum=firsttrack;
while (tracknum!=lasttrack) 
{
	if (trackselected[tracknum-1]!=trackselected[tracknum-1-direction]) 
	{
		int dummy=trackselected[tracknum-1];
		string* trackval=new string(filename[tracknum-1]->value());
		
		trackselected[tracknum-1]=trackselected[tracknum-1-direction];		
		trackselected[tracknum-1-direction]=dummy;
		
		int a=((Fl_Choice*)(trackaction[tracknum-1]))->value();
		int b=((Fl_Choice*)(trackaction[tracknum-1-direction]))->value();
		
		filename[tracknum-1]->value(filename[tracknum-1-direction]->value());		
		filename[tracknum-1-direction]->value(trackval->c_str());		
		
		populate_trackactionbyfile(tracknum-1,b);
		populate_trackactionbyfile(tracknum-1-direction,a);
		
		delete trackval;
	}
	tracknum-=direction;
}

redrawtracks();} {}
  }
  Function {trackaction_cb(Fl_Widget* w, void* data)} {open return_type {static void}
  } {
    code {\#if (HD24DEBUG==1) 
	cout << "trackaction_cb" << endl;
\#endif
HD24UserInterface *o=(HD24UserInterface *)data;
o->trackaction_callback(w,data);} {}
  }
  Function {redrawtracks()} {open return_type void
  } {
    code {bool track_active;
if (currsong==NULL) {
	return;
}

for (unsigned int tracknum=1;tracknum<=MAXCHANNELS;tracknum++) 
{
	if (currsong->logical_channels()>=tracknum) {
		track_active=true;
		filename[tracknum-1]->activate();
	} else {
		track_active=false;
		((Fl_Output*)filename[tracknum-1])->color(7);
		filename[tracknum-1]->deactivate();
	}
	
	if (track_active) {
		if (trackselected[tracknum-1]==1) {
			((Fl_Output*)filename[tracknum-1])->color(3);
		} else {
			((Fl_Output*)filename[tracknum-1])->color(7);
		}
	}

	((Fl_Output*)filename[tracknum-1])->redraw();
}} {}
  }
  decl {/* ===UI stuff ===================================================== */} {}
  Function {populate_formats()} {open return_type void
  } {
    code {\#if (HD24DEBUG==1) 
	cout << "populate_formats" << endl;
\#endif

for (int i=0;i<transeng->supportedformatcount();i++)
{
    fileformat->add(transeng->getformatdesc(i),0,NULL,(void*)this);
}
fileformat->value(0);} {}
  }
  Function {selectfilename(int tracknum)} {return_type void
  } {
    code {this->trackselected[tracknum-1]=1-this->trackselected[tracknum-1];
if (this->trackselected[tracknum-1]==1) {
	this->filename[tracknum-1]->color(3);
} else {
	this->filename[tracknum-1]->color(7);
}
this->filename[tracknum-1]->redraw();} {}
  }
  Function {select_project(int projectid)} {open return_type void
  } {
    code {if (currproj!=NULL) {
	if (currsong!=NULL)
	{
		hd24song* tmpsong=currsong;
		currsong=NULL;
		delete tmpsong;
	}
	hd24project* tmpproj=currproj;
	currproj=NULL;
	delete tmpproj;
}
currproj=currenthd24->getproject(projectid);
\#if (HD24DEBUG==1) 
	cout << "select_project \#" << projectid << endl;
\#endif
currenthd24->lastprojectid(projectid);
projectname->value(projectid-1); /* project id is 1-based */
int currsongcount=0;
if (currproj==NULL)
{
    delete_project->deactivate();
} 
else
{
    delete_project->activate();
    currsongcount=currproj->songcount();
}

if (currsongcount==0) 
{
	number_of_songs->value("0");
	populate_songlist(0); // shows -- EMPTY PROJECT --
	select_song(0);
	return;
}

// currproj is defined at this point.

string* nums=Convert::int2str(currproj->songcount());
number_of_songs->value(nums->c_str());
\#if (HD24DEBUG==1) 
	cout << "number of songs=" << currproj->songcount() << endl;
\#endif
delete(nums);

int lastsongid=currproj->lastsongid();
\#if (HD24DEBUG==1) 
	cout << "lastsongid=" << lastsongid << endl;
\#endif
populate_songlist(lastsongid);} {}
  }
  Function {select_song(int songid)} {open return_type void
  } {
    code {unsigned int i;
button_setlocatepoint->deactivate();
\#if (HD24DEBUG==1) 
cout << "select_song \#" << songid << endl; 
\#endif



if (songid==0) {

	// This represents the choice "all songs"
	if (currsong!=NULL) {
		hd24song* tmpsong=currsong;
		currsong=NULL;		
		delete tmpsong;
	}
	transfersource->value("(All songs in the current project)");
	if (number_of_tracks==NULL) 
	{
		return; // ui not yet initialized?
	}
	tab_tohd24->deactivate();
	rename_song->deactivate();
	delete_song->deactivate();
        number_of_tracks->value("");
	number_of_tracks->deactivate();
	sample_rate->value("");
	sample_rate->deactivate();
	bitdepth->value("");
	bitdepth->deactivate();
	duration->value("");
	duration->deactivate();
	//refresh (songname);
	for (i=0; i<MAXCHANNELS;i++) {
	    track[i]->deactivate();
	    track[i]->value(1);
	    track[i]->show();
	}
	button_setlocatepoint->deactivate();
	button_golocatepoint->deactivate();
	button_invert_tracks->deactivate();
	choice_startloc=0; // use default 
	// disable locatepoint dropdown:
	choice_endloc=populate_locatepoints(currsong,locatepoints);	
	choice_endloc=0;
	update_fromto();	
	fromto->deactivate();
	refresh (tab_tohd24);
	return;

} else {
\#if (HD24DEBUG==1) 
cout << "activate buttons" << endl;
\#endif
	delete_song->activate();
	rename_song->activate();
	tab_tohd24->activate();
	button_golocatepoint->activate();
	button_setlocatepoint->activate();
	button_invert_tracks->activate();
	rename_song->activate();
	sample_rate->activate();
	bitdepth->activate();
	duration->activate();
	refresh (rename_song);
	refresh (number_of_tracks);
	refresh (sample_rate);
	refresh (bitdepth);
	refresh (duration);
	refresh (tab_tohd24);
\#if (HD24DEBUG==1) 
cout << "deselect old song" << endl;
\#endif
	if (currsong!=NULL) {
		recorder->control->song(NULL); /* tell recorder that the song is gone */			
		delete currsong;
		currsong=NULL;
	}	
\#if (HD24DEBUG==1) 
cout << "currprojgetsong" << endl;
\#endif
	currsong=currproj->getsong(songid);
	currproj->lastsongid(songid);
	if (currsong->has_unexpected_end()) {
		if (currsong->is_fixable_unexpected_end()) {
			song_messages->value("Unexpected end of song.\\nTrying to find the rest of the audio...");
//		currenthd24->dumpclusterusage2(currenthd24->findorphanclusters());
			unsigned char* orphans=currenthd24->findorphanclusters();
			if (orphans != NULL) {
				currsong->appendorphanclusters(orphans,true /*allowsongresize*/);
				song_messages->value(
				"Unexpected end of song. I think I found back the rest of it.\\n"
				"However, you really should backup all audio and reformat this drive.");
				if (currenthd24->getmaintenancemode()==1) {
					if (confirm("Song was recovered. Do you wish to save the changes?\\nAnswer Yes only if you have verified that the audio is OK)")) {
						currsong->save();
					}
				}
			}
		}			
		else
		{
			ui_refresh("selectsong");
			song_messages->value("Unexpected end of song.\\nHD24tools can not automatically fix this specific occurence.");
		}
	} else {
		song_messages->value("No messages.");
	}
}


\#if (HD24DEBUG==1) 
cout << "songname->value" << endl;
\#endif

songname->value(songid); // entry 0=all songs, 1=song id 1
string* dummy=currsong->songname();
transfersource->value(dummy->c_str());

/* This should al be done by the recorder.... 
string disp="S";
string* idstr=Convert::int2str(songid,2,"0");
disp+=*idstr;
delete idstr;
disp+=":\\"";
string* dummy=currsong->songname();
transfersource->value(dummy->c_str());
string* dummy2=Convert::readstring((unsigned char*)dummy->c_str(),0,10);
string* dummy3=Convert::readstring((unsigned char*)dummy->c_str(),0,11);

disp+=*dummy2;
delete dummy;
delete dummy2;
if (dummy3->length()>10)
{
disp+="\\4"; // arrow right
} else {
disp+="\\"";
}
delete dummy3;
string* disp2=Convert::padright(disp,16," ");

string* dur=currsong->display_duration();

*disp2+=dur->substr(0,8);
*disp2+=":";
*disp2+=dur->substr(9,2);
*disp2+=" ";
if (currsong->iswriteprotected())
{
*disp2+="\\1";
} else {
*disp2+="\\2";
}
string* strtracksb=Convert::int2str(currsong->logical_channels(),2,"0");
*disp2+=*strtracksb;
delete strtracksb;
*disp2+="t";

recorder->control->dispwrite(0,disp2->c_str());
delete disp2;
 ............. until this point */
recorder->control->song(currsong); /* load song into recorder */

redrawtracks(); // enable/disable tracks for export to HD24	
string* strtracks=Convert::int2str(currsong->logical_channels());
number_of_tracks->value(strtracks->c_str());
number_of_tracks->activate();
delete (strtracks);
string* samrat=Convert::int2str(currsong->samplerate());
sample_rate->value(samrat->c_str());
sample_rate->activate();
delete samrat;
if (mixer!=NULL) {
	mixer->control->samplerate(this->samplerate());
}

string* bitd=Convert::int2str(currsong->bitdepth());
bitdepth->value(bitd->c_str());
bitdepth->activate();
delete(bitd);

string* dur=currsong->display_duration();
duration->value(dur->c_str());
duration->activate();
delete(dur);

if (currsong->iswriteprotected()) {
   writeprotected->value(1); 
} else {
   writeprotected->value(0);
}

refresh (songname);
refresh (number_of_tracks);
refresh (sample_rate);
refresh (bitdepth);
refresh (duration);
refresh (writeprotected);// writeprotected->deactivate();

for (i=0; i<currsong->logical_channels();i++) {
    track[i]->activate();
    track[i]->show();
    trackled[i]->show();
}
for (i=currsong->logical_channels();i<MAXCHANNELS;i++) {
    track[i]->deactivate();
    track[i]->hide();
    trackled[i]->hide();
}

choice_startloc=0; // use default 
choice_endloc=populate_locatepoints(currsong,locatepoints);
button_golocatepoint->activate();
if (choice_endloc>0) {
	fromto->activate();
}
update_fromto();} {}
  }
  decl {int choice_startloc;} {}
  decl {int choice_endloc;} {}
  decl {bool mustdispsavemessage;} {public
  }
  decl {int loopmode;} {public
  }
  decl {int uiredrawcount; /* to limit refreshing UI */} {public
  }
  Function {update_fromto()} {return_type void
  } {
    code {if (currsong==NULL)
{
fromtime->value("START");
totime->value("END");
return;
}
string* dummy1=currsong->getlocatename(choice_startloc);
string* dummy2=currsong->getlocatename(choice_endloc);
string* strfrom=Convert::trim(dummy1);
string* strto=Convert::trim(dummy2);


fromtime->value(strfrom->c_str());
totime->value(strto->c_str());
delete(dummy1);
delete(dummy2);
delete (strfrom);
delete (strto);} {}
  }
  Function {make_window(hd24fs* p_fsys) /* <------------------------------------------- */} {open
  } {
    Fl_Window {} {
      label HD24connect open
      xywh {485 44 605 530} type Double color 52 align 5
      code0 {defaulthd24=p_fsys;}
      code1 {currenthd24=p_fsys; // current and default to allow multi drive support}
      code2 {init_vars();} visible
    } {
      Fl_Group {} {open
        xywh {-5 0 1720 540}
      } {
        Fl_Group menucanvas {open
          xywh {0 0 640 24}
        } {
          Fl_Menu_Bar {} {open
            xywh {0 0 640 24} color 52
          } {
            Submenu menufile {
              label {&File} open
              xywh {0 0 100 20} labelsize 12
            } {
              MenuItem {} {
                label {&Detect HD24 drives}
                callback {if (currenthd24!=NULL) {
    delete currenthd24;
    currenthd24=NULL;
}

string* idir=hd24utils::getlastdir("driveimagedir"); 
currenthd24=new hd24fs(idir->c_str(),hd24fs::MODE_RDWR);
delete idir;
defaulthd24=currenthd24;
if (!(currenthd24->isOpen())) 
{
   fl_message("Sorry, during detection no valid HD24 drive was found connected to the system.\\nPlease switch on and connect the drive, or try another File menu option.");
}
ui_restart();}
                xywh {0 0 34 21} labelsize 12 divider
              }
              MenuItem {} {
                label {&Open drive image...}
                callback {string* driveimgdir=hd24utils::getlastdir("driveimagedir");

Fl_Native_File_Chooser chooser;
chooser.directory(driveimgdir->c_str());
delete driveimgdir;
chooser.title("Select HD24 drive image\\0");
chooser.type(Fl_Native_File_Chooser::BROWSE_FILE);
chooser.filter("Drive Images\\t*.{img,bin,h24,hd24}\\0");
//chooser.preview(0);
switch (chooser.show()) {
	case -1: break; //error
	case 1: break; //cancel
	default:
		if (chooser.filename()) {
			string* cfilename=new string(chooser.filename());
		
			//cout << "filename = " << *strfile << endl;
			string* fpath=new string("");
			*fpath+=cfilename->substr(0,strlen(cfilename->c_str())-strlen(fl_filename_name(cfilename->c_str())));
			hd24utils::setlastdir("driveimagedir",fpath->c_str());
					
			hd24fs* sysob=new hd24fs(fpath->c_str(),hd24fs::MODE_RDWR,cfilename,false);
			delete cfilename;
			if (currenthd24!=NULL) 
			{
				currenthd24->~hd24fs();
			}
			if (defaulthd24!=NULL) 
			{
				if (defaulthd24!=currenthd24)
				{
					defaulthd24->~hd24fs();
				}
			}
			currenthd24=sysob;
			defaulthd24=sysob;
			
			if (!(currenthd24->isOpen())) 
			{
	  		   bool choice=confirm(
				"File does not appear to be a valid HD24 device image.\\nDo you want to try using it anyway?\\nWarning: Choosing 'Yes' may result in\\ncrashes and other unpredictable behavior."
				);
			
			   if (choice) {
			        if (sysob!=NULL) {
				   	delete (sysob);
				}
				bool wantheader=confirm("Do you want to load a header file?");
				
				cfilename=new string(chooser.filename());
       				string* idir=hd24utils::getlastdir("driveimagedir"); 
			   	sysob=new hd24fs(idir->c_str(),hd24fs::MODE_RDWR,cfilename,true); //force
				delete idir;
				delete cfilename;
				if (currenthd24!=NULL) 
				{
					currenthd24->~hd24fs();
				}
				if (defaulthd24!=NULL) 
				{
					if (defaulthd24!=currenthd24)
					{
						defaulthd24->~hd24fs();
					}

				}
				
				currenthd24=sysob;
				defaulthd24=sysob;
				if (currenthd24->isOpen()) {
					if (wantheader) {
					   loadheaderfile();
					}
					ui_restart();
					return;
				}
				fl_message("Cannot open HD24 device image.");
			   }
			   
			   return;
			}
			ui_restart();			
		}
		break;
}}
                xywh {0 0 34 21} labelsize 12
              }
              MenuItem {} {
                label {&Save drive image...}
                callback {string* driveimgdir=new string("");
*driveimgdir+=*hd24utils::getlastdir("driveimagedir");

Fl_Native_File_Chooser chooser;
chooser.filter("Drive Images\\t*.{img,bin,h24,hd24}\\0");
chooser.title("Export full drive image file");
chooser.directory(driveimgdir->c_str());
chooser.options(Fl_Native_File_Chooser::NEW_FOLDER);
chooser.type(Fl_Native_File_Chooser::BROWSE_SAVE_FILE);

switch (chooser.show()) {
	case -1: break; //error
	case 1: break; //cancel
	default:
		// save header to chooser.filename()

		bool bFileexists=hd24utils::fileExists(chooser.filename());
		if (bFileexists) {
			bool choice=confirm(
				"A file with this name already exists. Do you wish to overwrite it?"
				);			
			if (!(choice)) return;
		}
		string* strfile=new string(chooser.filename());
		//cout << "filename = " << *strfile << endl;
		string* fpath=new string("");
		*fpath+=strfile->substr(0,strlen(strfile->c_str())-strlen(fl_filename_name(strfile->c_str())));
		hd24utils::setlastdir("driveimagedir",fpath->c_str());
		this->transfer_cancel=0;
		this->mustdispsavemessage=true;
		Fl::add_timeout(.25,savemessage_callback,this);
		int result=hd24utils::savedriveimage(currenthd24,strfile,&this->savemessage[0],&this->transfer_cancel);
		delete strfile;
		if (result==0) {
			fl_message("Drive image created successfully.");
			setstatus("Done.");
		} else {
			fl_message("Could not write drive image to file. Access denied? Disk full?");	
		}
		this->mustdispsavemessage=false;
		break;
}
delete driveimgdir;}
                xywh {10 10 34 21} labelsize 12
              }
              Submenu {} {
                label {&Catalog} open
                xywh {0 0 70 21} labelsize 12
              } {
                MenuItem {} {
                  label {&Export catalog...}
                  callback {string* catdir=new string("");
*catdir+=*hd24utils::getlastdir("catalogdir");

Fl_Native_File_Chooser chooser;
chooser.filter("Text files\\t*.txt");
chooser.title("Export disk catalog to file");
chooser.directory(catdir->c_str());
chooser.options(Fl_Native_File_Chooser::NEW_FOLDER);
chooser.type(Fl_Native_File_Chooser::BROWSE_SAVE_FILE);

switch (chooser.show()) {
	case -1: break; //error
	case 1: break; //cancel
	default:
		// save header to chooser.filename()

		bool bFileexists=hd24utils::fileExists(chooser.filename());
		if (bFileexists) {
			bool choice=confirm(
				"A file with this name already exists. Do you wish to overwrite it?"
				);			
			if (!(choice)) return;
		}
		string* strfile=new string(chooser.filename());
		//cout << "filename = " << *strfile << endl;
		string* fpath=new string("");
		*fpath+=strfile->substr(0,strlen(strfile->c_str())-strlen(fl_filename_name(strfile->c_str())));
		hd24utils::setlastdir("catalogdir",fpath->c_str());
		string* anyerrors=hd24utils::savecatalog(currenthd24,strfile);
		delete strfile;
		if (anyerrors==NULL) {
			fl_message("Catalog file created successfully.");
		} else {	
			delete anyerrors;
			fl_message("Could not write catalog file. Access denied? Disk full?");	
		}
		break;
}
delete catdir;}
                  tooltip {Save the disk directory to a printable text file} xywh {40 40 34 21} labelsize 12
                }
                MenuItem {} {
                  label {&Print catalog}
                  callback {string* result=hd24utils::printcatalog(currenthd24);
if (result!=NULL) 
{
	if (strlen(result->c_str())!=0) 
	{
		fl_message("%s",result->c_str());
	}
}
delete result;}
                  tooltip {Save the disk directory to a printable text file} xywh {30 30 34 21} labelsize 12 divider
                }
              }
              Submenu {} {
                label {&Mixer} open
                xywh {10 10 70 21} labelsize 12
              } {
                MenuItem {} {
                  label {&Save mixer settings to file,,,}
                  callback {mixer->savetofile();}
                  tooltip {Save the current mixer settings to a file} xywh {50 50 34 21} labelsize 12
                }
                MenuItem {} {
                  label {&Load mixer settings from file...}
                  callback {mixer->loadfromfile();}
                  tooltip {Recall mixer settings from a previously saved mix} xywh {60 60 34 21} labelsize 12 divider
                }
                MenuItem {} {
                  label {&Save mixer settings to HD24 drive,,,}
                  tooltip {Save the current mix onto the HD24 drive} xywh {60 60 34 21} labelsize 12 deactivate
                }
                MenuItem {} {
                  label {&Load mixer settings from HD24 drive...}
                  tooltip {Recall mixer settings from a mix previously saved to the current HD24 drive} xywh {70 70 34 21} labelsize 12 deactivate
                }
              }
              Submenu {} {
                label {&Recovery} open
                xywh {0 0 70 21} labelsize 12 divider
              } {
                MenuItem {} {
                  label {&Select device...}
                  callback {dialog_choosedevice* chooser=new dialog_choosedevice();
Fl_Double_Window* w=chooser->make_window(currenthd24);
w->end();
w->show();
while (w->visible()) { 
Fl::wait();
}
string* cfilename;
hd24fs* sysob;
string* idir=NULL;
switch (chooser->buttonclicked) {
	case 1:
		// OK
		cfilename=new string(chooser->devicename->c_str());
		idir=hd24utils::getlastdir("driveimagedir"); 
		sysob=new hd24fs(idir->c_str(),hd24fs::MODE_RDWR,cfilename,false);
		delete idir; idir=NULL;

		currenthd24=sysob;
		defaulthd24=sysob;
			
		if (!(currenthd24->isOpen())) 
		{
	  	   bool choice=confirm(
			"Device does not appear to be a valid HD24 device.\\nDo you want to try using it anyway?\\nWarning: Choosing 'Yes' may result in\\ncrashes and other unpredictable behavior."
		   );
		
		   if (choice) {
		        if (sysob!=NULL) {
			   	delete (sysob);
			}
       			string* idir=hd24utils::getlastdir("driveimagedir"); 
		   	sysob=new hd24fs(idir->c_str(),hd24fs::MODE_RDWR,cfilename,true); //force
			delete idir;
			currenthd24=sysob;
			defaulthd24=sysob;
			int tryheader=0;
			if (currenthd24->isOpen()) {
			        tryheader=1;
				bool wantheader=confirm("Do you want to load a header file?");
				if (wantheader) {
				   loadheaderfile();
				}
			
				ui_restart();
				delete cfilename;
				return;
			}
			if (tryheader==1) {
  			    fl_message("Cannot open HD24 device.");
  			} else {
    			    fl_message("Cannot open HD24 device. Access denied?");
  			}
		   }
		   delete cfilename;
		   break;
		}
		ui_restart();			
		delete cfilename;		
		break;
	case 2:
		// cancel
		break;
	default:
		// unknown
		break;
}
delete chooser;}
                  xywh {5 5 34 21} labelsize 12
                }
                MenuItem {} {
                  label {Load &header file...}
                  callback {loadheaderfile();}
                  xywh {5 5 34 21} labelsize 12
                }
                MenuItem {} {
                  label {&Create header file...}
                  callback {string* headerdir=new string("");
*headerdir+=*hd24utils::getlastdir("headerdir");

Fl_Native_File_Chooser chooser;
chooser.filter("Header files (*.h24)\\t");
chooser.title("Create header file");
chooser.options(Fl_Native_File_Chooser::NEW_FOLDER);
chooser.directory(headerdir->c_str());
chooser.type(Fl_Native_File_Chooser::BROWSE_SAVE_FILE);

switch (chooser.show()) {
	case -1: break; //error
	case 1: break; //cancel
	default:
		// save header to chooser.filename()
		bool bFileexists=hd24utils::fileExists(chooser.filename());
		if (bFileexists) {
			bool choice=confirm(
				"A file with this name already exists. Do you wish to overwrite it?"
				);			
			if (!(choice)) return;
		}
		string* strfile=new string(chooser.filename());
		string* fpath=new string("");
		*fpath+=strfile->substr(0,strlen(strfile->c_str())-strlen(fl_filename_name(strfile->c_str())));
		hd24utils::setlastdir("headerdir",fpath->c_str());
		
		int result=hd24utils::saveheader(currenthd24,strfile);
		delete strfile;
		if (result==0) {
			fl_message("Header file created successfully.");
		} else {
			fl_message("Could not write header file. Access denied? Disk full?");		
		}
		break;
}}
                  xywh {15 15 34 21} labelsize 12
                }
                MenuItem {} {
                  label {Recover song from &power failure}
                  callback {if (currsong==NULL) {
	fl_message("First select the song to recover.");
	return;
}

dialog_setlength* ui_setlength;
ui_setlength=new dialog_setlength;
int currlocchoice=locatepoints->value();
Fl_Window *win=ui_setlength->make_window(currsong,currlocchoice);
win->end();
win->show();

while (win->visible()) { Fl::wait(); }

if (ui_setlength->buttonclicked==1) {
	// TODO:
	// - create header file
	//   getuserdatapath. 
	//    
	
	char userdatapath[FL_PATH_MAX];
	Fl_Preferences* prefs=new Fl_Preferences(Fl_Preferences::USER,"HD24","HD24connect");
	prefs->getUserdataPath(userdatapath,FL_PATH_MAX);
	delete prefs;
	string* headerfilename=new string(userdatapath);
	
	// add OS directory slash if forgotten
\#ifdef WINDOWS
\#define OSSLASH '\\\\'
\#else
\#define OSSLASH '/'
\#endif
const char* x=headerfilename->c_str();
int q=strlen(x);
if (q>0) 
{
	if (x[q-1]!=OSSLASH) 
  	{
  		*headerfilename+=OSSLASH;
  	}
}		
*headerfilename+="livefix.h24";
	
	int createtempheaderresult=hd24utils::savedrivesectors(currenthd24,headerfilename,0,0x10c76,NULL,NULL);

	if (createtempheaderresult!=0)
	{
		delete headerfilename;
		fl_message("Couldn't create a temporary header file, cannot continue. Sorry.");
		return;
	}
	// header was created successfully.
	currenthd24->useheaderfile(*headerfilename);	
	//cout << "Userdatapath="<<userdatapath << endl;

	// - use header file
	// - this makes sure any writes go to header file

	bool clearnew=false;
	currsong->songlength_in_samples(ui_setlength->locpoint,clearnew);
	currsong->save();
	ui_refresh("liverec");
}
delete ui_setlength;}
                  xywh {10 10 36 21} labelsize 12
                }
              }
              MenuItem {} {
                label {E&xit}
                callback {/* Find current window */
this->finish();

Fl_Window * x=Fl::first_window();
x->~Fl_Window();
delete x;
x=NULL;}
                xywh {0 0 100 20} labelsize 12
              }
            }
            Submenu menutools {
              label {&Tools} open
              xywh {10 10 100 20} labelsize 12
            } {
              Submenu {} {
                label {Alter &order of songs in project} open
                xywh {20 20 100 20} labelsize 12 divider
              } {
                MenuItem {} {
                  label {Sort &Alphabetically}
                  callback {if (this->currproj==NULL)
{
	fl_message("Cannot sort project- no project selected.");
	return;
}
this->currproj->sort();
this->currproj->save();
this->ui_refresh("sort");}
                  xywh {30 30 34 21} labelsize 12
                }
              }
              MenuItem {} {
                label {&Options...}
                callback {dialog_options* ui_options;
ui_options=new dialog_options;
Fl_Window *win=ui_options->make_window();
win->end();
win->show();

while (win->visible()) { Fl::wait(); }

delete ui_options;}
                xywh {30 30 34 21} labelsize 12
              }
            }
            Submenu menuhelp {
              label {&Help} open
              xywh {0 0 100 20} labelsize 12
            } {
              MenuItem {} {
                label {&About}
                callback {UserInterface_HelpAbout* ui_help_about;
ui_help_about=new UserInterface_HelpAbout;

Fl_Window *helpaboutdialog=ui_help_about->make_window();
helpaboutdialog->end();
helpaboutdialog->show();

while (helpaboutdialog->visible()) { Fl::wait(); }}
                xywh {0 0 100 20} labelsize 12
              }
              MenuItem {} {
                label {System &Info}
                callback {string info="HD24connect system info\\n";
info+="JACK: ";
if (libjack->libloaded) {
	info+="Loaded";
} else {
	info+="Not present";
}
info+="\\n";

info+="LIBSNDFILE: ";
if (soundfile->libloaded) {
	info+="Loaded";
} else {
	info+="Not present";
}
info+="\\n";


info+="PORTAUDIO: ";
if (portaudio->libloaded) {
	info+="Loaded";
} else {
	info+="Not present";
}
info+="\\n";


fl_message("%s",info.c_str());}
                xywh {20 20 100 20} labelsize 12
              }
              MenuItem {} {
                label {Report a &Bug}
                callback {string bug="No warranty of any kind is given on this program.\\n\\n";
bug+="However, if you find any defects or faults in it, they\\n";
bug+="will most likely be fixed with high priority in the next\\n";
bug+="release, as long as the author is aware of them.\\n\\n";
bug+="Should you find any defects, please email the author at\\n";
bug+="the following e-mail address:\\n\\n";
bug+="mrjb@@dnd.utwente.nl.\\n\\n";
bug+="Make sure to include 'hd24' in the subject line.";
fl_message("%s",bug.c_str());}
                xywh {0 0 100 20} labelsize 12
              }
              MenuItem {} {
                label {Request a &Feature}
                callback {string bug="If you would like a specific feature to be added, please\\n";
bug+="please email your request to the author at the following \\n";
bug+="e-mail address:\\n\\n";
bug+="mrjb@@dnd.utwente.nl.\\n\\n";
bug+="Make sure to include 'hd24 feature request' in the subject line.\\n";
bug+="You can increase the priority of the request by donating.";
fl_message("%s",bug.c_str());}
                xywh {10 10 100 20} labelsize 12
              }
              MenuItem {} {
                label {&Credits}
                callback {string thanks="Extra Special thanks go out to: \\n\\n";
thanks+="Randy Bryant for trusting me to use his Mac\\n";
thanks+="Mike Crute for hosting and builder support\\n";
thanks+="Cabbage for building various Mac package installers\\n";
thanks+="Edward van Westerlaak for Windows and Mac/OSX beta testing, hardware support and suggestions\\n";
thanks+="Erik de Castro Lopo and other contributors for libsndfile\\n";
thanks+="Ross Bencina, Phil Burk, Bjorn Roche and other contributors for the portaudio library\\n";
thanks+="Bill Spitzak and others for the Fast Light Toolkit\\n";
thanks+="Sveinn Kjartansson for providing the means for high sample rate support\\n\\n";
thanks+="Special thanks go out to the Yahoo Groups HD24 community\\n";
thanks+="for additional beta testing, suggestions and general encouragement.\\n\\n";
fl_message("%s",thanks.c_str());}
                xywh {10 10 100 20} labelsize 12
              }
            }
          }
        }
        Fl_Group uicanvas {open
          xywh {-5 0 1720 540} resizable
        } {
          Fl_Group transfercanvas {
            label Transfer
            xywh {10 360 590 150} box UP_BOX color 52 labelfont 1 labelsize 12 align 5
          } {}
          Fl_Group statusbar {
            xywh {-5 510 725 20} box DOWN_BOX color 23
          } {
            Fl_Output backgroundbox {
              xywh {0 510 605 20} color 52 labelsize 12 textsize 12
            }
            Fl_Button stop_transfer {
              label Cancel
              callback {transfer_cancel=1;
stop_transfer->hide();}
              xywh {525 510 80 20} labelsize 12 align 16
              code0 {o->hide();}
            }
            Fl_Output statusmsg {
              xywh {0 510 525 20} color 52 labelsize 12 textsize 12
            }
          }
          Fl_Tabs Tabs {
            callback {this->readmixer();
this->mixer->damage();
if (o->value()==tabRecorder)
{
	if (recorder->button_play->value()==0)
	{
		showprogtitle();
	}
}} open
            xywh {-5 25 1600 485}
            code0 {o->value(tabDrive);}
          } {
            Fl_Group tabDrive {
              label Drive open
              xywh {0 45 605 465} box UP_BOX color 52 labelfont 1 labelsize 12 align 5 hide
            } {
              Fl_Choice drivename {
                label {Drive name:}
                xywh {155 80 440 20} down_box BORDER_BOX labelsize 12 textsize 12
              } {}
              Fl_Output fsversion {
                label {FS version:}
                xywh {305 105 50 20} labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Output number_of_projects {
                label {Number of projects:}
                xywh {155 105 70 20} labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Button rename_drive {
                label {Rename...}
                callback {if (currenthd24==NULL) return;
dialog_rename* ui_rename;
ui_rename=new dialog_rename();
string* currname=currenthd24->volumename();
string* strname=new string("Rename project");
Fl_Window* win=ui_rename->make_window(currname,strname);
if (strname!=NULL) 
{ 
 	delete strname;
}
if (currname!=NULL)
{	
	delete currname;
}
win->end();
win->show();

while (win->visible()) { Fl::wait(); }
if (ui_rename->buttonclicked==1) 
{
  // OK clicked
  if (confirm("Do you wish to write the changes to disk?")) {
        currenthd24->setvolumename(*(ui_rename->itemname));
  	currenthd24->savedriveinfo();
	populate_drivelist(1+drivename->value());
	drivename->redraw();
  }  
}
delete ui_rename;
ui_refresh("ren proj");}
                xywh {510 105 85 20} labelsize 12 align 16
              }
              Fl_Output freespace {
                label {Free space preview:}
                xywh {155 130 140 20} labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Choice atrate {
                label {at }
                callback {calcspace();} open
                xywh {320 130 85 20} down_box BORDER_BOX labelsize 12 textsize 12
                code0 {o->value(0);}
              } {
                MenuItem {} {
                  label 44100
                  xywh {5 5 100 20} value 1 labelsize 12
                }
                MenuItem {} {
                  label 48000
                  xywh {15 15 100 20} value 1 labelsize 12
                }
                MenuItem {} {
                  label 88200
                  xywh {25 25 100 20} value 1 labelsize 12
                }
                MenuItem {} {
                  label 96000
                  xywh {35 35 100 20} value 1 labelsize 12
                }
              }
              Fl_Choice attracks {
                label {Hz, }
                callback {calcspace();} open
                xywh {435 130 75 20} down_box BORDER_BOX labelsize 12 textsize 12
                code0 {o->value(5);}
              } {
                MenuItem {} {
                  label 2
                  xywh {15 15 100 20} value 1 labelsize 12
                }
                MenuItem {} {
                  label 6
                  xywh {25 25 100 20} value 1 labelsize 12
                }
                MenuItem {} {
                  label 8
                  xywh {35 35 100 20} value 1 labelsize 12
                }
                MenuItem {} {
                  label 12
                  xywh {45 45 100 20} value 1 labelsize 12
                }
                MenuItem {} {
                  label 16
                  xywh {55 55 100 20} value 1 labelsize 12
                }
                MenuItem {} {
                  label 24
                  xywh {65 65 100 20} value 1 labelsize 12
                }
              }
              Fl_Box {} {
                label tracks
                xywh {510 130 55 20} labelsize 12 align 20
              }
              Fl_Group {} {open
                xywh {25 70 15 15}
              } {}
              Fl_Box {} {
                label {Drive information}
                xywh {0 58 5 17} labelfont 1 labelsize 12 align 8
              }
              Fl_Text_Display catalog {
                label {Drive contents}
                xywh {5 190 595 310} box DOWN_BOX labelfont 1 labelsize 12 align 5 textfont 4 textsize 12
                code0 {if (catalogbuffer==NULL) catalogbuffer=new Fl_Text_Buffer(); string* cat=new string("\\n"); catalogbuffer->append(cat->c_str()); delete cat;}
                code1 {o->buffer(catalogbuffer); o->scrollbar_align(FL_ALIGN_RIGHT);}
              }
              Fl_Button format_driveimage {
                label Format
                callback {bool wantformat=confirm("This will COMPLETELY ERASE\\nALL projects and songs on this drive.\\nAre you SURE you want to format the current drive?\\n");
if (!wantformat) return;
// Okay, user is absolutely sure.
currenthd24->write_enable();
currenthd24->quickformat(NULL);
// there's no point in re-enabling write 
// protection again now, is there?
ui_refresh("format");
setstatus("Format complete.");
return;}
                xywh {455 105 55 20} labelsize 12 align 16
              }
              Fl_Button create_driveimage {
                label {New Image...}
                callback {dialog_filesize* ui_filesize;
ui_filesize=new dialog_filesize();
Fl_Window *win=ui_filesize->make_window();
win->end();
win->show();

while (win->visible()) { Fl::wait(); }
__uint32 lastsector=0;

if (ui_filesize->buttonclicked!=1) 
{
	delete ui_filesize;
	return;
}

lastsector=ui_filesize->lastsector;
delete ui_filesize;

string* driveimgdir=new string("");
*driveimgdir+=*hd24utils::getlastdir("driveimagedir");

Fl_Native_File_Chooser chooser;
chooser.filter("Drive Images\\t*.{img,bin,h24,hd24}\\0");
chooser.title("Create empty drive image in file");
chooser.directory(driveimgdir->c_str());
chooser.options(Fl_Native_File_Chooser::NEW_FOLDER);
chooser.type(Fl_Native_File_Chooser::BROWSE_SAVE_FILE);

switch (chooser.show()) {
	case -1: break; //error
	case 1: break; //cancel
	default:
		// save header to chooser.filename()

		bool bFileexists=hd24utils::fileExists(chooser.filename());
		if (bFileexists) {
			bool choice=confirm(
				"A file with this name already exists. Do you wish to overwrite it?"
				);			
			if (!(choice)) return;
		}
		string* strfile=new string(chooser.filename());
		//cout << "filename = " << *strfile << endl;
		string* fpath=new string("");
		*fpath+=strfile->substr(0,strlen(strfile->c_str())-strlen(fl_filename_name(strfile->c_str())));
		hd24utils::setlastdir("driveimagedir",fpath->c_str());
		this->transfer_cancel=0;
		this->mustdispsavemessage=true;
		Fl::add_timeout(.25,savemessage_callback,this);
//		__uint32 lastsector=2097151; // 1 GiB
		int result=hd24utils::newdriveimage(strfile,lastsector,&this->savemessage[0],&this->transfer_cancel);

		this->mustdispsavemessage=false;
		setstatus("Done.");
		if (result==0) {
			setstatus("Done.");
			int wantopen=confirm("Drive image created successfully.\\nDo you want to open it now?");
			if (wantopen==1)
			{
       				string* idir=hd24utils::getlastdir("driveimagedir"); 
				hd24fs* sysob=new hd24fs(idir->c_str(),hd24fs::MODE_RDWR,strfile,false);
				delete idir;
				if (currenthd24!=NULL) 
				{
					currenthd24->~hd24fs();
				}
				if (defaulthd24!=NULL) 
				{
					if (defaulthd24!=currenthd24)
					{
						defaulthd24->~hd24fs();
					}

				}
				currenthd24=sysob;
				defaulthd24=sysob;
			}
			
		} else {
			fl_message("Could not write drive image to file. Access denied? Disk full?");	
		}
		delete strfile;		
		break;
}
setstatus("Done.");
ui_refresh("newdriveimage");
delete driveimgdir;}
                xywh {360 105 95 20} labelsize 12 align 16
              }
              Fl_Box {} {
                label {Songs marked * are write-protected.}
                xywh {235 175 365 15} labelfont 2 labelsize 12 align 24
              }
            }
            Fl_Group songinfogroup {
              label {Project/Song}
              xywh {0 50 605 460} box UP_BOX color 52 labelfont 1 labelsize 12 align 5 hide
            } {
              Fl_Choice songname {
                label {Song name:} open
                xywh {155 155 440 20} down_box BORDER_BOX labelsize 12 textsize 12
              } {}
              Fl_Output number_of_tracks {
                label {Number of tracks:}
                xywh {155 180 90 20} labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Output sample_rate {
                label {Sample rate:}
                callback {if (currsong==NULL) return;
bool confirmrate=false;
if (strcmp(o->value(),"44100")==0) {
	o->value("48000");
	currsong->samplerate(48000);
	if (mixer!=NULL) mixer->control->samplerate(48000);
	confirmrate=confirm("Re-stamp song as 48000Hz on disk?");
} else {
	if (strcmp(o->value(),"48000")==0) {
		o->value("44100");
		currsong->samplerate(44100);
		if (mixer!=NULL) mixer->control->samplerate(44100);
		confirmrate=confirm("Re-stamp song as 44100Hz on disk?");
	}
}
if (strcmp(o->value(),"88200")==0) {
	o->value("96000");
	currsong->samplerate(96000);
	if (mixer!=NULL) mixer->control->samplerate(48000);
	confirmrate=confirm("Re-stamp song as 96000Hz on disk?");
} else {
	if (strcmp(o->value(),"96000")==0) {
		o->value("88200");
		if (mixer!=NULL) mixer->control->samplerate(44100);
		confirmrate=confirm("Re-stamp song as 88200Hz on disk?");
	}
}

  if (confirmrate) {
//	currsong->songname(*(ui_rename->itemname));
  	currsong->save();
  	populate_songlist(songname->value());
  } else {



if (strcmp(o->value(),"44100")==0) {
	o->value("48000");
	currsong->samplerate(48000);
	if (mixer!=NULL) mixer->control->samplerate(48000);
} else {
	if (strcmp(o->value(),"48000")==0) {
		o->value("44100");
		currsong->samplerate(44100);
		if (mixer!=NULL) mixer->control->samplerate(44100);
	}
}
if (strcmp(o->value(),"88200")==0) {
	o->value("96000");
	currsong->samplerate(96000);
	if (mixer!=NULL) mixer->control->samplerate(48000);
} else {
	if (strcmp(o->value(),"96000")==0) {
		o->value("88200");
		currsong->samplerate(88200);
		if (mixer!=NULL) mixer->control->samplerate(44100);
	}
}


  }
ui_refresh("stamprate");}
                xywh {155 230 90 20} labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Output bitdepth {
                label {Bit depth:}
                xywh {155 255 90 20} labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Output duration {
                label {Duration:}
                xywh {155 205 90 20} labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Button rename_song {
                label {Rename...}
                callback {if (currsong==NULL) return;
dialog_rename* ui_rename;
ui_rename=new dialog_rename();
string* currname=currsong->songname();
string* strsong=new string("Rename song");
Fl_Window* win=ui_rename->make_window(currname,strsong);
delete strsong;
win->end();
win->show();

while (win->visible()) { Fl::wait(); }
if (ui_rename->buttonclicked==1) 
{
  // OK clicked
  if (confirm("Do you wish to write the changes to disk?")) {
	currsong->songname(*(ui_rename->itemname));
  	currsong->save();
	populate_songlist(songname->value());
  }
}

delete ui_rename;
ui_refresh("rename song");}
                xywh {510 180 85 20} labelsize 12 align 16
              }
              Fl_Choice locatepoints {
                label {Locate points:}
                callback {setlocbuttonlabel(locatepoints->value());
if ((locatepoints->value())==25) {
button_setlocatepoint->deactivate();
} else {
button_setlocatepoint->activate();
}} open
                xywh {155 280 215 20} down_box BORDER_BOX labelsize 12 textsize 12 deactivate
              } {}
              Fl_Button button_setlocatepoint {
                label {Edit...}
                callback {if (currsong==NULL) return;
dialog_setlocate* ui_setlocate;
ui_setlocate=new dialog_setlocate;
int currlocchoice=locatepoints->value();
Fl_Window *win=ui_setlocate->make_window(currsong,locatepoints->value());
win->end();
win->show();

while (win->visible()) { Fl::wait(); }

/* Dialog has closed, read the results */

populate_locatepoints(currsong,locatepoints);
locatepoints->value(currlocchoice);

if (ui_setlocate->useasrange==1) {
   if (currlocchoice==1) 
   {
	choice_startloc=1;	
   }
   if (currlocchoice==2) 
   {
   	choice_endloc=2;
   }
}
currsong->save();
	
update_fromto();
delete ui_setlocate;}
                xywh {370 280 60 20} labelsize 12 align 16 deactivate
              }
              Fl_Check_Button writeprotected {
                label {Write protected}
                callback {if (currsong==NULL) return;
bool confirmprot=false;
if (o->value()==0) {
	currsong->setwriteprotected(false);
	confirmprot=confirm("Write-enable song on disk?");
} else {
	if (o->value()==1) {
		currsong->setwriteprotected(true);
		confirmprot=confirm("Write-protect song on disk?");
	}
}

if (confirmprot) {
	currsong->save();
        populate_songlist(songname->value());
} else {
	if (o->value()==0) {
		o->value(1);
	} else {
		o->value(0);
	}
}
ui_refresh("writeprot");}
                xywh {155 300 20 25} down_box DOWN_BOX labelsize 12 align 8
              }
              Fl_Button button_golocatepoint {
                label Go
                callback {if (currsong==NULL) return;
if (recorder==NULL) return;
recorder->control->hd24_transport_goloc(currsong->getlocatepos(locatepoints->value()));}
                xywh {435 280 155 20} labelsize 12 align 16
              }
              Fl_Output number_of_songs {
                label {Number of songs:}
                xywh {155 105 85 20} labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Choice projectname {
                label {Project name:} open
                xywh {155 80 440 20} down_box BORDER_BOX labelsize 12 textsize 12
              } {}
              Fl_Button rename_project {
                label {Rename...}
                callback {if (currproj==NULL) return;
dialog_rename* ui_rename;
ui_rename=new dialog_rename();

string* currname=currproj->projectname();
string* strproject=new string("Rename project");
Fl_Window* win=ui_rename->make_window(currname,strproject);
if (strproject!=NULL) 
{ 
 	delete strproject;
}
win->end();
win->show();

while (win->visible()) { Fl::wait(); }
if (ui_rename->buttonclicked==1) 
{
  // OK clicked
  if (confirm("Do you wish to write the changes to disk?")) {
	currproj->projectname(*(ui_rename->itemname));
  	currproj->save();
	populate_projectlist(1+projectname->value());
  }  
  

  
  
}
delete ui_rename;
ui_refresh("ren proj 2");}
                xywh {510 105 85 20} labelsize 12 align 16
              }
              Fl_Box {} {
                label {Project information}
                xywh {0 58 5 17} labelfont 1 labelsize 12 align 8
              }
              Fl_Box {} {
                label {Song information}
                xywh {0 138 5 17} labelfont 1 labelsize 12 align 8
              }
              Fl_Output song_messages_label {
                label {Recovery messages:}
                xywh {155 325 10 20} type Multiline labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Output song_messages {
                xywh {155 325 440 40} type Multiline labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Button delete_project {
                label Delete
                callback {bool wantdel=confirm("Are you sure you want to delete this project, all songs in it and their recorded audio?\\nThis operation cannot be undone!");
if (!wantdel) return;
__sint32 projtodel=currproj->projectid();
__uint32 result=currenthd24->deleteproject(projtodel);
result++; result--; // ignore for now
ui_refresh("del proj");}
                xywh {455 105 55 20} labelsize 12 align 16
              }
              Fl_Button delete_song {
                label Delete
                callback {if (currproj==NULL) return;
if (currsong==NULL) return;

bool wantdel=confirm("Are you sure you want to delete this song and its recorded audio?\\nThis operation cannot be undone!");
if (!wantdel) return;
__uint32 songtodel=currsong->songid();
__uint32 result=currproj->deletesong(songtodel);
result++; result--; //ignore for now
ui_refresh("del song");}
                xywh {455 180 55 20} labelsize 12 align 16
              }
              Fl_Button create_project {
                label {New Project...}
                callback {if (currenthd24==NULL) {
	fl_message("No drive is currently selected.");
	return;
}

if (currenthd24->projectcount() == currenthd24->maxprojects()) 
{
	fl_message("Cannot create project.\\nThe maximum number of projects is already in use!");
	return;
}
// - check if current project is NULL
// - check if there's song space left in it
dialog_newproject* ui_newproject;
ui_newproject=new dialog_newproject();
Fl_Window *win=ui_newproject->make_window();
win->end();
win->show();

while (win->visible()) { Fl::wait(); }

if (ui_newproject->buttonclicked!=1) 
{
	delete ui_newproject;
	return;
}
char projname[65];
for (int i=0;i<65;i++) {
	projname[i]=0;
}
hd24project* newproj=currenthd24->createproject(
(const char*)strncpy(projname,ui_newproject->projectname,64)
);
if (newproj==NULL) 
{
    fl_message("Could not create the project. Access denied?");
    delete ui_newproject;
    return;    
}

//if (ui_newsong->buttonclicked==1) {
//	lastsector=ui_filesize->lastsector;
//} 
ui_refresh("createproj");
delete ui_newproject;}
                xywh {360 105 95 20} labelsize 12 align 16
              }
              Fl_Button create_song {
                label {New Song...}
                callback {if (currenthd24==NULL) {
	fl_message("No drive is currently selected.");
	return;
}

if (currproj==NULL) {
	fl_message("No project is currently selected.");
	return;	
}

if (currproj->songcount() == currproj->maxsongs()) 
{
	fl_message("Cannot create song.\\nThe maximum number of songs is already in use!");
	return;	
}
savemessage[0]='\\0';
transfer_cancel=0;

this->mustdispsavemessage=true;
Fl::add_timeout(0,savemessage_callback,this);

dialog_newsong* ui_newsong;
ui_newsong=new dialog_newsong();
Fl_Window *win=ui_newsong->make_window();
win->end();
win->show();



while (win->visible()) { Fl::wait(); }



//__uint32 lastsector=0;

if (ui_newsong->buttonclicked!=1) 
{
	mustdispsavemessage=false;
	transfer_cancel=1;	
	delete ui_newsong;
	return;
}

char songname[65];
for (int i=0;i<65;i++) {
	songname[i]=0;
}
hd24song* newsong=currproj->createsong(
(const char*)strncpy(songname,ui_newsong->songname,64),ui_newsong->trackcount,ui_newsong->samplerate
);


if (newsong==NULL) 
{
    fl_message("Could not create the song. Access denied?");
	mustdispsavemessage=false;
	transfer_cancel=1;    
    delete ui_newsong;
    return;    
}
__uint32 samlen=ui_newsong->songlength_in_samples;
win->~Fl_Window();
delete ui_newsong;
// optionally, lengthen song to specified size.
if (samlen>0) {
	setstatus("Lengthening song... ");
	
		
\#if (HD24DEBUG==1) 
	cout << "about to start lengthening song to maxlen=" << samlen << endl;
\#endif
	bool clearnew=true; // clear lengthened part

	__uint32 translen=newsong->songlength_in_samples(samlen,clearnew,&this->savemessage[0],&this->transfer_cancel,Fl::check); 


\#if (HD24DEBUG==1) 
	cout << "verifying actual song length " << endl;
	cout << "new len=" << translen << endl;
\#endif
	if (translen!=samlen) 
	{
\#if (HD24DEBUG==1) 
		
		cout << "new len<> maxlen so not enough space." << endl;
\#endif
		if (transfer_cancel==0)
		{
			fl_message("Not enough space on HD24 drive.");
		} else
		{
			fl_message("Song lengthening cancelled by user.");
		}
		return;
	}
	newsong->save(); 

\#if (HD24DEBUG==1) 
cout << "translen is now " << translen << endl;
\#endif
}
stop_transfer->hide();	
this->mustdispsavemessage=false;	
delete newsong; // ui refresh will pick it up as currsong.
ui_refresh("newsong");
setstatus("Ready.");
return;}
                xywh {360 180 95 20} labelsize 12 align 16
              }
              Fl_Box {} {
                label Hz
                xywh {245 230 19 20} labelsize 12 align 20
              }
              Fl_Box {} {
                label {hours:minutes:seconds.frames}
                xywh {245 205 195 20} labelsize 12 align 20
              }
            }
            Fl_Group tabRecorder {
              label Recorder open
              xywh {-5 46 620 464} color 52 labelfont 1 labelsize 12 hide
            } {
              Fl_Group recorder {open
                xywh {-5 49 610 457} color 53 selection_color 53 align 0
                code0 {o->set_ui(this);}
                code1 {o->control->audiolib(AUDIOLIB_PORTAUDIO,(void*)(this->portaudio));}
                code2 {o->control->audiolib(AUDIOLIB_JACK,(void*)(this->libjack));}
                code3 {o->control->audiolib(AUDIOLIB_SNDFILE,(void*)(this->soundfile));}
                class RecorderUI
              } {}
            }
            Fl_Group tabMixer {
              label Mixer open
              xywh {0 45 605 463} color 52 labelfont 1 labelsize 12 hide
            } {
              Fl_Group mixer {open
                xywh {0 49 605 456} color 53 selection_color 53 align 0
                code0 {o->set_ui(this);}
                class MixerUI
              } {}
            }
            Fl_Group tabCopyToPC {
              label {Copy to PC} open
              xywh {5 50 600 455} color 52 labelfont 1 labelsize 12 hide
            } {
              Fl_Check_Button {} {
                xywh {85 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[0]=o;}
              }
              Fl_Check_Button {} {
                xywh {105 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[1]=o;}
              }
              Fl_Check_Button {} {
                xywh {125 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[2]=o;}
              }
              Fl_Check_Button {} {
                xywh {145 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[3]=o;}
              }
              Fl_Check_Button {} {
                xywh {165 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[4]=o;}
              }
              Fl_Check_Button {} {
                xywh {185 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[5]=o;}
              }
              Fl_Check_Button {} {
                xywh {205 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[6]=o;}
              }
              Fl_Check_Button {} {
                xywh {225 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[7]=o;}
              }
              Fl_Check_Button {} {
                xywh {255 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[8]=o;}
              }
              Fl_Check_Button {} {
                xywh {275 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[9]=o;}
              }
              Fl_Check_Button {} {
                xywh {295 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[10]=o;}
              }
              Fl_Check_Button {} {
                xywh {315 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[11]=o;}
              }
              Fl_Check_Button {} {
                xywh {335 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[12]=o;}
              }
              Fl_Check_Button {} {
                xywh {355 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[13]=o;}
              }
              Fl_Check_Button {} {
                xywh {375 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[14]=o;}
              }
              Fl_Check_Button {} {
                xywh {395 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[15]=o;}
              }
              Fl_Check_Button {} {
                xywh {425 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[16]=o;}
              }
              Fl_Check_Button {} {
                xywh {445 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[17]=o;}
              }
              Fl_Check_Button {} {
                xywh {465 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[18]=o;}
              }
              Fl_Check_Button {} {
                xywh {485 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[19]=o;}
              }
              Fl_Check_Button {} {
                xywh {505 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[20]=o;}
              }
              Fl_Check_Button {} {
                xywh {525 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[21]=o;}
              }
              Fl_Check_Button {} {
                xywh {545 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[22]=o;}
              }
              Fl_Check_Button {} {
                xywh {565 92 20 20} down_box DOWN_BOX value 1 labelsize 12 align 1
                code0 {track[23]=o;}
              }
              Fl_Box {} {
                label {Tracks:}
                xywh {15 79 70 16} box FLAT_BOX color 52 labelsize 12 align 20
              }
              Fl_Button button_invert_tracks {
                label Invert
                callback {int i;
for (i=0; i<MAXCHANNELS; i++) {
   track[i]->value(1-track[i]->value());
}}
                xywh {15 92 65 20} labelsize 12 align 16
              }
              Fl_Box led1 {
                label 01
                xywh {85 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[0]=o;}
              }
              Fl_Box led2 {
                label 02
                xywh {105 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[1]=o;}
              }
              Fl_Box led3 {
                label 03
                xywh {125 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[2]=o;}
              }
              Fl_Box led4 {
                label 04
                xywh {145 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[3]=o;}
              }
              Fl_Box led5 {
                label 05
                xywh {165 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[4]=o;}
              }
              Fl_Box led6 {
                label 06
                xywh {185 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[5]=o;}
              }
              Fl_Box led7 {
                label 07
                xywh {205 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[6]=o;}
              }
              Fl_Box led8 {
                label 08
                xywh {225 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[7]=o;}
              }
              Fl_Box led9 {
                label 09
                xywh {255 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[8]=o;}
              }
              Fl_Box led10 {
                label 10
                xywh {275 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[9]=o;}
              }
              Fl_Box led11 {
                label 11
                xywh {295 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[10]=o;}
              }
              Fl_Box led12 {
                label 12
                xywh {315 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[11]=o;}
              }
              Fl_Box led13 {
                label 13
                xywh {335 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[12]=o;}
              }
              Fl_Box led14 {
                label 14
                xywh {355 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[13]=o;}
              }
              Fl_Box led15 {
                label 15
                xywh {375 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[14]=o;}
              }
              Fl_Box led16 {
                label 16
                xywh {395 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[15]=o;}
              }
              Fl_Box led17 {
                label 17
                xywh {424 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[16]=o;}
              }
              Fl_Box led18 {
                label 18
                xywh {444 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[17]=o;}
              }
              Fl_Box led19 {
                label 19
                xywh {464 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[18]=o;}
              }
              Fl_Box led20 {
                label 20
                xywh {484 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[19]=o;}
              }
              Fl_Box led21 {
                label 21
                xywh {504 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[20]=o;}
              }
              Fl_Box led22 {
                label 22
                xywh {524 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[21]=o;}
              }
              Fl_Box led23 {
                label 23
                xywh {544 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[22]=o;}
              }
              Fl_Box led24 {
                label 24
                xywh {564 80 20 14} box FLAT_BOX color 52 selection_color 0 labelsize 12
                code0 {this->trackled[23]=o;}
              }
              Fl_Button button_transfertopc {
                label Transfer
                callback {recorder->control->button_stop_call();
mustdisplaytimer=false;
__sint64 bytestransferred=0;
transeng->sizelimit(strtoll(sizelimit->value(),0,10));

int bytespersam;
int wantsplit=0;
__uint32 numsongs=1;
double dif;
__sint64 totbytestotransfer=0; 

bool needoverwrite=false;
bool isproblem=false;	
__uint32 channelstotransfer=0;

__uint32 i=0;

transfer_cancel=0;

if (currproj==NULL) 
{
\#if (HD24DEBUG==1) 
	cout << "No current project." << endl;
\#endif			
	return;	
}

/* TODO: DISABLE/ENABLE JACK BEFORE/AFTER TRANSFER */
//jack_client_t* saveclient=jackclient;
//jackclient=NULL;
/* TODO: DISABLE/ENABLE JACK BEFORE/AFTER TRANSFER */

if (!(hd24utils::dirExists(projectdir->value()))) 
{
	fl_message("Project directory no longer exists.\\nPlease select another directory and try again.");
	//jackclient=saveclient;
\#if (HD24DEBUG==1) 
	cout << "project dir no longer exists, transfer cancelled." << endl;
\#endif			
	
	return;
}
transeng->setstatusfunction=HD24UserInterface::transferstatus;
transeng->projectdir(projectdir->value());
transeng->set_ui((void*)this);
transeng->mixer(this->mixer->control);
transeng->soundfile=soundfile;
bool channelwarning=false;
int currfileformat=0;
bool multisong=false;
if (currsong==NULL) 
{
	multisong=true;
}  
else 
{
	// count channels to transfer
	__uint32 channels=currsong->logical_channels();
	for (unsigned int handle=0;handle<channels;handle++) 
	{
		if (track[handle]->value()!=0) 
		{
			channelstotransfer++;
			transeng->trackselected(handle,true);
		} 
		else 
		{
			transeng->trackselected(handle,false);
		}
	}
	
	transeng->mixleft( (transfersource_mixleft->value())==1);
	transeng->mixright( (transfersource_mixright->value()) ==1);

	currfileformat=fileformat->value();
	
	transeng->selectedformat(currfileformat);
	
	if (transeng->format_outputchannels(currfileformat)>1) 
	{
		if ((channelstotransfer%(transeng->format_outputchannels(currfileformat)))!=0) 
		{
			channelwarning=true;
		}
	}
	
} 
	
if (multisong) 
{
	numsongs=currproj->songcount();
}
if (channelwarning) 
{
	string multiple="Number of channels to export must be a multiple of ";
	string* mynum=Convert::int2str(transeng->format_outputchannels(currfileformat));
	multiple+=*mynum;
	if (transeng->format_outputchannels(currfileformat)==2) 
	{
		multiple+="\\nto export to stereo pairs.";
	} else {
		multiple+="\\nfor export to groups of ";
		multiple+=*mynum;
		multiple+=" channels.";
	}
	fl_message("%s",multiple.c_str());
	delete mynum;
/* TODO: DISABLE/ENABLE JACK BEFORE/AFTER TRANSFER */	
//	jackclient=saveclient;


	return;
	
}
if (numsongs==0) 
{
\#if (HD24DEBUG==1) 
	cout << "multisong transfer: no songs in current project." << endl;
\#endif			
	fl_message("Nothing to do!");
/* TODO: DISABLE/ENABLE JACK BEFORE/AFTER TRANSFER */	
//	jackclient=saveclient;

	return;
}
int havedoublesongname=0;
if (multisong && (numsongs>1)) 
{
	// check if any song names are duplicated
	hd24song* s1=NULL;
	hd24song* s2=NULL;
	for (unsigned i=1; i<numsongs; i++) 
	{
		if (s1!=NULL) {
                        delete s1;
                        s1=NULL;
		}
		s1=currproj->getsong(i);
		string* songname1=s1->songname();
		for (unsigned int j=i+1; j<=numsongs; j++) {
			if (s2!=NULL) {
                                delete s2;
                                s2=NULL;
			}
			s2=currproj->getsong(j);
			string* songname2=s2->songname();
			if (*songname1==*songname2) {
				havedoublesongname=1;
			}
			delete songname2;
			if (havedoublesongname==1) break;
		}
		delete songname1;
		if (havedoublesongname==1) break;
	}
	if (s1!=NULL) {
                delete s1;
                s1=NULL;
	}
	if (s2!=NULL) {
                delete s2;
                s2=NULL;
	}
}	
if (havedoublesongname==1) 
{
 if (!confirm(
		"Duplicate song names were detected. If you continue, \\n"
		"exported songs will be prefixed with the song number. \\n\\n"
		"If you prefer to name the songs before export, you will\\n"
		"want to stop now.\\n\\n"
		"Do you wish to continue?"
	)
  ) {
/* TODO: DISABLE/ENABLE JACK BEFORE/AFTER TRANSFER */  
//  	jackclient=saveclient;
	return;	
  };
}
// preparation for the transfers
for (i=1; i<=numsongs; i++) 
{
	if (multisong) 
	{
		if (currsong!=NULL) {
                        delete currsong;
			currsong=NULL;
		}
		currsong=currproj->getsong(i);
		if (currsong!=NULL) 
		{
			channelstotransfer=currsong->logical_channels();
			choice_startloc=0;
			choice_endloc=currsong->locatepointcount();
		}
	}
\#if (HD24DEBUG==1) 
	cout << "channels to transfer=" << channelstotransfer << endl;	
\#endif			
	__uint64 bytestotransfer_perchannel=0;
	__uint64 bytestotransfer_thissong=0;
	transeng->sourcesong(currsong);	
	if (currsong!=NULL)
	{
		bytespersam=(currsong->bitdepth())/8;
		// for kb/sec calculation
		// because of this, double at higher sample rates

		__uint32 samstotrans_thissong;
		if (multisong) 
		{
			samstotrans_thissong=currsong->songlength_in_samples();
			transeng->startoffset(0);
			transeng->endoffset(currsong->songlength_in_samples());
		}
		else
		{
			__uint32 startoffset=0;
			__uint32 endoffset=0;	

			if (choice_startloc!=0) {
				startoffset=currsong->getlocatepos(choice_startloc);
			}
			if (choice_endloc!=0)
			{
				endoffset=currsong->getlocatepos(choice_endloc);
			}
			transeng->startoffset(startoffset);
			transeng->endoffset(endoffset);
			if (endoffset>startoffset) 
			{		
				samstotrans_thissong=endoffset-startoffset;
			} 
			else 
			{
				samstotrans_thissong=startoffset-endoffset;
			}
		}
\#if (HD24DEBUG==1) 	
	cout << "sams to transfer for this song=" << samstotrans_thissong << endl ;
\#endif		
		if (samstotrans_thissong==0xFFFFFFFF)
		{
			bool wanttransfer=confirm(
			"You are trying to transfer the maximum song size possible\\n"
			"(more than twenty hours or 300 Gigabytes of audio). \\n\\n"
			"HD24tools will gladly try to perform this transfer for you,\\n"
			"but it will take VERY LONG, and is probably not very helpful\\n"
			"to you.\\n\\n"
			"If you are currently trying to recover audio, you probably\\n"
			"forgot to set the export range (with the 'Range...' button\\n"
			"above). It is highly recommended to listen to your audio\\n"
			"and set two locate points before setting the export range.\\n\\n"
			"Do you want to perform this long and possibly useless\\n"
			"transfer anyway?");
			if (!(wanttransfer)) return;
		}
		
		bytestotransfer_perchannel=(__sint64)((__sint64)samstotrans_thissong*(__sint64)bytespersam);
		
		// hi-samplerate correction:
		bytestotransfer_perchannel*=(currsong->physical_channels()/currsong->logical_channels());	
		bytestotransfer_thissong=(channelstotransfer*bytestotransfer_perchannel);
		
		totbytestotransfer+=bytestotransfer_thissong;
		
		if (!(needoverwrite)) 
		{
			needoverwrite=anyfilesexist(currsong);
		}			
	}	
		
		
	/* The above number equals 2 giga/4, to bypass format limitations. 
	   For 24-bit samples 2 giga/3 would suffice but some space could 
	   be needed by headers etc. */
	__uint64 MAXBYTES=transeng->sizelimit();
	// max number of samples per giga is half for high samplerate files
	if (multisong)
	{
                delete currsong;
		currsong=NULL;
	}
\#if (HD24DEBUG==1) 	
	cout << "Maxbytes per channel=" << MAXBYTES ;
	cout << "bytes per channel=" << bytestotransfer_perchannel << endl;
\#endif	
	if (bytestotransfer_perchannel>MAXBYTES) 
	{
	        if (wantsplit!=1)
	        {
/*	        
			int choice=fl_choice(
				"Exported audio files may be too large to play or edit. \\nDo you want to export the file as multiple smaller chunks?",
				"Yes","No","Cancel"
				);
			if (choice==2) 
			{
\#if (HD24DEBUG==1) 
				cout << "user cancelled too large file transfer" << endl;
\#endif			
				//jackclient=saveclient;
				return; // cancelled
			}
			if (choice==0) 
			{
				wantsplit=1;
			}
*/
			if (autosplit->value()==1) {
				wantsplit=1;
			}			
		}		
	}
}
if (multisong)
{
	if (currsong!=NULL) {
                delete currsong;
		currsong=NULL;
	}
}

// do we need to overwrite any files? Are we allowed to?
if (needoverwrite) 
{
	isproblem=(!(confirm("One or more output files already exist. Do you want to overwrite them?")));
}

if (isproblem) 
{
\#if (HD24DEBUG==1) 
	cout << "user does not wish to perform needed overwrite." << endl;
\#endif
/* TODO: DISABLE/ENABLE JACK BEFORE/AFTER TRANSFER */
//	jackclient=saveclient;
	return;	
}

// needed to check for dir to make sure about existence of output files
// but the previous question may have given the user the time to mess up.
// check the dir again :)

if (!(hd24utils::dirExists(projectdir->value()))) 
{
	fl_message("Project directory no longer exists.\\nPlease select another directory and try again.");
/* TODO: DISABLE/ENABLE JACK BEFORE/AFTER TRANSFER */	
//	jackclient=saveclient;
\#if (HD24DEBUG==1) 
	cout << "project directory deleted" << endl;
\#endif	
	return;
}	
\#if (HD24DEBUG==1) 
	cout << "by calc, tot bytes to transfer=" << totbytestotransfer << endl;	
\#endif			

deactivate_ui();	
setstatus("Transferring audio to PC... 0%");	
time (&starttime);		
int somethingwrong=0;
for (i=1; i<=numsongs; i++) 
{
\#if (HD24DEBUG==1) 
	cout << "set song" << endl;
\#endif
	if (transfer_cancel!=0) 
	{ 
\#if (HD24DEBUG==1) 
		cout << "transfer cancelled by user." << endl;
\#endif	
		break;
	}

	if (multisong) 
	{
		if (currsong!=NULL) {
                        delete currsong;
			currsong=NULL;
		}
		currsong=currproj->getsong(i);
	}
	transeng->sourcesong(currsong);
	if (currsong==NULL) 
  	{	
\#if (HD24DEBUG==1) 
		cout << "currsong=null, nothing to transfer" << endl;
\#endif
  		continue;
   	}
\#if (HD24DEBUG==1) 
	cout << "calling ftransfer with ";
	cout << "sonnum=" << i;
	cout << ", numsongs=" << numsongs;
	cout << ", totlen(bytes)=" << totbytestotransfer;
	cout << ", bytestransferred=" << bytestransferred;
	cout << ", wantsplit=" << wantsplit << endl;
\#endif

	transeng->prepare_transfer_to_pc(i,numsongs,totbytestotransfer,bytestransferred,wantsplit,(havedoublesongname==1)?(i):(0));
	__sint64 currtransferred=transeng->transfer_to_pc();
	if (currtransferred==0) 
	{
		somethingwrong=1;
		break;
	}
	bytestransferred+=currtransferred;
			
	if (multisong)
	{
                delete currsong;
		currsong=NULL;
	}
	
} 


if (multisong)
{
	if (currsong!=NULL)
	{
                delete currsong;
		currsong=NULL;
	}				
}	

/* TODO: DISABLE/ENABLE JACK BEFORE/AFTER TRANSFER */
//jackclient=saveclient;
if (somethingwrong==1) 
{
	activate_ui();
	if (transeng->lasterror()!=NULL)
	{
		
		setstatus(transeng->lasterror()->c_str());
	}
	else
	{
		setstatus((const char*)&"Unexpected error transferring files.");
	}
	stop_transfer->hide();
	return;		
}

time (&endtime);
dif=difftime(endtime,starttime);
//__uint32 subsecs=(__uint32)(100*(dif-floor(dif)));
dif=floor(dif);
__uint32 minutes=((__uint32)dif-((__uint32)dif%60))/60;
__uint32 seconds=((__uint32)dif%60);

string minsec="Ready. Transfer time: ";
if (transfer_cancel==1) 
{
	minsec="Transfer cancelled. Elapsed transfer time: ";
}
transfer_cancel=0;
string* strmins=Convert::int2str(minutes,2,"0");
minsec+=*strmins;
delete (strmins);
minsec+=":";
string* strsecs=Convert::int2str(seconds,2,"0");
minsec+=*strsecs;
delete(strsecs);

if (dif>=1) 
{
	__uint32 kbps=(__uint32)(((bytestransferred)/1024)/dif);

	minsec+=" (";
	string* strkbps=Convert::int2str(kbps);
	minsec+=*strkbps;
	minsec+=" kB/sec)";
	delete(strkbps);
}
activate_ui();
setstatus(minsec.c_str());
stop_transfer->hide();}
                xywh {530 480 70 20} labelsize 12 align 16
                code0 {o->label("Transfer");}
              }
              Fl_Button {} {
                label {Browse...}
                callback {Fl_Native_File_Chooser chooser;
chooser.title("Select project directory");
chooser.type(Fl_Native_File_Chooser::BROWSE_DIRECTORY);
chooser.options(Fl_Native_File_Chooser::NEW_FOLDER);
chooser.filter("");

string currdir="";
currdir+=projectdir->value();

chooser.directory(currdir.c_str());
switch (chooser.show()) {
	case -1: break; //error
	case 1: break; //cancel
	default:
		if (chooser.filename()) {
			projectdir->value(chooser.filename());
			hd24utils::setlastdir("projdir",chooser.filename());
		}

		break;
}}
                xywh {505 175 85 20} labelsize 12 align 16
              }
              Fl_Input projectdir {
                label {Project dir:}
                callback {/* callback when release: add a 
   (back)slash to the end of the
   pathname if one is not present. */

\#ifdef WINDOWS
\#define MYSLASH '\\\\'
\#else
\#define MYSLASH '/'
\#endif
char* x=(char*)projectdir->value();
if (strlen(x)==0) {
   x[0]=MYSLASH;
   x[1]=0;
} else {
  int q=strlen(x);
  if (x[q-1]!=MYSLASH) {
     x[q]=MYSLASH;
     x[q+1]=0;
  }
}
projectdir->value(x);
hd24utils::setlastdir("projdir",projectdir->value());}
                xywh {85 175 415 20} labelsize 12 textsize 12
                code0 {getlastprojdir(o);}
                code1 {/*o->clear_visible_focus();*/}
              }
              Fl_Output fromtime {
                label {From:}
                xywh {265 115 105 20} labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Output totime {
                label {To:}
                xywh {395 115 105 20} labelsize 12 textsize 12
                code0 {o->clear_visible_focus();}
              }
              Fl_Button fromto {
                label {Range...}
                callback {if (currsong==NULL) return;
dialog_fromto* ui_fromto;
ui_fromto=new dialog_fromto;

Fl_Window *win=ui_fromto->make_window(currsong);
populate_locatepoints(currsong,ui_fromto->fromloc);
populate_locatepoints(currsong,ui_fromto->toloc);
ui_fromto->fromloc->value(choice_startloc);
ui_fromto->toloc->value(choice_endloc);
win->end();
win->show();

while (win->visible()) { Fl::wait(); }

/* Dialog has closed, read the results */
//if (ui_fromto->buttonclicked==0) 
//{ fl_message("No OK nor Cancel clicked"); }
if (ui_fromto->buttonclicked==1) 
{
	// OK clicked
	choice_startloc=ui_fromto->choice_startloc;
	choice_endloc=ui_fromto->choice_endloc;
	update_fromto();
}
//if (ui_fromto->buttonclicked==2) 
//{ fl_message("Cancel clicked"); }
delete ui_fromto;}
                xywh {505 115 85 20} labelsize 12 align 16
              }
              Fl_Choice fileformat {
                label {File format:} open
                xywh {85 200 160 20} down_box BORDER_BOX labelsize 12 textsize 12
              } {}
              Fl_Check_Button autosplit {
                label {Automatically limit size of exported files}
                callback {if (autosplit->value()==1) {
	sizelimitdropdown->activate();

	if (sizelimitdropdown->value()==6) {
		sizelimit->activate();
	} else {
		sizelimit->deactivate();
	}
} else {
	sizelimitdropdown->deactivate();
	sizelimit->deactivate();
}}
                xywh {10 265 20 20} box FLAT_BOX down_box DOWN_BOX value 1 color 52 labelsize 12 align 8
              }
              Fl_Input sizelimit {
                label bytes
                xywh {425 290 120 20} labelsize 12 align 8 textsize 12
                code0 {long long x=1073741824LL; string* sval=Convert::int64tostr(x); o->value(sval->c_str()); delete sval; o->deactivate();}
                code1 {o->maximum_size(17);}
              }
              Fl_Box {} {
                label {Transfer target:}
                xywh {10 153 305 17} box FLAT_BOX color 52 labelfont 1 labelsize 12 align 20
              }
              Fl_Box {} {
                label {Transfer options:}
                xywh {10 243 305 17} box FLAT_BOX color 52 labelfont 1 labelsize 12 align 20
              }
              Fl_Box {} {
                label {Note: The actual file size will be a rough approximation of the requested split size.}
                xywh {30 318 550 17} box FLAT_BOX color 52 labelfont 2 labelsize 12 align 20
              }
              Fl_Check_Button customrate {
                label {Stamp files with a custom sample rate}
                callback {if (customrate->value()==1) {
	ratechoice->activate();
	if (ratechoice->value()==4) {
		stamprate->activate();	
	} else {
		stamprate->deactivate();	
	}
} else {
	ratechoice->deactivate();
	stamprate->deactivate();	
}}
                xywh {10 345 20 20} box FLAT_BOX down_box DOWN_BOX color 52 labelsize 12 align 8
              }
              Fl_Choice ratechoice {
                label {Sample rate:} open
                xywh {105 370 295 20} down_box BORDER_BOX labelsize 12 textsize 12 deactivate
                code0 {o->value(1);}
              } {
                MenuItem {} {
                  label {44100 Hz}
                  callback {long long x=44100LL;
string* sval=Convert::int64tostr(x);
stamprate->value(sval->c_str());
delete sval;
stamprate->deactivate();}
                  xywh {25 25 36 21} labelsize 12
                }
                MenuItem {} {
                  label {48000 Hz}
                  callback {long long x=48000LL;
string* sval=Convert::int64tostr(x);
stamprate->value(sval->c_str());
delete sval;
stamprate->deactivate();}
                  xywh {35 35 36 21} labelsize 12
                }
                MenuItem {} {
                  label {88200 Hz}
                  callback {long long x=88200LL;
string* sval=Convert::int64tostr(x);
stamprate->value(sval->c_str());
delete sval;
stamprate->deactivate();}
                  xywh {45 45 36 21} labelsize 12
                }
                MenuItem {} {
                  label {96000 Hz}
                  callback {long long x=96000LL;
string* sval=Convert::int64tostr(x);
stamprate->value(sval->c_str());
delete sval;
stamprate->deactivate();}
                  xywh {55 55 36 21} labelsize 12
                }
                MenuItem {} {
                  label {User defined, specify -->}
                  callback {stamprate->activate();}
                  xywh {85 85 36 21} labelsize 12
                }
              }
              Fl_Input stamprate {
                label Hz
                xywh {425 370 120 20} labelsize 12 align 8 textsize 12 deactivate
                code0 {long long x=48000; string* sval=Convert::int64tostr(x); o->value(sval->c_str()); delete sval; o->deactivate();}
                code1 {o->maximum_size(5);}
              }
              Fl_Choice sizelimitdropdown {
                label {Split every:} open
                tooltip 1 xywh {105 290 295 20} down_box BORDER_BOX labelsize 12 textsize 12
                code0 {o->value(2);}
              } {
                MenuItem {} {
                  label {650 MB (74 minute CD)}
                  callback {long long x=650000000LL;
string* sval=Convert::int64tostr(x);
sizelimit->value(sval->c_str());
delete sval;
sizelimit->deactivate();}
                  xywh {20 20 36 21} labelsize 12
                }
                MenuItem {} {
                  label {700 MB (80 minute CD)}
                  callback {long long x=700000000LL;
string* sval=Convert::int64tostr(x);
sizelimit->value(sval->c_str());
delete sval;
sizelimit->deactivate();}
                  xywh {30 30 36 21} labelsize 12
                }
                MenuItem {} {
                  label {1 GiB (Recommended for wave editors)}
                  callback {long long x=1073741824LL;
string* sval=Convert::int64tostr(x);
sizelimit->value(sval->c_str());
delete sval;
sizelimit->deactivate();}
                  xywh {40 40 36 21} labelsize 12
                }
                MenuItem {} {
                  label {2 GiB (Max. legal WAV size)}
                  callback {long long x=2147483648LL;
string* sval=Convert::int64tostr(x);
sizelimit->value(sval->c_str());
delete sval;
sizelimit->deactivate();}
                  xywh {50 50 36 21} labelsize 12
                }
                MenuItem {} {
                  label {4 GiB (Max. 32-bit limit)}
                  callback {long long x=4294967296LL;
string* sval=Convert::int64tostr(x);
sizelimit->value(sval->c_str());
delete sval;
sizelimit->deactivate();}
                  xywh {60 60 36 21} labelsize 12
                }
                MenuItem {} {
                  label {4.7 GB (DVD size)}
                  callback {long long x=4700000000LL;
string* sval=Convert::int64tostr(x);
sizelimit->value(sval->c_str());
delete sval;
sizelimit->deactivate();}
                  xywh {70 70 36 21} labelsize 12
                }
                MenuItem {} {
                  label {User defined, specify -->}
                  callback {sizelimit->activate();}
                  xywh {80 80 36 21} labelsize 12
                }
              }
              Fl_Check_Button transfersource_mixleft {
                label {Mixer Left}
                callback {saverestoretrackselection(o);}
                xywh {85 115 20 20} down_box DOWN_BOX labelsize 12 align 4
              }
              Fl_Check_Button transfersource_mixright {
                label Right
                callback {saverestoretrackselection(o);}
                xywh {105 115 20 20} down_box DOWN_BOX labelsize 12 align 8
              }
              Fl_Group batch_stuff {
                label {batch stuff } open
                xywh {5 390 600 115} align 16 hide deactivate
              } {
                Fl_Box {} {
                  label {Batch transfer list:}
                  xywh {10 393 305 17} box FLAT_BOX color 52 labelfont 1 labelsize 12 align 20 deactivate
                }
                Fl_Output transfer_list {
                  xywh {10 410 515 90} type Multiline labelsize 12 textsize 12 deactivate
                  code0 {o->clear_visible_focus();}
                }
                Fl_Button button_addtobatch {
                  label {To Batch}
                  xywh {530 410 70 20} labelsize 12 align 16 deactivate
                }
                Fl_Button button_removefrombatch {
                  label Remove
                  xywh {530 430 70 20} labelsize 12 align 16 deactivate
                }
              }
              Fl_Output transfersource {
                label {Transfer source:}
                xywh {127 57 458 20} box NO_BOX labelfont 1 labelsize 12 textsize 12
              }
              Fl_Button {} {
                label {?}
                callback {fl_message("This option allows you to limit the size of exported files. \\n"
"In the dropdown box, the following units are used:\\n\\n"
"MB - Megabyte, 1000x1000 bytes\\n"
"GB - Gigabyte, 1000x1000x1000 bytes\\n"
"GiB - Binary Gigabyte or Gibibyte, 1024x1024x1024 bytes\\n\\n"
"In any situation, the actual byte count is displayed on the right.");}
                tooltip {Click here for an explanation about file splitting.} xywh {400 290 20 20} box FLAT_BOX down_box FLAT_BOX color 15 selection_color 15 labelfont 1 labelsize 11 labelcolor 7
              }
              Fl_Button {} {
                label {?}
                callback {fl_message("Stamping files with another sample rates allows you \\n"
"to export files with a sample rate that differs from the sample \\n"
"rate at which the song was recorded. When using this option, \\n"
"note that no resampling takes place; both the pitch and playback \\n"
"speed will change compared to the original sample rate. ");}
                tooltip {Click here for an explanation about sample rate stamping} xywh {400 370 20 20} box FLAT_BOX down_box FLAT_BOX color 15 selection_color 15 labelfont 1 labelsize 11 labelcolor 7
              }
            }
            Fl_Group tab_tohd24 {
              label {Copy to HD24} open
              xywh {0 45 605 461} color 52 labelfont 1 labelsize 12
            } {
              Fl_Button button_transfertohd24 {
                label Transfer
                callback {recorder->control->button_stop_call(); //stop transport
bool have_smpte=false;
if (currproj==NULL) 
{
	fl_message("No project selected, nothing to do!\\nSelect a project on the Project/Song tab and try again.");
	return;	
}
if (currsong==NULL) 
{
	fl_message("No song selected, nothing to do!\\nSelect a song on the Project/Song tab and try again.");
	return;
}

int havefiles=0;
for (unsigned int ch=1;ch<=currsong->logical_channels();ch++) {

	if (strlen(filename[ch-1]->value())>0) {
		// track has a file selected
		havefiles=1;
		currsong->trackarmed(ch,true);
		continue;
	}
	int action=((Fl_Choice*)(trackaction[ch-1]))->value();
	if (action==0) { /* 0=ERASE */
		// track action says 'erase'
		havefiles=1;
		currsong->trackarmed(ch,true);	
		continue;
	} 
	if (action==1) { /* 1=SMPTE */
		// track action says 'stripe with SMPTE/LTC'
		havefiles=1;
		have_smpte=true;
		currsong->trackarmed(ch,true);	
		continue;
	} 
	// no file, no timecode stripe and no erase, keep track.
	currsong->trackarmed(ch,false);	
	
}
if (havefiles==0) {
	fl_message(
		"To transfer files to the HD24, load one or more files.\\n"
		"Each file will be assigned to an empty track slot.\\n\\n"
		"Before transferring, you will be able to rearrange the\\n"
		"order of the tracks by clicking on one or more tracks\\n"
		"and clicking the up or down arrow buttons.\\n\\n"
		"When a track slot is empty, the existing track will be\\n"
		"preserved, unless 'Erase' or 'SMPTE' is selected on \\n"
		"the right of the track.\\n\\n"
		"When a file to transfer contains multiple tracks, you\\n"
                "can choose to mixdown the file to mono (the default), \\n"
                "or you can select the track that you want to transfer \\n"
                "to the HD24 drive." 
	);
	for (unsigned int ch=1;ch<=currsong->logical_channels();ch++) {
		currsong->trackarmed(ch,false);	
	}
	return;
}
if (currsong->iswriteprotected())
{
	fl_message("The song is write protected.");
	for (unsigned int ch=1;ch<=currsong->logical_channels();ch++) {
		currsong->trackarmed(ch,false);
	}
	return;
}
// ask ARE YOU SURE????
bool sure=confirm("Are you sure you want to overwrite the existing audio?");
if (!sure) return;

// check if all files still exist

int filemissing=0;
for (unsigned int misscheck=1;misscheck<=currsong->logical_channels();misscheck++) {
	if (strlen(filename[misscheck-1]->value())==0) continue;	
	if (!(hd24utils::fileExists(filename[misscheck-1]->value()))) 
	{
		filemissing=1;
		break;
	}	
}

if (filemissing==1) {
	fl_message("One or more files no longer exist. \\nPlease clear and reload the files, then try again.");
	return;
}
// end of checking if all files still exist
transeng->targetsong(currsong);
transeng->soundfile=soundfile;
for (unsigned int filenum=1;filenum<=currsong->logical_channels();filenum++) 
{
    transeng->sourcefilename(filenum,filename[filenum-1]->value());
    transeng->trackaction(filenum,((Fl_Choice*)(trackaction[filenum-1]))->value());
}
transeng->transfer_to_hd24();
stop_transfer->hide();
if (transeng->lasterror()!=NULL)
{
    if (transeng->lasterror()->c_str()!=NULL)
    {
	    setstatus(transeng->lasterror()->c_str());
    }
    else 
    {
        setstatus("Done. No error messages.");
    }	 
} else {
    setstatus("Done.");
}
ui_refresh("tohd24_done");
activate_ui();	
fl_check();} selected
                xywh {530 480 70 20} labelsize 12
              }
              Fl_Output filename1 {
                label {01  }
                callback {selectfilename(1);}
                xywh {40 50 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[0]=o;}
              }
              Fl_Output filename2 {
                label {02  }
                callback {selectfilename(2);}
                xywh {40 69 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[1]=o;}
              }
              Fl_Output filename3 {
                label {03  }
                callback {selectfilename(3);}
                xywh {40 88 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[2]=o;}
              }
              Fl_Output filename4 {
                label {04  }
                callback {selectfilename(4);}
                xywh {40 107 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[3]=o;}
              }
              Fl_Output filename5 {
                label {05  }
                callback {selectfilename(5);}
                xywh {40 126 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[4]=o;}
              }
              Fl_Output filename6 {
                label {06  }
                callback {selectfilename(6);}
                xywh {40 145 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[5]=o;}
              }
              Fl_Output filename7 {
                label {07  }
                callback {selectfilename(7);}
                xywh {40 164 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[6]=o;}
              }
              Fl_Output filename8 {
                label {08  }
                callback {selectfilename(8);}
                xywh {40 183 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[7]=o;}
              }
              Fl_Output filename9 {
                label {09  }
                callback {selectfilename(9);}
                xywh {40 202 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[8]=o;}
              }
              Fl_Output filename10 {
                label {10  }
                callback {selectfilename(10);}
                xywh {40 221 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[9]=o;}
              }
              Fl_Output filename11 {
                label {11  }
                callback {selectfilename(11);}
                xywh {40 240 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[10]=o;}
              }
              Fl_Output filename12 {
                label {12  }
                callback {selectfilename(12);}
                xywh {40 259 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[11]=o;}
              }
              Fl_Output filename13 {
                label {13  }
                callback {selectfilename(13);}
                xywh {40 278 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[12]=o;}
              }
              Fl_Output filename14 {
                label {14  }
                callback {selectfilename(14);}
                xywh {40 297 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[13]=o;}
              }
              Fl_Output filename15 {
                label {15  }
                callback {selectfilename(15);}
                xywh {40 316 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[14]=o;}
              }
              Fl_Output filename16 {
                label {16  }
                callback {selectfilename(16);}
                xywh {40 335 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[15]=o;}
              }
              Fl_Output filename17 {
                label {17  }
                callback {selectfilename(17);}
                xywh {40 354 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[16]=o;}
              }
              Fl_Output filename18 {
                label {18  }
                callback {selectfilename(18);}
                xywh {40 373 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[17]=o;}
              }
              Fl_Output filename19 {
                label {19  }
                callback {selectfilename(19);}
                xywh {40 392 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[18]=o;}
              }
              Fl_Output filename20 {
                label {20  }
                callback {selectfilename(20);}
                xywh {40 411 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[19]=o;}
              }
              Fl_Output filename21 {
                label {21  }
                callback {selectfilename(21);}
                xywh {40 430 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[20]=o;}
              }
              Fl_Output filename22 {
                label {22  }
                callback {selectfilename(22);}
                xywh {40 449 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[21]=o;}
              }
              Fl_Output filename23 {
                label {23  }
                callback {selectfilename(23);}
                xywh {40 468 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[22]=o;}
              }
              Fl_Output filename24 {
                label {24  }
                callback {selectfilename(24);}
                xywh {40 487 430 19} labelfont 1 labelsize 12 textsize 12
                code0 {filename[23]=o;}
              }
              Fl_Repeat_Button button_moveup {
                callback {moveselected(-1);}
                image {images/up.gif} xywh {530 255 70 20} labelsize 12 align 17
              }
              Fl_Repeat_Button button_movedown {
                callback {moveselected(1);}
                image {images/down.gif} xywh {530 275 70 20} labelsize 12
              }
              Fl_Button button_load {
                label {Load...}
                callback {if (currsong == NULL) {
	fl_message("No song selected.\\nSelect a song on the Project/Song tab and try again.");
	return;
	return;
}
string* audiofiledir=hd24utils::getlastdir("audiofiledir");

Fl_Native_File_Chooser chooser;
chooser.directory(audiofiledir->c_str());
delete audiofiledir;
chooser.title("Select the files to transfer:\\0");
chooser.type(Fl_Native_File_Chooser::BROWSE_MULTI_FILE);
chooser.filter("Audio files\\t*.{wav,aif}\\0");
//chooser.preview(0);
int tosplitornottosplit=0;

switch (chooser.show()) {
	case -1: break; //error
	case 1: break; //cancel
	default:
		if (chooser.filename()) {
			string* cfilename=new string(chooser.filename());		

			string* fpath=new string("");
			*fpath+=cfilename->substr(0,strlen(cfilename->c_str())-strlen(fl_filename_name(cfilename->c_str())));
			hd24utils::setlastdir("audiofiledir",fpath->c_str());				
			delete cfilename;
			for (int n = 0; n < chooser.count(); n++ ) {
				string* cfilename=new string(chooser.filename(n));
				int currfiletracks=countfiletracks(cfilename->c_str());
				int totfiletracks=currfiletracks;
				int haveslot=0;	
				while (currfiletracks>0) {
					if (totfiletracks>1) {
						if (tosplitornottosplit==0) {
							bool wantsplit=
							confirm("One or more selected files have more than 1 track. Do you wish to split them up?");
							if (!wantsplit) {
								tosplitornottosplit=1;
							} else {
								tosplitornottosplit=2;
							}
						}
					}
				
					haveslot=0;	
					for (unsigned int freeslot=0;freeslot<currsong->logical_channels();freeslot++) {
						if (strlen(filename[freeslot]->value())==0) {
							haveslot=1;
							filename[freeslot]->value(chooser.filename(n));
//							cout << "Clear slot " << freeslot << endl;
							((Fl_Choice*)(trackaction[freeslot]))->clear();
							if (tosplitornottosplit>1) {
								populate_trackactionbyfile(freeslot,3+(totfiletracks-currfiletracks));					
							} else {
								populate_trackactionbyfile(freeslot,2);									
							}
							break;
						}
					}
					if (haveslot==0) {
						break;
					}
					if (tosplitornottosplit==1) {					
						currfiletracks=0;
					} else {
						currfiletracks--;
					}
				}
				delete cfilename;
				if (haveslot==0) {
					fl_message("One or more files could not be assigned to a track slot.\\n"
						   "Please clear one or more track slots and try again.");
					break;
				}				
		        }
		}
}}
                xywh {530 50 70 20} labelsize 12
              }
              Fl_Button button_clear {
                label Clear
                callback {for (unsigned int i=0;i<MAXCHANNELS;i++) {
	if (trackselected[i]==1) {
		filename[i]->value("");
		trackselected[i]=0;

	}
};
redrawtracks();}
                xywh {530 70 70 20} labelsize 12
              }
              Fl_Choice trackaction1 {open
                xywh {470 50 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,1);}
              } {}
              Fl_Choice trackaction2 {open
                xywh {470 69 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,2);}
              } {}
              Fl_Choice trackaction3 {open
                xywh {470 88 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,3);}
              } {}
              Fl_Choice trackaction4 {open
                xywh {470 107 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,4);}
              } {}
              Fl_Choice trackaction5 {open
                xywh {470 126 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,5);}
              } {}
              Fl_Choice trackaction6 {open
                xywh {470 145 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,6);}
              } {}
              Fl_Choice trackaction7 {open
                xywh {470 164 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,7);}
              } {}
              Fl_Choice trackaction8 {open
                xywh {470 183 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,8);}
              } {}
              Fl_Choice trackaction9 {open
                xywh {470 202 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,9);}
              } {}
              Fl_Choice trackaction10 {open
                xywh {470 221 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,10);}
              } {}
              Fl_Choice trackaction11 {open
                xywh {470 240 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,11);}
              } {}
              Fl_Choice trackaction12 {open
                xywh {470 259 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,12);}
              } {}
              Fl_Choice trackaction13 {open
                xywh {470 278 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,13);}
              } {}
              Fl_Choice trackaction14 {open
                xywh {470 297 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,14);}
              } {}
              Fl_Choice trackaction15 {open
                xywh {470 316 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,15);}
              } {}
              Fl_Choice trackaction16 {open
                xywh {470 335 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,16);}
              } {}
              Fl_Choice trackaction17 {open
                xywh {470 354 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,17);}
              } {}
              Fl_Choice trackaction18 {open
                xywh {470 373 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,18);}
              } {}
              Fl_Choice trackaction19 {open
                xywh {470 392 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,19);}
              } {}
              Fl_Choice trackaction20 {open
                xywh {470 411 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,20);}
              } {}
              Fl_Choice trackaction21 {open
                xywh {470 430 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,21);}
              } {}
              Fl_Choice trackaction22 {open
                xywh {470 449 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,22);}
              } {}
              Fl_Choice trackaction23 {open
                xywh {470 468 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,23);}
              } {}
              Fl_Choice trackaction24 {open
                xywh {470 487 55 19} down_box BORDER_BOX labelsize 11 textsize 11
                code0 {this->populate_trackaction(this,o,24);}
              } {}
              Fl_Button button_transfertohd24help {
                label Help
                callback {fl_message(
		"To transfer files to the HD24, load one or more files.\\n"
		"Each file will be assigned to an empty track slot.\\n\\n"
		"Before transferring, you will be able to rearrange the\\n"
		"order of the tracks by clicking on one or more tracks\\n"
		"and clicking the up or down arrow buttons.\\n\\n"
		"When a track slot is empty, the existing track will be\\n"
		"preserved, unless 'Erase' or 'SMPTE' is selected on \\n"
		"the right of the track.\\n\\n"
		"When a file to transfer contains multiple tracks, you\\n"
                "can choose to mixdown the file to mono (the default), \\n"
                "or you can select the track that you want to transfer \\n"
                "to the HD24 drive." 
	);}
                xywh {530 455 70 20} labelsize 12
              }
            }
          }
          Fl_Group uicanvas_futureversions {open
            xywh {5 10 1710 530} hide resizable
          } {
            Fl_Tabs Future_Tabs {open
              xywh {10 35 1595 485}
            } {
              Fl_Group tab_wave {
                label Wave open
                xywh {15 60 595 455} color 52 labelfont 1 labelsize 12 deactivate
                code0 {o->hide();}
              } {
                Fl_Box {} {
                  label {A future version of HD24connect may display a wave form here.
Initially, the purpose of this wave form would be to make it 
easier to select an export range.}
                  xywh {15 68 460 222} align 21
                }
              }
              Fl_Group tab_data {
                label Data open
                xywh {15 60 595 455} color 52 labelfont 1 labelsize 12 hide deactivate
                code0 {o->hide();}
              } {
                Fl_Box {} {
                  label {A future version of HD24connect may display a list of data files here. 
Specifically, this would be a list of files associated with the current
project and/or song. To make this possible, a single song on the
HD24 drive may be sacrificed as data area. This tab would then contain
functionality to import/export/list those files, as well as functionality to 
create a data area on the drive.
Without data area on the HD24 drive itself, songs may still be given a 
unique identifier to allow, for instance, automatically associating a mix 
on the DAW computer with a song. }
                  xywh {15 63 505 222} align 21
                }
              }
            }
          }
        }
      }
    }
  }
  Function {make_cli(hd24fs* p_fsys)} {return_type void
  } {
    code {// make_cli: stands for make commandline interface
// (intended to allow batch processing and regression testing)
// both current and default to allow multi drive support
defaulthd24=p_fsys; 
currenthd24=p_fsys;} {}
  }
  decl {/* ===RECORDER UI stuff ===================================================== */} {}
  Function {readmixer()} {open return_type void
  } {
    code {// set solo status of channel to value
/*
for (unsigned int i=0;i<MAXCHANNELS;i++) {
	solobutton[i]->value(mixer->mixerchannel[i]->control->solo());
	solobutton[i]->redraw();
	mutebutton[i]->value(mixer->mixerchannel[i]->control->mute());
	mutebutton[i]->redraw();
}
*/} {}
  }
  decl {/* === UTILS ===================================================== */} {}
  Function {getlastprojdir(Fl_Input* o)} {return_type void
  } {
    code {string* projdir=hd24utils::getlastdir("projdir");
o->value(projdir->c_str());
delete projdir;} {}
  }
  Function {ui_restart()} {open
  } {
    code {//if (isportaudioinitialized()) {
//	portaudio_transport_stop();
//}
if (recorder!=NULL) {
	if (recorder->control!=NULL) {
		recorder->control->button_stop_call();
	}
}
Fl::remove_timeout(poll_callback);

recorder->~RecorderUI();
delete recorder;

Fl_Window * winx=Fl::first_window();
if (currproj!=NULL)
{
    delete currproj;
    currproj=NULL;
}

if (currsong!=NULL)
{
    delete currsong;
    currsong=NULL;
}

Fl_Window * winy=make_window(currenthd24);

winy->position(winx->x(),winx->y());
winy->end();
winy->show();
\#ifdef LINUX
XSetWMHints(fl_display, fl_xid(winy), XGetWMHints(fl_display, fl_xid(winx)));
\#endif
winx->~Fl_Window();
delete winx;
winx=NULL;
//if (jackmtsample!=NULL)
//{
//	free(jackmtsample);
//}} {}
  }
  Function {loadheaderfile()} {} {
    code {Fl_Native_File_Chooser chooser;
chooser.title("Select header file\\0");
chooser.filter("Drive Images\\t*.{img,bin,h24,hd24}\\0");
chooser.type(Fl_Native_File_Chooser::BROWSE_FILE);

string* headerdir=hd24utils::getlastdir("headerdir");
chooser.directory(headerdir->c_str());
delete headerdir;
switch (chooser.show()) {
	case -1: break; //error
	case 1: break; //cancel
	default:
		if (chooser.filename()) {
			if (!(currenthd24->useheaderfile (chooser.filename()))) {
				fl_message("Couldn't load headerfile. Possible causes: \\n- Most likely you haven't selected a device or drive image yet.\\n- Maybe you have no read access to the file.");
				return;
			}
			string* strfile=new string(chooser.filename());			
			string* fpath=new string("");
			*fpath+=strfile->substr(0,strlen(strfile->c_str())-strlen(fl_filename_name(strfile->c_str())));
			hd24utils::setlastdir("headerdir",fpath->c_str());			
			ui_restart();
			return;
		}
		break;
}} {}
  }
  Function {anyfilesexist(hd24song* thesong)} {return_type bool
  } {
    code {bool anyexist=false;

struct stat fi;
__uint32 channels=thesong->logical_channels();
for (unsigned int q=0; q<100; q++)
{
    for (unsigned int handle=0;handle<channels;handle++) 
    {
        if (track[handle]->value()==0) {
    	    // channel not selected for export
	    continue;
        }
        string* fname=transeng->generate_filename(handle,0,q);
\#if (HD24DEBUG==1) 
      cout << "check if file exists:" << *fname << endl; 
\#endif    
        if ((stat (fname->c_str(), &fi) != -1) && ((fi.st_mode & S_IFDIR) == 0)) {
            anyexist=true;
\#if (HD24DEBUG==1) 
  cout << "yes, exists" << *fname << endl; 
\#endif            
            delete fname;
            break;
        }
    
        fname=transeng->generate_filename(handle,1,q);
\#if (HD24DEBUG==1) 
  cout << "check if file exists:" << *fname << endl; 
\#endif    
        if ((stat (fname->c_str(), &fi) != -1) && ((fi.st_mode & S_IFDIR) == 0)) {
            anyexist=true;
\#if (HD24DEBUG==1) 
  cout << "yes, exists" << *fname << endl; 
\#endif            
            delete fname;
            break;
        }    
\#if (HD24DEBUG==1) 
      cout << "no, doesnt exist" << endl;
\#endif            

        delete fname;
    }  
    if (anyexist==true) break;
}
return anyexist;} {}
  }
  Function {fl_check()} {open return_type void
  } {
    code {refresh(stop_transfer);
refresh(statusmsg);
Fl::check();} {}
  }
  decl {bool mustdisplaytimer;} {public
  }
  decl {bool polling;} {public
  }
  decl {Fl_Text_Buffer* catalogbuffer;} {public
  }
  Function {HD24UserInterface(int argc,char** argv,char* absprogpath)} {open
  } {
    code {control=new HD24control();
control->parentui(this);
control->ready(0);
/*currpeakmode=0;
for (unsigned int i=0;i<MAXCHANNELS;i++) { trackpeak[i]=0; } */
catalogbuffer=NULL;
portaudio=new PortAudioWrapper(absprogpath);
soundfile=new SoundFileWrapper(absprogpath);
libjack=new JackWrapper(absprogpath);
this->recorder=NULL; // will be initialized by make_window code
this->transeng=new hd24transferengine();} {}
  }
  Function {~HD24UserInterface()} {open
  } {
    code {if (control!=NULL) delete control;
if (portaudio!=NULL) delete portaudio;
if (soundfile!=NULL) delete soundfile;
if (libjack!=NULL) delete libjack;
if (currsong!=NULL) delete currsong;
if (currproj!=NULL) delete currproj;
if (currenthd24==defaulthd24)
{
	if (currenthd24!=NULL) delete currenthd24;
} else {
	if (currenthd24!=NULL) delete currenthd24;
	if (defaulthd24!=NULL) delete defaulthd24;
}
if (transeng!=NULL) 
{
	delete transeng;
	transeng=NULL;
}} {}
  }
  Function {confirm(const char* question)} {open return_type bool
  } {
    code {int result=fl_choice("%s","No","Yes",NULL,question);
if (result==1) {
	return true;
}
return false;} {}
  }
  Function {samplerate()} {open return_type __uint32
  } {
    code {// returns current samplerate of the UI, used by mixer
if (currsong==NULL) return 44100;
return currsong->samplerate();} {}
  }
  decl {friend class ScrubWheel;} {}
  decl {int refreshingui;} {}
  Function {saverestoretrackselection(Fl_Check_Button* o)} {open return_type void
  } {
    code {int i;
if (o->value()==1)
{
	if (
	     (transfersource_mixleft->value()
    	    +transfersource_mixright->value())
		==1)
	{
		// save selected tracks
		// disable track selection
		// (repopulate formats list/file name/whatever?)
		for (i=0;i<MAXCHANNELS;i++)
		{
			tracksave[i]=track[i]->value();
			track[i]->value(1);
			track[i]->deactivate();
			button_invert_tracks->deactivate();
		}
		fileformat->deactivate();
		return;
	}
}

if (o->value()==0)
{
	if (
	     (transfersource_mixleft->value()
    	    +transfersource_mixright->value())
		==0)
	{
		// restore tracks
		// enable track selection		
		for (i=0;i<MAXCHANNELS;i++)
		{		
			track[i]->value(tracksave[i]);			
			track[i]->activate();
			button_invert_tracks->activate();
			
		}
		fileformat->activate();
	}		
}} {}
  }
  Function {showprogtitle()} {open return_type void
  } {
    code {recorder->control->dispwrite(0,"HD24connect     "
           "HD24VERSION                ",3000);} {}
  }
  decl {bool closingdown;} {public
  }
  Function {finish()} {open return_type void
  } {
    code {this->control->ready(0);
this->closingdown=true;
this->recorder->finish();} {}
  }
  Function {poll_callback(void* user)} {open return_type {static void}
  } {
    code {HD24UserInterface* mythis=(HD24UserInterface*)user;
//RecorderUI* mythis=(RecorderUI*)user;
\#if (HD24DEBUG==1) 
      //cout << "poll_callback" << endl;
\#endif    
if (mythis->control->ready()!=1) { return; }


if (mythis->busy!=1) {
	mythis->busy=1;
	hd24song* mycurrsong=mythis->currsong;
	
	if (mythis->recorder->control->song()!=mythis->currsong)
	{
		mythis->recorder->control->song(mythis->currsong); /* tell recorder that the song is gone */				
	}
		
	if (mycurrsong!=NULL) {
		mycurrsong->bufferpoll();
	}


	mythis->uiredrawcount=(mythis->uiredrawcount+1)%UIREFRESH;
	if (mythis->uiredrawcount==0) {

	   for (unsigned int i=0;i<MAXCHANNELS;i++) {
//		if (mythis->Tabs->value()==mythis->tabCopyToPC) {
//			if (mythis->trackpeak[i]>.01) {
//			       if (mythis->trackpeak[i]>.9) 
//			       {
//				    mythis->trackled[i]->color(1);
//				    mythis->trackled[i]->redraw();
//			       } else {
//		                    if (mythis->trackpeak[i]>.7) {
//		           		mythis->trackled[i]->color(3);
//					mythis->trackled[i]->redraw();
//		                    } else {
//				        mythis->trackled[i]->color(2);
//				   	mythis->trackled[i]->redraw();
//				    }
//        		        }
//			} else {
//				mythis->trackled[i]->color(52);
//				mythis->trackled[i]->redraw();
//			}
//		} 
	   }

	   if (mythis->Tabs->value()==mythis->tabMixer) {
//                   mythis->mixer->redraw();
		   mythis->mixer->control->updatemeters();
	   }
	   if (mythis->Tabs->value()==mythis->tabRecorder) {
//                mythis->mixer->redraw();
//		mythis->recorder->control->updatemeters();
           }
           // Fl check??
	}
}
if (mythis->recorder!=NULL) {
	RecorderUI::poll_callback(mythis->recorder);
}
mythis->busy=0;
Fl::add_timeout(TIMEOUT,poll_callback,user);} {}
  }
  decl {Fl_Box* trackled[24];} {public
  }
  Function {setlocbuttonlabel(int i)} {open return_type void
  } {
    code {hd24song* locsong=this->currsong;
int numpoints=0;
if (locsong!=NULL) 
{
 	numpoints=locsong->locatepointcount();
}
__uint32 locatepos=locsong->getlocatepos(i);
string* locname1=new string("");
	if (!(((i==0)||(i==numpoints)))) {
		*locname1+="+";
		string* dur=locsong->display_duration(locatepos);
		*locname1+=*dur;
		delete (dur);	
	} else {
		if (i!=0)
		{
			*locname1+="+";
			string* dur=locsong->display_duration(locatepos);
			*locname1+=*dur;
			delete (dur);		
		} else {
			*locname1+="START";		
		}
	}
	
	*locname1="Seek to "+*locname1;
	int l=strlen(locname1->c_str());
	for (i=0;i<l;i++) {
		locbuttonlabel[i]=locname1->c_str()[i];
		locbuttonlabel[i+1]=(char)0;		
	}
	
	button_golocatepoint->label(&(this->locbuttonlabel[0]));
	delete locname1;} {}
  }
  decl {char locbuttonlabel[64];} {}
}