# data file for the Fltk User Interface Designer (fluid)
version 1.0109 
header_name {.h} 
code_name {.cxx}
decl {\#define RECORDERDEBUG 0} {public
} 

decl {\#define MAXSAMRATE 48000} {public
} 

decl {\#define AUDIOLIB_PORTAUDIO 1} {public
} 

decl {\#define AUDIOLIB_JACK 2} {public
} 

decl {\#define AUDIOLIB_SNDFILE 3} {public
} 

decl {\#define Pi2 (2*3.1415926535897)} {public
} 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

decl {class MixerControl;} {public
} 

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

decl {class RecorderChannelData;} {public
} 

decl {class RecorderChannelControl;} {public
} 

decl {class RecorderChannelUI;} {public
} 

decl {class RecorderData;} {public
} 

decl {class RecorderControl;} {public
} 

decl {class RecorderUI;} {public
} 

class ScrubWheel {: {public Fl_Roller}
} {
  decl {int myval;} {}
  decl {RecorderUI* ui;} {}
  decl {int lastx;} {}
  Function {handle(int e)} {open return_type int
  } {
    code {/*char *fltk_eventnames[] =
{
  "FL_NO_EVENT",
  "FL_PUSH",
  "FL_RELEASE",
  "FL_ENTER",
  "FL_LEAVE",
  "FL_DRAG",
  "FL_FOCUS",
  "FL_UNFOCUS",
  "FL_KEYDOWN",
  "FL_KEYUP",
  "FL_CLOSE",
  "FL_MOVE",
  "FL_SHORTCUT",
  "FL_DEACTIVATE",
  "FL_ACTIVATE",
  "FL_HIDE",
  "FL_SHOW",
  "FL_PASTE",
  "FL_SELECTIONCLEAR",
  "FL_MOUSEWHEEL",
  "FL_DND_ENTER",
  "FL_DND_DRAG",
  "FL_DND_LEAVE",
  "FL_DND_RELEASE",
};

*/
if (e==FL_DRAG) {
	myval=Fl::event_x()-lastx;
	RecorderControl::button_scrub_call(myval,this->ui->control);
}
lastx=Fl::event_x();
return 1;} {}
  }
  Function {ScrubWheel(int a,int b,int c,int d,const char* e):Fl_Roller(a,b,c,d,e)} {open
  } {
    code {myval=0;} {}
  }
  Function {draw()} {open
  } {
    code {//draw goes here
return Fl_Roller::draw();} {}
  }
  Function {value()} {open return_type int
  } {
    code {return this->myval;} {}
  }
  Function {value(int newval)} {open return_type int
  } {
    code {int oldval=this->myval;
this->myval=newval; // not very useful but whatever
return oldval;} {}
  }
  Function {setui(RecorderUI* p_ui)} {open
  } {
    code {this->ui=p_ui;} {}
  }
} 

class AudioSystem {open
} {
  decl {AudioStorage* tape;} {}
  decl {__uint32 samrate;} {public
  }
  decl {bool closingdown;} {public
  }
  decl {MixerControl* mixercontrol;} {}
  decl {RecorderControl* recorder;} {}
  decl {PortAudioWrapper* portaudio;} {public
  }
  decl {SoundFileWrapper* soundfile;} {public
  }
  decl {JackWrapper* libjack;} {}
  decl {PaStreamParameters* inputParameters;} {}
  decl {PaStreamParameters* outputParameters;} {}
  decl {PaStream* portaudiostream;} {}
  decl {jack_client_t *jackclient;} {}
  decl {__uint32 jackrate;} {}
  decl {__uint32 portaudiooffset;} {public
  }
  decl {int as_initialized;} {}
  decl {int portaudio_initialized;} {}
  decl {int jack_initialized;} {}
  decl {int as_looppos;} {}
  decl {bool as_mustloop;} {}
  decl {jack_port_t *output_port[24];} {}
  decl {jack_port_t *output_master[2];} {}
  decl {jack_port_t *input_port[24];} {}
  decl {long* mtsample;} {}
  decl {bool havestreamtime;} {}
  decl {__sint64 streamtime;} {public
  }
  Function {AudioSystem(RecorderControl* rec)} {open
  } {
    code {\#if (RECORDERDEBUG==1)
cout << "AudioSystem::AudioSystem()" << endl;
\#endif
initvars(rec);} {}
  }
  Function {initvars(RecorderControl* rec)} {open return_type void
  } {
    code {this->tape=NULL;
this->samrate=0;
this->closingdown=false;
this->mixercontrol=NULL;
this->recorder=rec;
this->portaudio=NULL;
this->soundfile=NULL;
this->libjack=NULL;
this->jackclient=NULL;
this->portaudiostream=NULL;
this->portaudio_initialized=0;
this->as_initialized=false;
this->jack_initialized=false;
this->as_looppos=0;
this->as_mustloop=false;
this->inputParameters=NULL;
this->outputParameters=NULL;
this->inputParameters=new PaStreamParameters;
this->outputParameters=new PaStreamParameters;
this->mtsample=NULL;
for (int i=0;i<24;i++) {
   this->output_port[i]=NULL;
   this->input_port[i]=NULL;
}
this->output_master[0]=NULL;
this->output_master[1]=NULL;
this->havestreamtime=false;} {}
  }
  Function {currentlocation(__uint32 newpos)} {open return_type void
  } {
    code {if (tape==NULL) return;
tape->currentlocation(newpos);} {}
  }
  Function {currentlocation()} {return_type __uint32
  } {
    code {if (tape==NULL) return 0;
return tape->currentlocation();} {}
  }
  Function {jack_process(jack_nframes_t nframes, void *arg)} {open private return_type {static int}
  } {
    code {\#ifndef LIBJACK
\#if (RECORDERDEBUG==1)
cout << "no libjack" << endl;
\#endif
\#endif

\#ifdef LIBJACK

RecorderControl* recordercontrol=(RecorderControl*)arg;

if (recordercontrol==NULL) {
	cout << "no control" << endl;
	return 0;
}
AudioSystem* audio=recordercontrol->audio;
if (audio==NULL)
{
	cout << "no audiosys" << endl;
	return 0;
}
if ((audio->libjack)==NULL)
{
\#if (RECORDERDEBUG==1)
cout << "no libjack" << endl;
\#endif
	return 0;
}

if (!(audio->libjack->libloaded)) 
{
	cout << "no jacklib" << endl;
	return 0;
}

RecorderControl* mythis=recordercontrol;
//RecorderUI* mythis=recordercontrol; //(RecorderUI*)arg;
//AudioSystem* audio=mythis->control->audio;


jack_client_t* currjackclient=audio->jackclient;
if (currjackclient==NULL) return 0;
MixerControl* mixer=audio->mixer();
if (mixer==NULL) return 0;
jack_position_t current;
jack_transport_state_t transport_state=audio->libjack->jack_transport_query(currjackclient,&current);

hd24song* mysong=(hd24song*)audio->tape;
if (mysong==NULL) return 0; /* nothing to do! */

hd24fs* myfs=mysong->fs();

__sint64 frame_time = (__sint64)(audio->libjack->jack_get_current_transport_frame(currjackclient));

MixerChannelControl* mixerchannel[24];

	
for (unsigned int tracknum=0;tracknum<MAXCHANNELS;tracknum++) 
{
	mixerchannel[tracknum]=mixer->parentui()->mixerchannel[tracknum]->control;
}
	
unsigned int i;
__sint64 intsamval=0;
mysong->golocatepos(frame_time);
int jumpedloop=0;
if (transport_state!=JackTransportStopped) 
{
	__sint64 frpos=frame_time;
	__sint64 posoffset=0;
	for (i=0;i<nframes;i++) 
	{
		if ( mythis->loopmode()==1 ) 
		{
			posoffset++;
			if ((frpos+i)==(__sint64)(mysong->getlocatepos(hd24song::LOCATEPOS_LOOPEND))) 
			{
				frpos=mysong->getlocatepos(hd24song::LOCATEPOS_LOOPSTART);
				mysong->golocatepos(frpos);
				posoffset=0;
				jumpedloop=1;
			}
		}

		mysong->getmultitracksample(
			(long*)((&audio->mtsample[i*25])),
			hd24song::READMODE_REALTIME
		);
	}
	if (jumpedloop==1) 
	{
		audio->hd24_transport_locate((__sint64)(frpos+posoffset));
	}
}

for (unsigned int tracknum=0;tracknum<MAXCHANNELS;tracknum++) 
{
	jack_default_audio_sample_t *out = 
	(jack_default_audio_sample_t *)(audio->libjack->jack_port_get_buffer (audio->output_port[tracknum], nframes));
	jack_default_audio_sample_t *in = 
	(jack_default_audio_sample_t *)(audio->libjack->jack_port_get_buffer (audio->input_port[tracknum], nframes));
	for (i=0;i<nframes;i++) 
	{
		if (transport_state!=JackTransportStopped) {
 			long* xb=(long*)(&(audio->mtsample[i*25+tracknum]));
			intsamval=xb[0];
			intsamval=((intsamval>>16)+((intsamval%256)<<16)+(intsamval & 0xff00));			
			if (intsamval>=(1<<23)) {
				intsamval-=(1<<24);
			}
			double samval=(intsamval/(double)0x800000);
			out[i]=samval; // send pre-fader, pre-mixer channel output to JACK
		} else {			
			out[i]=0;
		}
		
		mixerchannel[tracknum]->sample(i,out[i]);
				
		// ... except if we are monitoring input, in which case regular reading etc is
		// still going on, but we will just copy the incoming signal to the output:
		// (with the possible exception of tracks being recorded but that's for later)
		if (myfs->isallinput()) {
			out[i]=in[i];
		}

                if (fabs(out[i]) > mythis->data->trackpeak[i]) {
			mythis->data->trackpeak[tracknum]=fabs(out[i]);
		}
	}
}
mixer->mix(nframes);
jack_default_audio_sample_t *masterL = 
(jack_default_audio_sample_t *)(audio->libjack->jack_port_get_buffer (audio->output_master[0], nframes));
jack_default_audio_sample_t *masterR = 
(jack_default_audio_sample_t *)(audio->libjack->jack_port_get_buffer (audio->output_master[1], nframes));
if ((masterL!=NULL)&&(masterR!=NULL)) {	
	for (i=0;i<nframes;i++) 
	{
		masterL[i] = mixer->masterout(0,i); // left 
		masterR[i] = mixer->masterout(1,i); // right	
	}
}
\#endif

return 0;} {}
  }
  Function {jack_shutdown(void *arg)} {private return_type {static void}
  } {
    code {\#ifdef LIBJACK
AudioSystem* audio=(AudioSystem*)arg;
if (audio->jackclient==NULL) {
    return;
}
if (audio->mtsample!=NULL) {
	memutils::myfree("jack_shutdown",audio->mtsample);
	audio->mtsample=NULL;
}
audio->jackclient=NULL;
return;
\#endif} {}
  }
  Function {jackinit()} {open private return_type void
  } {
    code {if (portaudio_initialized==1) 
{
\#if (RECORDERDEBUG==1)
	cout << "not initializing jack because portaudio is active" << endl;
\#endif
	return;
}
if (!(libjack->libloaded)) 
{
\#if (RECORDERDEBUG==1)
	cout << "not initializing jack because its lib is not loaded" << endl;
\#endif
	return;
}
if (this->closingdown) {
    if (jackclient!=NULL)
    {
        jack_shutdown(this);
    }
    jackclient=NULL;
    return;
}
\#ifdef LIBJACK
//button_setlocate->value(0);
//highlight_setbuttons(0); // value of setlocate button
//mustdisplaytimer=true;
if (jackclient==NULL) {
	jackclient = libjack->jack_client_new("HD24connect");

	if (jackclient == NULL) {
		// error: jack open failed.
\#if (RECORDERDEBUG==1)
		cout << "error: jack open failed." << endl;
\#endif		
		return;
	}
	mtsample=(long *)memutils::mymalloc("jackinit",512000,1);
	
	libjack->jack_set_process_callback (
		jackclient,
		(int (*)(jack_nframes_t, void*))jack_process, 
		recorder); // was: this (=audiosystem)
	libjack->jack_on_shutdown (jackclient, jack_shutdown, this);
	jackrate=libjack->jack_get_sample_rate (jackclient);
	int i;
	for (i=1;i<=MAXCHANNELS;i++) {
		string portnameout="output";
		string portnamein="input";
		
		string* tracknum=Convert::int2str(i);
		portnameout+=*tracknum;
		portnamein+=*tracknum;
		delete(tracknum);

		output_port[i-1]=libjack->jack_port_register (jackclient, portnameout.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
		input_port[i-1]=libjack->jack_port_register (jackclient, portnamein.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
	}
	string portnameout="master_out_L";
	output_master[0]=libjack->jack_port_register (jackclient, portnameout.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
	portnameout="master_out_R";
	output_master[1]=libjack->jack_port_register (jackclient, portnameout.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);	
	if (libjack->jack_activate(jackclient)) {
\#if (RECORDERDEBUG==1)
		cout << "cannot activate jack client" << endl;
\#endif
	};
}
\#endif} {}
  }
  Function {isjackinitialized()} {open private return_type bool
  } {
    code {if (this->jackclient!=NULL)
{
	return true;
}
return false;} {}
  }
  Function {portaudioinit()} {open private return_type void
  } {
    code {\#ifndef LIBPORTAUDIO
return;
\#endif
\#ifdef LIBPORTAUDIO
//if (currsong==NULL) return;
//\#if (RECORDERDEBUG==1) 
//cout << "Init portaudio" << endl; 
//\#endif
//mustdisplaytimer=true;
PaError err;
err=(*(portaudio->Pa_Initialize))();
if (err!=paNoError) { 
        this->portaudiostream=NULL;
	(*(portaudio->Pa_Terminate))(); return; 
\#if (RECORDERDEBUG==1) 
cout << "Error during init portaudio" << endl; 
\#endif
}
this->mustloop(false);
this->as_looppos=0;
this->portaudio_initialized=1;
this->as_initialized=1;
\#endif} {}
  }
  Function {isportaudioinitialized()} {open private return_type bool
  } {
    code {if (!(portaudio->libloaded)) {
return false;
}
if (portaudiostream!=NULL) {
	return true;
}
if (portaudio_initialized!=0) {
	return true;
}
return false;} {}
  }
  Function {portaudio_process(const void *inputBuffer, void *outputBuffer, __uint32 nframes, const PaStreamCallbackTimeInfo* timeinfo,PaStreamCallbackFlags, void *userData)} {open private return_type {static int}
  } {
    code {RecorderControl* recordercontrol=(RecorderControl*)userData;

if (recordercontrol==NULL) {
	cout << "no control" << endl;
	return 0;
}
AudioSystem* audio=recordercontrol->audio;
if (audio==NULL)
{
	cout << "no audiosys" << endl;
	return 0;
}
if (audio->portaudio==NULL)
{
	cout << "no portaudio" << endl;
	return 0;
}
if (!(audio->portaudio->libloaded)) 
{
	cout << "no palib" << endl;
	return 0;
}
if (!audio->havestreamtime)
{
	audio->streamtime=0;
        audio->havestreamtime=true;
}

float samleft=0;
float samright=0;

//hd24fs* myfs=mythis->currenthd24;

PaStream* curr_pa_stream=audio->portaudiostream;

if (curr_pa_stream==NULL)
{
	cout << "no stream" << endl;
	return paContinue;
}
if ((audio->mtsample)==NULL) 
{
	cout << "no sample" << endl;
	return paContinue;
}

// TODO: connect audio system to mixer
MixerControl* mixer=audio->mixer();
if (mixer==NULL) 
{
	cout << "no mixer" << endl;
	return paContinue;
}

if (audio->mustloop()) 
{
	cout << "must loop" << endl;
	return paContinue;
}

hd24song* mysong=recordercontrol->song();
if (mysong == NULL) 
{
	cout << "no song" << endl;
	return 0;//nothing to do!
}

unsigned int tottracks=(unsigned int)mysong->logical_channels();

/* frame time indicates how long the stream has been playing
   and is reset to 0 after pressing stop/play.
   To compensate for this, we must add our portaudio-offset,
   the offset of the songcursor when we pressed 'play'.
   We then record the absolute stream time in pa_streamtime. */
__sint64 frame_time = audio->streamtime; 
frame_time+=audio->portaudiooffset; 
//audio->streamtime=frame_time;
audio->streamtime+=nframes;
MixerChannelControl* mixerchannel[24];

unsigned int i;
__sint64 intsamval=0;

mysong->golocatepos(frame_time);
int loopmode=recordercontrol->loopmode();
int jumpedloop=0;

	__sint64 frpos=frame_time;
	__sint64 posoffset=0;
	for (i=0;i<nframes;i++) 
	{
		if ( loopmode==1 ) 
		{
			posoffset++;
			if ((frpos+i)==(__sint64)(mysong->getlocatepos(hd24song::LOCATEPOS_LOOPEND))) 
			{
				frpos=mysong->getlocatepos(hd24song::LOCATEPOS_LOOPSTART);
				mysong->golocatepos(frpos);
				posoffset=0;
				jumpedloop=1;
			}
		}

		mysong->getmultitracksample(
			(long*)((&audio->mtsample[i*25])),
			hd24song::READMODE_REALTIME
		);
		// if sample rate is high speed, skip next sample.
		if ((mysong->physical_channels()/mysong->logical_channels())==2) 
		{
			mysong->getmultitracksample(
				(long*)((&audio->mtsample[i*25])),
				hd24song::READMODE_REALTIME
			);		
		}
	}
	if (jumpedloop==1) 
	{
		audio->as_looppos=frpos+posoffset;
		audio->mustloop(true);
	}
	

	
	for (unsigned int tracknum=0;tracknum<MAXCHANNELS;tracknum++) 
	{
		mixerchannel[tracknum]=mixer->parentui()->mixerchannel[tracknum]->control;	
	}
	
	for (unsigned int tracknum=0;tracknum<tottracks;tracknum++) 
	{
		recordercontrol->data->trackpeak[tracknum]=0;
	}
	

	for (i=0;i<nframes;i++) 
	{
		double samvaltot=0;
		if (inputBuffer!=NULL) {
			samleft=((float*)inputBuffer)[i*2];
			samright=((float*)inputBuffer)[i*2+1];
		} else {
			samleft=0;
			samright=0;
		}
		// depending on input mode, mix these to mono, set right to be equal to 
		// left, swap them or set left to be equal to right.
		float subsamval;
		for (unsigned int tracknum=0;tracknum<tottracks;tracknum++) 
		{
 			long* xb=(long*)(&(audio->mtsample[i*25+tracknum]));
			intsamval=xb[0];
			intsamval=((intsamval>>16)+((intsamval%256)<<16)+(intsamval & 0xff00));			
			if (intsamval>=(1<<23)) {
				intsamval-=(1<<24);
			}
			

			if (mysong->istrackmonitoringinput(tracknum+1)) 
			{				
				subsamval=((tracknum%2)==0)?(samleft):(samright);
			} 
			else 
			{
				subsamval=(intsamval/(double)0x800000);
			}
			samvaltot+=subsamval;
			if (fabs(subsamval) > recordercontrol->data->trackpeak[tracknum]) {
				recordercontrol->data->trackpeak[tracknum]=fabs(subsamval);
			}
			
			mixerchannel[tracknum]->sample(i,subsamval);

		}
		if (tottracks<24) {
			for (unsigned int tracknum=tottracks;tracknum<MAXCHANNELS;tracknum++) {
				mixerchannel[tracknum]->sample(i,0);
			}
		}
		/*
		if (outputBuffer!=NULL) {
			((float*)outputBuffer)[i*2] = samval; // left 
			((float*)outputBuffer)[i*2+1] = samval; // right
		}*/

	}
	mixer->mix(nframes);
	
	if (outputBuffer!=NULL) {
		
		for (i=0;i<nframes;i++) 
		{
			((float*)outputBuffer)[i*2] = mixer->masterout(0,i); // left 
			((float*)outputBuffer)[i*2+1] = mixer->masterout(1,i); // right	
		}
	}

//	cout << mythis->trackpeak[0] << endl;

return 0;} {}
  }
  Function {portaudio_transport_start()} {open private return_type void
  } {
    code {if (!(portaudio->libloaded)) {
return;
}

\#if (RECORDERDEBUG==1) 
cout << "portaudio transport start" << endl; 
\#endif
if (!isportaudioinitialized())
{
	PaError err=(*(portaudio->Pa_Initialize))();
	if (err != paNoError) 
	{
\#if (RECORDERDEBUG==1) 
		cout << "Cannot initialize portaudio- exiting." << endl;
\#endif
		
	}
}
if (isportaudioinitialized() && (portaudiostream!=NULL)) {
\#if (RECORDERDEBUG==1) 
cout << "already have stream- done starting" << endl; 
\#endif
	return;
}
this->mustloop(false);

this->as_looppos=0;
PaDeviceIndex indev=(*(portaudio->Pa_GetDefaultInputDevice))();
PaDeviceIndex outdev=(*(portaudio->Pa_GetDefaultOutputDevice))();
cout << "default input device="<<indev<< endl;
cout << "default output device="<<outdev<<endl;

if (inputParameters!=NULL)
{
	memset(inputParameters,'\\0',sizeof(*inputParameters));
}

inputParameters->channelCount=2;
inputParameters->sampleFormat=paFloat32;
inputParameters->device=indev;
inputParameters->suggestedLatency = (*(portaudio->Pa_GetDeviceInfo))( inputParameters->device )->defaultLowInputLatency;
inputParameters->hostApiSpecificStreamInfo = NULL;
\#if (RECORDERDEBUG==1) 
cout << "Input params set" << endl; 
cout << "Device=" << indev << endl;
cout << "Channelcount=" << inputParameters->channelCount << endl;
cout << "sampleFormat=" << inputParameters->sampleFormat << endl;
cout << "suggestedlatency=" << inputParameters->suggestedLatency << endl;

\#endif
if (outputParameters!=NULL)
{
	memset(outputParameters,'\\0',sizeof(*outputParameters));
}

outputParameters->channelCount=2;
outputParameters->sampleFormat=paFloat32;
outputParameters->device=outdev;
outputParameters->suggestedLatency = (*(portaudio->Pa_GetDeviceInfo))( outputParameters->device )->defaultLowOutputLatency;
outputParameters->hostApiSpecificStreamInfo = NULL;
\#if (RECORDERDEBUG==1) 
cout << "Output params set" << endl; 
\#endif
cout << "Device=" << outdev << endl;
cout << "Channelcount=" << outputParameters->channelCount << endl;
cout << "sampleFormat=" << outputParameters->sampleFormat << endl;
cout << "suggestedlatency=" << outputParameters->suggestedLatency << endl;

if (mtsample==NULL)
{
	mtsample=(long *)memutils::mymalloc("portaudio_transport_start",512000,sizeof(long));
}

double playbackrate=this->samplerate();
cout << "trying samrate="<<samrate<<endl;
cout << "framesperbuf=" << PA_FRAMESPERBUF << endl;

PaError err=(*(portaudio->Pa_OpenStream))(
	&portaudiostream,
	NULL,/*this->inputParameters,*/
	this->outputParameters,
	playbackrate,
	PA_FRAMESPERBUF, /* frames per buffer */
	paClipOff | paDitherOff,
	portaudio_process,
	(void*)recorder);
this->havestreamtime=false;
this->streamtime=0;

if (err!=paNoError) { 
\#if (RECORDERDEBUG==1) 
cout << "Error opening stream" << endl; 
cout << portaudio->Pa_GetErrorText(err) << endl;
cout << "playbackrate=" << playbackrate << endl;
\#endif
	(*(portaudio->Pa_Terminate))(); 
	return; 
}
\#if (RECORDERDEBUG==1) 
cout << "Stream opened, going to start it now..." << endl; 
\#endif
err=(*(portaudio->Pa_StartStream))(portaudiostream);
if (err!=paNoError) { 
\#if (RECORDERDEBUG==1) 
cout << "Error starting stream" << endl; 
cout << portaudio->Pa_GetErrorText(err) << endl;
\#endif
	(*(portaudio->Pa_Terminate))(); 
	return; 
}
\#if (RECORDERDEBUG==1) 
cout << "Stream started" << endl; 
\#endif


return;} {}
  }
  Function {stopPAstream()} {open private return_type void
  } {
    code {// only to be called by portaudio_transport_stop
if (portaudiostream==NULL) return;
PaStream* pstream=portaudiostream;
portaudiostream=NULL;

PaError err = (*(portaudio->Pa_StopStream))( pstream );

if (err!=paNoError) { 
       cout << portaudio->Pa_GetErrorText(err) << endl;
}

err = (*(portaudio->Pa_CloseStream))( pstream );

if (err!=paNoError) { 
   cout << portaudio->Pa_GetErrorText(err) << endl;
}

(*(portaudio->Pa_Terminate))();} {}
  }
  Function {portaudio_transport_stop()} {open private return_type void
  } {
    code {if (portaudio==NULL) return;
if (!(portaudio->libloaded)) return;

\#if (RECORDERDEBUG==1) 
cout << "portaudio transport stop" << endl;   
\#endif
// TODO: only stop stream if not monitoring input.
stopPAstream();
portaudio_initialized=0;
portaudiostream=NULL;
portaudiooffset+=streamtime;
cout << "portaudiooffset at stop=" << portaudiooffset << endl;
if (mtsample!=NULL) 
{
    memutils::myfree("portaudio_transport_stop",mtsample);
    mtsample=NULL;
}} {}
  }
  Function {hd24_transport_goloc(__uint32 frames)} {open return_type void
  } {
    code {if (libjack!=NULL)
{
	if (libjack->libloaded) {
		if (portaudio_initialized!=1) {

			jackinit();
			if (jackclient!=NULL) {
				hd24_transport_locate((__sint64)frames);
				return;
			}
		}	
	}
}

if (portaudio!=NULL)
{
	if (portaudio->libloaded) 
	{
		hd24_transport_locate((__sint64)frames);
		return;
	}
}} {}
  }
  Function {hd24_transport_locate(__sint64 i)} {open return_type void
  } {
    code {cout << "Request to transport locate to " << i << endl;
if (i<0) i=0;
if (libjack!=NULL)
{
	if (libjack->libloaded) {
		cout << "try jackinit" << endl;
		jackinit();
		if (jackclient!=NULL) {
			libjack->jack_transport_locate(jackclient,i);
			return;
		}
	}
	cout << "Jack locate attempt inconclusive, will try portaudio if available" << endl;
}

if (portaudio!=NULL)
{
	if (portaudio->libloaded) {
		cout << "will have to do portaudio locate." << endl;
		bool streamwasinitialized=true;
		if (!(isportaudioinitialized())) 
		{	
			cout << "No previous stream, init a new one "<< endl;
			streamwasinitialized=false;
			if (tape==NULL)
			{
				return;
			}

		    	tape->currentlocation((i < 0) ? 0 : i);
			cout << "set location to " << i << endl;
			portaudiooffset=i; // still ok even without active stream
			streamtime=i;
  			cout << "set portaudiooffset, streamtime to " << i << endl;
  			return; // <-- see if this does the trick- no previous 
  				// stream, no new one.
		}
	
		PaError err;
		if (portaudiostream!=NULL) 
		{
			cout << "Still have a stream that needs stopping first." << endl;
			err = (*(portaudio->Pa_StopStream))( portaudiostream );
			if (err!=paNoError) 
			{
				// maybe another program owns the stream.
            			cout << portaudio->Pa_GetErrorText(err) << endl;
        		}
        				
			PaStream* oldportaudiostream=portaudiostream;
			portaudiostream=NULL;
			err = (*(portaudio->Pa_CloseStream))( oldportaudiostream );        
		}
		
		portaudiooffset=i; // still ok even without active stream
		streamtime=i; // old portaudio V18 legacy

		bool streamnolongerinitialized=false;
		if (!(isportaudioinitialized())) 
		{
			if (streamwasinitialized)
			{ 
				streamnolongerinitialized=true;
			}
		}
		
		if (streamnolongerinitialized)
		{
			/* if closing stream means no longer initialized,
			   do not open another because we are not playing back
			   anything at the moment. */
			return;
		}
		cout << "open a fresh stream" << endl;
		
		PaDeviceIndex indev=(*(portaudio->Pa_GetDefaultInputDevice))();
		PaDeviceIndex outdev=(*(portaudio->Pa_GetDefaultOutputDevice))();
		if (inputParameters!=NULL)
		{
			memset(inputParameters,'\\0',sizeof(*inputParameters));		

			this->inputParameters->device=indev;
			this->inputParameters->channelCount=2;
			this->inputParameters->sampleFormat=paFloat32;
			void* devinfo=(void*)(*(portaudio->Pa_GetDeviceInfo))( inputParameters->device );
			if (devinfo!=NULL)
			{
				this->inputParameters->suggestedLatency = (*(portaudio->Pa_GetDeviceInfo))( inputParameters->device )->defaultLowInputLatency;
			}
			this->inputParameters->hostApiSpecificStreamInfo = NULL;
		}
		if (outputParameters!=NULL)
		{
			memset(outputParameters,'\\0',sizeof(*outputParameters));
			this->outputParameters->device=outdev;
			this->outputParameters->channelCount=2;
			this->outputParameters->sampleFormat=paFloat32;
			void* devinfo=(void*)(*(portaudio->Pa_GetDeviceInfo))( outputParameters->device );
			if (devinfo!=NULL)
			{
				this->outputParameters->suggestedLatency = (*(portaudio->Pa_GetDeviceInfo))( outputParameters->device )->defaultLowOutputLatency;
			}
			this->outputParameters->hostApiSpecificStreamInfo = NULL;
		}

		double samrate=this->samplerate();
		cout << " sample rate for new stream is " << samrate << endl;
		if (samrate==0)
		{
			return;
		}
		
		err=(*(portaudio->Pa_OpenStream))(
			&portaudiostream,
			NULL,/*this->inputParameters,*/
			this->outputParameters,
			samrate,
			PA_FRAMESPERBUF, /* frames per buffer */
			paClipOff | paDitherOff,
			portaudio_process,
			this->recorder);
		this->havestreamtime=false;
		this->streamtime=0;
	
		if (err!=paNoError) { 
            		cout << portaudio->Pa_GetErrorText(err) << endl;
        	}
		if (err!=paNoError) { (*( portaudio->Pa_Terminate))(); return; }


		err=(*(portaudio->Pa_StartStream))(portaudiostream);
		if (err!=paNoError) { 
            		cout << portaudio->Pa_GetErrorText(err) << endl;
        	}
        	cout << "stream appears to have started successfully" << endl;
		        	
		return;
	}
}} {}
  }
  Function {hd24_transport_locate(__uint32 i)} {open return_type void
  } {
    code {this->hd24_transport_locate((__sint64)i);} {}
  }
  Function {hd24_transport_start()} {open return_type void
  } {
    code {if (libjack!=NULL)
{
	if (libjack->libloaded) {
		jackinit();
		if (jackclient!=NULL) {
			libjack->jack_transport_start(jackclient);
			return;
		}
	}
}

if (portaudio!=NULL)
{
	if (portaudio->libloaded) 
	{
		if (!(isportaudioinitialized())) 
		{
			portaudioinit();
		}
		if (isportaudioinitialized()) 
		{
			portaudio_transport_start();
			return;
		}
	}
}} {}
  }
  Function {hd24_transport_stop()} {open return_type void
  } {
    code {if (recorder!=NULL)
{
	recorder->resetpeaks();
}

if (libjack!=NULL)
{
	if (libjack->libloaded) 
	{
		jackinit();
		if (jackclient!=NULL) 
		{
			libjack->jack_transport_stop(jackclient);
			return;			
		}
	}
}

if (portaudio!=NULL)
{
	if (portaudio->libloaded) 
	{
		if (!(isportaudioinitialized())) 
		{
			portaudioinit();
		}
		if (isportaudioinitialized()) 
		{
			portaudio_transport_stop();
			return;
		}
	}
}} {}
  }
  Function {hd24_transport_ffwd(long int frames)} {open return_type void
  } {
    code {if (portaudio_initialized!=1) 
{
	if (libjack!=NULL)
	{
		if (libjack->libloaded) 
		{
			jackinit();
			if (jackclient!=NULL) 
			{
			__sint64 frame_time = /* currentlocation() */
				(__sint64)(libjack->jack_get_current_transport_frame(jackclient));
			hd24_transport_locate((__sint64)(frame_time+frames));
			return;
			}
		}
	}
}

if (portaudio!=NULL)
{
	if (portaudio->libloaded) 
	{
		__sint64 frame_time=currentlocation();
		hd24_transport_locate((__sint64)(frame_time+frames));

//string* dur=currsong->display_cursor();
//setstatus(*dur);
//delete (dur);

		return;
	}
}} {}
  }
  Function {hd24_transport_rew(long int frames)} {open return_type void
  } {
    code {if (libjack!=NULL)
{
	if (libjack->libloaded) 
	{
		if (portaudio_initialized!=1) 
		{	
			jackinit();	
			if (jackclient!=NULL) 
			{
				__sint64 frame_time = 
					(__sint64)(libjack->jack_get_current_transport_frame(jackclient));
				if (frames>frame_time) {
			   	    hd24_transport_locate((__sint64)0);
				} else {
				    hd24_transport_locate((__sint64)(frame_time-frames));
				}
				return;	
			}
		}	
	}
}

if (portaudio!=NULL)
{
	if (portaudio->libloaded) {

		__sint64 frame_time=currentlocation();
		if (frames>frame_time) {
		    hd24_transport_locate((__sint64)0);
		} else {
		    hd24_transport_locate((__sint64)(frame_time-frames));
		}

		hd24_transport_locate((__sint64)(frame_time-frames));

		return;
	}	
}} {}
  }
  Function {isinitialized()} {return_type bool
  } {
    code {if (this->isportaudioinitialized())
{
	return true;
}
if (this->isjackinitialized())
{
	return true;
}
return false;} {}
  }
  Function {mustloop()} {return_type bool
  } {
    code {return this->as_mustloop;} {}
  }
  Function {mustloop(bool yesno)} {return_type void
  } {
    code {this->as_mustloop=yesno;} {}
  }
  Function {samplerate()} {return_type __uint32
  } {
    code {return this->samrate; 
/*(double)(currsong->samplerate()/(currsong->physical_channels()/currsong->logical_channels())); */} {}
  }
  Function {samplerate(__uint32 newrate)} {return_type void
  } {
    code {this->samrate=newrate;} {}
  }
  Function {looppos()} {return_type __uint32
  } {
    code {return this->as_looppos;} {}
  }
  Function {looppos(__uint32 newpos)} {return_type void
  } {
    code {this->as_looppos=newpos;} {}
  }
  Function {locatepoint(int locpointnum,__uint32 locatepos)} {return_type void
  } {
    code {if (tape==NULL) return;
tape->setlocatepos(locpointnum,locatepos);} {}
  }
  Function {locatepoint(int locpointnum)} {return_type __uint32
  } {
    code {if (tape==NULL) return 0;
return tape->getlocatepos(locpointnum);} {}
  }
  Function {audiolib(int whichlib,void* libptr)} {open return_type void
  } {
    code {if (whichlib==AUDIOLIB_PORTAUDIO)
{
	this->portaudio=(PortAudioWrapper*)libptr;
\#if (RECORDERDEBUG==1)
cout << "set portaudio lib to " << libptr << endl;
\#endif
	return;
}
if (whichlib==AUDIOLIB_JACK)
{
	this->libjack=(JackWrapper*)libptr;
\#if (RECORDERDEBUG==1)
cout << "set jack lib to " << libptr << endl;
\#endif	
	return;
}
if (whichlib==AUDIOLIB_SNDFILE)
{
	this->soundfile=(SoundFileWrapper*)libptr;
\#if (RECORDERDEBUG==1)
cout << "set soundfile lib to " << libptr << endl;
\#endif		
}} {}
  }
  Function {audiolib(int whichlib)} {open return_type {void*}
  } {
    code {if (whichlib==AUDIOLIB_PORTAUDIO)
{
	return (void*)portaudio;
}
if (whichlib==AUDIOLIB_JACK)
{
	return (void*)libjack;
}
if (whichlib==AUDIOLIB_SNDFILE)
{
	return (void*)soundfile;
}
return NULL;} {}
  }
  Function {~AudioSystem()} {open
  } {
    code {if (inputParameters!=NULL)
{
	delete inputParameters;
	inputParameters=NULL;
}
if (outputParameters!=NULL)
{
	delete outputParameters;
	outputParameters=NULL;
}
\#if (RECORDERDEBUG==1)
cout << "AudioSystem::~AudioSystem()" << endl;
\#endif} {}
  }
  Function {audiostore(AudioStorage* store)} {open return_type void
  } {
    code {this->tape=store;
if (store!=NULL)
{
	this->samrate=store->samplerate();
}} {}
  }
  Function {audiostore()} {open return_type {AudioStorage*}
  } {
    code {return tape;} {}
  }
  Function {mixer(MixerControl* p_mixer)} {open return_type void
  } {
    code {this->mixercontrol=p_mixer;} {}
  }
  Function {mixer()} {open return_type {MixerControl*}
  } {
    code {return this->mixercontrol;} {}
  }
} 

class RecorderData {open
} {
  decl {int loopmode;} {public
  }
  decl {float trackpeak[24];} {public
  }
} 

class RecorderControl {open
} {
  decl {RecorderData* data;} {public
  }
  decl {RecorderUI* ui;} {public
  }
  decl {AudioSystem* audio;} {public
  }
  Function {RecorderControl()} {open
  } {
    code {this->data=new RecorderData();
init();} {}
  }
  Function {~RecorderControl()} {open
  } {
    code {if (this->data!=NULL)
{
	delete this->data;
}} {}
  }
  Function {init()} {open return_type void
  } {
    code {this->ui=NULL;
this->audio=new AudioSystem(this);
data->loopmode=0;} {}
  }
  Function {ready()} {open return_type int
  } {
    code {return 1;} {}
  }
  Function {parentui()} {open return_type {RecorderUI*}
  } {
    code {return this->ui;} {}
  }
  Function {parentui(RecorderUI* p_ui)} {open return_type void
  } {
    code {this->ui=p_ui;} {}
  }
  Function {loopmode()} {open return_type int
  } {
    code {return data->loopmode;} {}
  }
  Function {loopmode(int p_loopmode)} {return_type void
  } {
    code {data->loopmode=p_loopmode;
if (ui!=NULL)
{
	ui->button_loopmode->value(p_loopmode);
	ui->button_loopmode->redraw();
}} {}
  }
  Function {button_scrub_call(int amount,RecorderControl* mycontrol)} {open return_type {static void}
  } {
    code {if (mycontrol->audio==NULL) return;
// we could get the current transport pos here; ....
if (amount>0) {
mycontrol->audio->hd24_transport_ffwd((__uint32)(300*amount));
} else {
mycontrol->audio->hd24_transport_rew((__uint32)(-300*amount));
}
// ... then the new transport pos here; read the snippet 
// of audio that is spanned by the difference, stretch 
// it to the audio buffer size, then play it.
// Alternatively, a visual-only representation could be fine.} {}
  }
  Function {button_rew_call()} {open return_type void
  } {
    code {if (this->audio==NULL) return;
this->audio->hd24_transport_rew(5*this->audio->samplerate());} {}
  }
  Function {button_ffwd_call()} {open return_type void
  } {
    code {if (this->audio==NULL) return;
this->audio->hd24_transport_ffwd(5*this->audio->samplerate());} {}
  }
  Function {button_stop_call()} {open return_type void
  } {
    code {if (this->audio==NULL) return;
//this->currenthd24->settransportstatus(hd24fs::TRANSPORTSTATUS_STOP);
//TODO: The above is for monitoring purposes
this->audio->hd24_transport_stop();
if (ui==NULL) return;

ui->button_light((void*)(ui->button_stop),1);
//button_stop->up_image(button_stop_uplit->image());
ui->button_up((void*)(ui->button_play));
ui->button_up((void*)(ui->button_rec));} {}
  }
  Function {button_play_call()} {open return_type void
  } {
    code {if (this->audio==NULL) return;
//if (button_rec->value()==1) {
//	this->currenthd24->settransportstatus(hd24fs::TRANSPORTSTATUS_REC);
// TODO: The above is for monitoring purposes
//} else {
//	this->currenthd24->settransportstatus(hd24fs::TRANSPORTSTATUS_PLAY);
// TODO: The above is for monitoring purposes
//}
this->audio->hd24_transport_start();

ui->button_light(ui->button_stop,0);

if (ui->button_play->value()==1)
{
	ui->button_up(ui->button_rec);
}
ui->button_down(ui->button_play);} {}
  }
  Function {button_rec_call()} {open return_type void
  } {
    code {/* ui->button_rec->redraw();
if (currsong==NULL) return;
if (currenthd24==NULL) return;

if (this->currenthd24->gettransportstatus()==hd24fs::TRANSPORTSTATUS_STOP) {
	return;
}

if (ui->button_rec->value()==1) {
	this->currenthd24->settransportstatus(hd24fs::TRANSPORTSTATUS_REC);
} else {
	this->currenthd24->settransportstatus(hd24fs::TRANSPORTSTATUS_PLAY);
}

this->audio->hd24_transport_stop();
//button_play->value(0); */} {}
  }
  Function {solo(int channel,int val)} {} {
    code {// set solo status of channel to value
//mixer->mixerchannel[channel]->control->solo(val);} {}
  }
  Function {mute(int channel,int val)} {} {
    code {// set mute status of channel to value
//mixer->mixerchannel[channel]->control->mute(val);} {}
  }
  Function {resetpeaks()} {open return_type void
  } {
    code {for (int i=0;i<24;i++)
{
	data->trackpeak[i]=0;
}} {}
  }
  Function {highlight_setbuttons(int value)} {open return_type void
  } {
    code {ui->highlight_setbuttons(value);} {}
  }
  Function {hd24_transport_goloc(__uint32 frames)} {open return_type void
  } {
    code {if (audio==NULL)
{
	return;
}
audio->hd24_transport_goloc(frames);} {}
  }
  Function {button_rehearse_call()} {return_type void
  } {
    code {return;} {}
  }
  Function {handlelocatebutton(__uint32 locpoint)} {return_type void
  } {
    code {// either set or jumpto locate point

if (ui->button_setlocate->value()==1) 
{
   // set locate point
   ui->button_setlocate->value(0);
   highlight_setbuttons(ui->button_setlocate->value());
   // set loop start to current song cursor
   if (audio==NULL) return;
   audio->locatepoint(locpoint,audio->currentlocation());   
//   ui->populate_locatepoints(currsong,ui->locatepoints);
} else {
   // jump to locate point
   if (audio==NULL) return;
   audio->hd24_transport_locate((__sint64)(audio->locatepoint(locpoint)));
}} {}
  }
  Function {disable()} {} {
    code {/* Disable the recorder */
//fl_message("TODO: recordercontrol::disable()");
if ((this->ui)==NULL) return;
this->ui->deactivate();} {}
  }
  Function {enable()} {} {
    code {/* Disable the recorder */
//fl_message("TODO: recordercontrol::enable()");
if ((this->ui)==NULL) return;
this->ui->activate();} {}
  }
  decl {int dispwritecountdown;} {public
  }
  Function {dispwrite(unsigned int line,const char* message)} {return_type void
  } {
    code {ui->dispwrite(line,message);} {}
  }
  Function {dispwrite(unsigned int line,const char* message,__uint32 timeout_msec)} {return_type void
  } {
    code {ui->dispwrite(line,message,timeout_msec);} {}
  }
  Function {audiolib(int whichlib,void* libptr)} {open return_type void
  } {
    code {if (audio==NULL) return;
audio->audiolib(whichlib,libptr);} {}
  }
  Function {song(hd24song* store)} {open return_type void
  } {
    code {audio->audiostore((AudioStorage*)store);
if (store!=NULL)
{
	this->enable();
} else {
	this->disable();
}
if (store==NULL)
{
        string* disp=new string("    No Song     "
                                "    Selected    ");
        dispwrite(0,disp->c_str());
        delete disp;
}
else
{

	string disp="S";
	string* idstr=Convert::int2str(store->songid(),2,"0");
	disp+=*idstr;
	delete idstr;
	disp+=":\\"";
	string* dummy=store->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=store->display_duration();

	*disp2+=dur->substr(0,8);
	*disp2+=":";
	*disp2+=dur->substr(9,2);
	*disp2+=" ";
	delete dur;

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

	dispwrite(0,disp2->c_str());
	delete disp2;

}} {selected
    }
  }
  Function {song()} {open return_type {hd24song*}
  } {
    code {return (hd24song*)audio->audiostore();} {}
  }
  Function {toggletrackarmed(__uint32 base1tracknum)} {open return_type void
  } {
    code {AudioStorage* astore=(hd24song*)(this->audio->audiostore());
astore->trackarmed(base1tracknum,!astore->trackarmed(base1tracknum));} {}
  }
} 

class RecorderUI {: {public Fl_Group}
} {
  decl {RecorderControl* control;} {public
  }
  Function {RecorderUI(int a,int b,int c,int d):Fl_Group(a,b,c,d,NULL)} {open
  } {
    code {this->control=new RecorderControl();
control->parentui(this);
this->window=(Fl_Window*)(this->make_window());
this->init_gui();} {}
  }
  Function {~RecorderUI()} {open
  } {
    code {delete control;} {}
  }
  Function {init_gui()} {open
  } {
    code {// position vu meters on recorder tab
int startx=trackchan[0]->x();
int starty=trackchan[0]->y();
for (unsigned int i=1; i<=MAXCHANNELS; i++) {
   int coloff=((i-((i-1)%8))-1)/8;
   trackchan[i-1]->setui(this);
   trackchan[i-1]->position(7+(18*coloff)+(startx)+((i-1)*23),starty+10);
   trackchan[i-1]->setchnum(i);

   solobutton[i-1]->position(8+(15*coloff)+(startx)+((i-1)*23),solobutton[i-1]->y());
   solobutton[i-1]->size(solobutton[0]->w(),solobutton[0]->h());
   solobutton[i-1]->up_image(solobutton[0]->up_image());
   solobutton[i-1]->down_image(solobutton[0]->down_image());
   mutebutton[i-1]->up_image(mutebutton[0]->up_image());
   mutebutton[i-1]->down_image(mutebutton[0]->down_image());
   mutebutton[i-1]->position(solobutton[i-1]->x(),mutebutton[i-1]->y());
   mutebutton[i-1]->size(mutebutton[0]->w(),mutebutton[0]->h());

   armbutton[i-1]->position(solobutton[i-1]->x(),armbutton[i-1]->y());
   if (i!=1) {
   	armbutton[i-1]->size(armbutton[0]->w(),armbutton[0]->h());
	armbutton[i-1]->up_image(armbutton[0]->up_image());
	armbutton[i-1]->down_image(armbutton[0]->down_image());
   }

}
   

trackinfo[0]->position(8*23+15,starty+10);
trackinfo[1]->position(16*23+33,starty+10);} {}
  }
  Function {set_ui(HD24UserInterface* p_ui)} {open return_type void
  } {
    code {this->ui=p_ui;} {}
  }
  decl {bool mustdisplaytimer;} {public
  }
  decl {int loopmode;} {public
  }
  decl {RecorderChannelUI* recorderchannel[24];} {public
  }
  decl {/* ==== RECORDER UI STUFF ====================*/} {}
  decl {HD24UserInterface* ui;} {}
  decl {//hd24fs* currenthd24;} {public
  }
  decl {//hd24song* currsong;} {public
  }
  decl {Fl_Window* window} {}
  decl {int currpeakmode;} {public
  }
  decl {Fl_Box* dispcell[16][2];} {public
  }
  decl {Fl_Box* i7seg[10];} {public
  }
  decl {Fl_Box* dispfont[256];} {public
  }
  decl {int slidermoved;} {public
  }
  decl {Fl_Image_Button* armbutton[24];} {public
  }
  decl {Fl_Image_Toggle_Button* mutebutton[24];} {public
  }
  decl {Fl_Image_Toggle_Button* solobutton[24];} {public
  }
  decl {int blinkcounter; /* For blinking record enable leds of level meters etc */} {public
  }
  decl {HD24TrackChannel* trackchan[24];} {public
  }
  decl {TrackInfo* trackinfo[24];} {public
  }
  decl {char olddisp[32];} {}
  Function {dispwrite_raw(unsigned int line,const char* message,bool savedisp)} {private return_type void
  } {
    code {unsigned int max=strlen(message);
// allowed lines on display: 0 and 1
if (line>1) { return; }

if (max>(16*(2-line))) {
   // maximum 16 chars if we start on line 1 (second line)
   // 32 chars if we start on line 0 (first line).
   max=(16*(2-line));
}

for (unsigned int i=0;i<max;i++) {
    if (i==16) { line++; }    
    unsigned int currchar=(unsigned int)((unsigned char)(message[i]));
    if (savedisp) 
    {
    	olddisp[(i%16)+(16*line)]=currchar;
    }
    this->dispcell[i%16][line]->image(dispfont[currchar]->image());
    this->dispcell[i%16][line]->redraw();
    
}
fl_check();} {}
  }
  decl {int dispwritecountdown;} {public
  }
  Function {dispwrite(unsigned int line,const char* message)} {return_type void
  } {
    code {dispwrite_raw(line,message,true);
dispwritecountdown=0;} {}
  }
  Function {disprestore()} {return_type void
  } {
    code {dispwrite_raw(0,&olddisp[0],false);
dispwritecountdown=0;} {}
  }
  Function {dispwrite(unsigned int line,const char* message,__uint32 timeout_msec)} {return_type void
  } {
    code {dispwrite_raw(line,message,false);
    dispwritecountdown=(int)(1000*TIMEOUT);} {}
  }
  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();
}
*/} {}
  }
  Function {make_window() /*<-----------------------------------*/} {open
  } {
    Fl_Window recordergroup {open
      xywh {378 259 615 440} type Double
      code0 {o->position(this->x(),this->y());}
      class Fl_Group visible
    } {
      Fl_Group resources {open
        xywh {25 62 560 423} hide deactivate
      } {
        Fl_Button button_play_up {
          tooltip Play image {images/button_play.gif} xywh {25 75 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_play_dn {
          tooltip Play image {images/button_play_dn.gif} xywh {75 75 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_stop_dn {
          tooltip Play image {images/button_stop_dn.gif} xywh {295 445 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_stop_up {
          tooltip Play image {images/button_stop.gif} xywh {345 445 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_stop_uplit {
          tooltip Play image {images/button_stop_uplit.gif} xywh {355 455 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_small_up {
          tooltip arm image {images/button_small.gif} xywh {565 195 20 15} deactivate
        }
        Fl_Button button_small_dn {
          tooltip arm image {images/button_small_dn.gif} xywh {60 215 20 15} deactivate
        }
        Fl_Button button_rew_up {
          tooltip Play image {images/button_rew.gif} xywh {35 85 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_rew_dn {
          tooltip Play image {images/button_rew_dn.gif} xywh {85 85 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_ffwd_up {
          tooltip Play image {images/button_ffwd.gif} xywh {45 95 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_ffwd_dn {
          tooltip Play image {images/button_ffwd_dn.gif} xywh {95 95 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_rec_up {
          tooltip Play image {images/button_rec.gif} xywh {55 105 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_rec_dn {
          tooltip Play image {images/button_rec_dn.gif} xywh {105 105 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_mute_up {
          tooltip Play image {images/button_mute.gif} xywh {65 115 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_mute_dn {
          tooltip Play image {images/button_mute_dn.gif} xywh {115 115 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_solo_up {
          tooltip Play image {images/button_solo.gif} xywh {75 125 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_solo_dn {
          tooltip Play image {images/button_solo_dn.gif} xywh {125 125 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_lrc_led_up {
          tooltip Play image {images/button_lrc_led.gif} xywh {85 135 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_lrc_led_dn {
          tooltip Play image {images/button_lrc_led_dn.gif} xywh {135 135 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_lrc_led_on_up {
          tooltip Play image {images/button_lrc_led_on.gif} xywh {85 135 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_lrc_led_on_dn {
          tooltip Play image {images/button_lrc_led_on_dn.gif} xywh {135 135 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_lrc_up {
          tooltip Play image {images/button_lrc.gif} xywh {85 135 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Button button_lrc_dn {
          tooltip Play image {images/button_lrc_dn.gif} xywh {135 135 50 30} labelsize 11 align 16 deactivate
        }
        Fl_Box i7seg0 {
          image {images/7seg_0.gif} xywh {325 276 20 34} hide
          code0 {i7seg[0]=o;}
        }
        Fl_Box i7seg1 {
          image {images/7seg_1.gif} xywh {325 276 20 34} hide
          code0 {i7seg[1]=o;}
        }
        Fl_Box i7seg2 {
          image {images/7seg_2.gif} xywh {325 276 20 34} hide
          code0 {i7seg[2]=o;}
        }
        Fl_Box i7seg3 {
          image {images/7seg_3.gif} xywh {325 276 20 34} hide
          code0 {i7seg[3]=o;}
        }
        Fl_Box i7seg4 {
          image {images/7seg_4.gif} xywh {325 276 20 34} hide
          code0 {i7seg[4]=o;}
        }
        Fl_Box i7seg5 {
          image {images/7seg_5.gif} xywh {325 276 20 34} hide
          code0 {i7seg[5]=o;}
        }
        Fl_Box i7seg6 {
          image {images/7seg_6.gif} xywh {325 276 20 34} hide
          code0 {i7seg[6]=o;}
        }
        Fl_Box i7seg7 {
          image {images/7seg_7.gif} xywh {325 276 20 34} hide
          code0 {i7seg[7]=o;}
        }
        Fl_Box i7seg8 {
          image {images/7seg_8.gif} xywh {325 276 20 34} hide
          code0 {i7seg[8]=o;}
        }
        Fl_Box i7seg9 {
          image {images/7seg_9.gif} xywh {325 276 20 34} hide
          code0 {i7seg[9]=o;}
        }
        Fl_Group dispfontgroup {
          label font open
          xywh {565 28 70 52} hide deactivate
        } {
          Fl_Box {} {
            label label
            image {images/HD24_matrix_32.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[32]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_33.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[33]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_34.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[34]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_35.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[35]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_36.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[36]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_37.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[37]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_38.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[38]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_39.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[39]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_40.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[40]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_41.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[41]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_42.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[42]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_43.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[43]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_44.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[44]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_45.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[45]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_46.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[46]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_47.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[47]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_48.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[48]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_49.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[49]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_50.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[50]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_51.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[51]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_52.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[52]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_53.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[53]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_54.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[54]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_55.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[55]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_56.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[56]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_57.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[57]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_58.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[58]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_59.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[59]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_60.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[60]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_61.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[61]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_62.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[62]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_63.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[63]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_64.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[64]=o;}
          }
          Fl_Box {} {
            label A
            image {images/HD24_matrix_65.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[65]=o;}
          }
          Fl_Box {} {
            label B
            image {images/HD24_matrix_66.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[66]=o;}
          }
          Fl_Box {} {
            label C
            image {images/HD24_matrix_67.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[67]=o;}
          }
          Fl_Box {} {
            label D
            image {images/HD24_matrix_68.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[68]=o;}
          }
          Fl_Box {} {
            label E
            image {images/HD24_matrix_69.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[69]=o;}
          }
          Fl_Box {} {
            label F
            image {images/HD24_matrix_70.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[70]=o;}
          }
          Fl_Box {} {
            label G
            image {images/HD24_matrix_71.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[71]=o;}
          }
          Fl_Box {} {
            label H
            image {images/HD24_matrix_72.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[72]=o;}
          }
          Fl_Box {} {
            label I
            image {images/HD24_matrix_73.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[73]=o;}
          }
          Fl_Box {} {
            label J
            image {images/HD24_matrix_74.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[74]=o;}
          }
          Fl_Box {} {
            label K
            image {images/HD24_matrix_75.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[75]=o;}
          }
          Fl_Box {} {
            label L
            image {images/HD24_matrix_76.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[76]=o;}
          }
          Fl_Box {} {
            label M
            image {images/HD24_matrix_77.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[77]=o;}
          }
          Fl_Box {} {
            label N
            image {images/HD24_matrix_78.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[78]=o;}
          }
          Fl_Box {} {
            label O
            image {images/HD24_matrix_79.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[79]=o;}
          }
          Fl_Box {} {
            label P
            image {images/HD24_matrix_80.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[80]=o;}
          }
          Fl_Box {} {
            label Q
            image {images/HD24_matrix_81.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[81]=o;}
          }
          Fl_Box {} {
            label R
            image {images/HD24_matrix_82.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[82]=o;}
          }
          Fl_Box {} {
            label S
            image {images/HD24_matrix_83.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[83]=o;}
          }
          Fl_Box {} {
            label T
            image {images/HD24_matrix_84.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[84]=o;}
          }
          Fl_Box {} {
            label U
            image {images/HD24_matrix_85.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[85]=o;}
          }
          Fl_Box {} {
            label V
            image {images/HD24_matrix_86.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[86]=o;}
          }
          Fl_Box {} {
            label W
            image {images/HD24_matrix_87.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[87]=o;}
          }
          Fl_Box {} {
            label X
            image {images/HD24_matrix_88.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[88]=o;}
          }
          Fl_Box {} {
            label Y
            image {images/HD24_matrix_89.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[89]=o;}
          }
          Fl_Box {} {
            label Z
            image {images/HD24_matrix_90.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[90]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_91.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[91]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_92.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[92]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_93.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[93]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_94.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[94]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_95.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[95]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_96.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[96]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_97.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[97]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_98.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[98]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_99.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[99]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_100.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[100]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_101.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[101]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_102.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[102]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_103.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[103]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_104.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[104]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_105.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[105]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_106.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[106]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_107.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[107]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_108.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[108]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_109.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[109]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_110.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[110]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_111.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[111]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_112.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[112]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_113.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[113]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_114.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[114]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_115.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[115]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_116.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[116]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_117.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[117]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_118.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[118]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_119.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[119]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_120.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[120]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_121.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[121]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_122.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[122]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_123.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[123]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_124.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[124]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_125.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[125]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_126.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[126]=o;}
          }
          Fl_Box {} {
            label label
            image {images/HD24_matrix_127.gif} xywh {580 43 35 17} hide
            code0 {this->dispfont[127]=o;}
          }
          Fl_Box {} {
            label writeprotect
            image {images/HD24_matrix_writeprotected.gif} xywh {590 53 35 17} hide
            code0 {this->dispfont[1]=o;}
          }
          Fl_Box {} {
            label writeenable
            image {images/HD24_matrix_writeenabled.gif} xywh {600 63 35 17} hide
            code0 {this->dispfont[2]=o;}
          }
          Fl_Box {} {
            label {arrow left}
            image {images/HD24_matrix_arrowleft.gif} xywh {600 63 35 17} hide
            code0 {this->dispfont[3]=o;}
          }
          Fl_Box {} {
            label {arrow right}
            image {images/HD24_matrix_arrowright.gif} xywh {610 73 35 17} hide
            code0 {this->dispfont[4]=o;}
          }
        }
      }
      Fl_Slider locationslider {
        callback {hd24song* currsong=(hd24song*)(this->control->song());
if (currsong==NULL) return;
this->slidermoved=3;
long long newpos=(long long)currsong->songlength_in_samples();
newpos*=(int)(o->value());
newpos=(__uint32)(newpos/1000);
control->hd24_transport_goloc(newpos);}
        xywh {10 208 595 17} type Horizontal selection_color 41 labelsize 12 align 4 maximum 1000 step 1
        code0 {this->slidermoved=0;}
      }
      Fl_Box {} {
        xywh {305 226 300 149} box DOWN_BOX color 8
      }
      Fl_Button button_setlocate {
        label {SET LOC}
        callback {control->highlight_setbuttons(o->value());}
        tooltip {Set Locate} xywh {420 290 50 20} type Toggle box FLAT_BOX down_box FLAT_BOX color 16 selection_color 18 labelfont 1 labelsize 9 labelcolor 7 align 5
        code0 {o->up_image(button_lrc_up->image()); o->down_image(button_lrc_dn->image());}
        class Fl_Image_Toggle_Button
      }
      Fl_Button button_loopmode {
        label {AUTO LOOP}
        callback {control->loopmode(button_loopmode->value());}
        tooltip {Auto Loop} xywh {310 250 50 20} type Toggle box FLAT_BOX down_box FLAT_BOX color 16 selection_color 18 labelfont 1 labelsize 9 labelcolor 7 align 5
        code0 {o->up_image(button_lrc_up->image()); o->down_image(button_lrc_dn->image());}
        class Fl_Image_Toggle_Button
      }
      Fl_Repeat_Button button_rew {
        callback {control->button_rew_call();}
        tooltip Rewind image {images/button_rew.gif} xywh {310 330 50 30} box FLAT_BOX labelsize 11 align 16
        code0 {o->up_image(o->image()); o->down_image(button_rew_dn->image()); o->image(NULL);}
        class Fl_Image_Repeat_Button
      }
      Fl_Repeat_Button button_ffwd {
        callback {control->button_ffwd_call();}
        tooltip {F Fwd} image {images/button_ffwd.gif} xywh {370 330 50 30} box FLAT_BOX labelsize 11 align 16
        code0 {o->up_image(o->image()); o->down_image(button_ffwd_dn->image()); o->image(NULL);}
        class Fl_Image_Repeat_Button
      }
      Fl_Button button_stop {
        callback {if (control!=NULL) control->button_stop_call();}
        tooltip Stop image {images/button_stop_uplit.gif} xywh {430 330 50 30} box FLAT_BOX labelsize 11 align 16
        code0 {//o->up_image(button_stop_uplit->image()); o->down_image(button_stop_dn->image());}
        code1 {o->up_image(o->image()); o->down_image(button_stop_dn->image()); o->image(NULL);}
        class Fl_Image_Button
      }
      Fl_Button button_play {
        callback {control->button_play_call();}
        tooltip Play image {images/button_play.gif} xywh {490 330 50 30} box FLAT_BOX labelsize 11 align 16
        code0 {o->up_image(o->image()); o->down_image(button_play_dn->image()); o->image(NULL);}
        class Fl_Image_Button
      }
      Fl_Box {} {
        xywh {475 231 127 84} box BORDER_BOX color 0
      }
      Fl_Button button_loopstart {
        label {LOOP START}
        callback {control->handlelocatebutton(hd24song::LOCATEPOS_LOOPSTART);}
        tooltip {Loop Start} xywh {485 250 50 20} box FLAT_BOX down_box FLAT_BOX color 16 selection_color 18 labelfont 1 labelsize 9 labelcolor 7 align 1
        code0 {hlbuttons_defaultcolor=o->color(); o->up_image(button_lrc_led_up->image()); o->down_image(button_lrc_led_dn->image());}
        class Fl_Image_Button
      }
      Fl_Button button_loopend {
        label {LOOP END}
        callback {control->handlelocatebutton(hd24song::LOCATEPOS_LOOPEND);}
        tooltip {Loop End} xywh {550 250 50 20} box FLAT_BOX down_box FLAT_BOX color 16 selection_color 18 labelfont 1 labelsize 9 labelcolor 7 align 9
        code0 {o->up_image(button_lrc_led_up->image()); o->down_image(button_lrc_led_dn->image());}
        class Fl_Image_Button
      }
      Fl_Button button_locate0 {
        label {LOC 0}
        callback {control->audio->hd24_transport_locate((__sint64)0);}
        tooltip {Locate 0} xywh {420 250 50 20} box FLAT_BOX color 16 selection_color 18 labelfont 1 labelsize 9 labelcolor 7 align 5
        code0 {o->up_image(button_lrc_up->image()); o->down_image(button_lrc_dn->image());}
        class Fl_Image_Button
      }
      Fl_Button button_rec {
        callback {control->button_rec_call();}
        tooltip Record image {images/button_rec.gif} xywh {550 330 50 30} type Toggle box FLAT_BOX labelsize 11
        code0 {o->up_image(o->image()); o->down_image(button_rec_dn->image()); o->image(NULL);}
        class Fl_Image_Toggle_Button
      }
      Fl_Group channelcanvas {open
        xywh {10 15 595 140} box DOWN_BOX color 0
      } {
        Fl_Group tc1 {open
          xywh {15 15 15 135}
          code0 {trackchan[0]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc2 {open
          xywh {15 15 15 135}
          code0 {trackchan[1]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc3 {open
          xywh {15 15 15 135}
          code0 {trackchan[2]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc4 {open
          xywh {15 15 15 135}
          code0 {trackchan[3]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc5 {open
          xywh {15 15 15 135}
          code0 {trackchan[4]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc6 {open
          xywh {15 15 15 135}
          code0 {trackchan[5]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc7 {open
          xywh {15 15 15 135}
          code0 {trackchan[6]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc8 {open
          xywh {15 15 15 135}
          code0 {trackchan[7]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group trackinfo1 {open
          xywh {15 15 15 135}
          code0 {trackinfo[0]=trackinfo1;}
          class TrackInfo
        } {}
        Fl_Group tc9 {open
          xywh {15 15 15 135}
          code0 {trackchan[8]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc10 {open
          xywh {15 15 15 135}
          code0 {trackchan[9]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc11 {open
          xywh {15 15 15 135}
          code0 {trackchan[10]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc12 {open
          xywh {15 15 15 135}
          code0 {trackchan[11]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc13 {open
          xywh {15 15 15 135}
          code0 {trackchan[12]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc14 {open
          xywh {15 15 15 135}
          code0 {trackchan[13]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc15 {open
          xywh {15 15 15 135}
          code0 {trackchan[14]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc16 {open
          xywh {15 15 15 135}
          code0 {trackchan[15]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group trackinfo2 {open
          xywh {15 15 15 135}
          code0 {trackinfo[1]=trackinfo2;}
          class TrackInfo
        } {}
        Fl_Group tc17 {open
          xywh {15 15 15 135}
          code0 {trackchan[16]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc18 {open
          xywh {15 15 15 135}
          code0 {trackchan[17]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc19 {open
          xywh {15 15 15 135}
          code0 {trackchan[18]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc20 {open
          xywh {15 15 15 135}
          code0 {trackchan[19]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc21 {open
          xywh {15 15 15 135}
          code0 {trackchan[20]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc22 {open
          xywh {15 15 15 135}
          code0 {trackchan[21]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc23 {open
          xywh {15 15 15 135}
          code0 {trackchan[22]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group tc24 {open
          xywh {15 15 15 135}
          code0 {trackchan[23]=o;}
          class HD24TrackChannel
        } {}
        Fl_Group {} {open
          xywh {35 40 15 15}
        } {}
      }
      Fl_Button arm1 {
        callback {this->control->toggletrackarmed(1);}
        tooltip arm xywh {40 155 20 15} labelsize 8 labelcolor 7
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[0]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm2 {
        callback {this->control->toggletrackarmed(2);}
        tooltip arm xywh {60 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[1]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm3 {
        callback {this->control->toggletrackarmed(3);}
        tooltip arm xywh {75 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[2]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm4 {
        callback {this->control->toggletrackarmed(4);}
        tooltip arm xywh {90 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[3]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm5 {
        callback {this->control->toggletrackarmed(5);}
        tooltip arm xywh {105 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[4]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm6 {
        callback {this->control->toggletrackarmed(6);}
        tooltip arm xywh {120 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[5]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm7 {
        callback {this->control->toggletrackarmed(7);}
        tooltip arm xywh {135 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[6]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm8 {
        callback {this->control->toggletrackarmed(8);}
        tooltip arm xywh {150 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[7]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm9 {
        callback {this->control->toggletrackarmed(9);}
        tooltip arm xywh {235 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[8]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm10 {
        callback {this->control->toggletrackarmed(10);}
        tooltip arm xywh {250 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[9]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm11 {
        callback {this->control->toggletrackarmed(11);}
        tooltip arm xywh {265 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[10]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm12 {
        callback {this->control->toggletrackarmed(12);}
        tooltip arm xywh {280 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[11]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm13 {
        callback {this->control->toggletrackarmed(13);}
        tooltip arm xywh {295 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[12]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm14 {
        callback {this->control->toggletrackarmed(14);}
        tooltip arm xywh {310 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[13]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm15 {
        callback {this->control->toggletrackarmed(15);}
        tooltip arm xywh {325 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[14]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm16 {
        callback {this->control->toggletrackarmed(16);}
        tooltip arm xywh {340 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[15]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm17 {
        callback {this->control->toggletrackarmed(17);}
        tooltip arm xywh {430 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[16]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm18 {
        callback {this->control->toggletrackarmed(18);}
        tooltip arm xywh {445 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[17]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm19 {
        callback {this->control->toggletrackarmed(19);}
        tooltip arm xywh {460 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[18]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm20 {
        callback {this->control->toggletrackarmed(20);}
        tooltip arm xywh {475 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[19]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm21 {
        callback {this->control->toggletrackarmed(21);}
        tooltip arm xywh {490 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[20]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm22 {
        callback {this->control->toggletrackarmed(22);}
        tooltip arm xywh {505 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[21]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm23 {
        callback {this->control->toggletrackarmed(23);}
        tooltip arm xywh {520 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[22]=o;}
        class Fl_Image_Button
      }
      Fl_Button arm24 {
        callback {this->control->toggletrackarmed(24);}
        tooltip arm xywh {535 155 15 15}
        code0 {o->up_image(button_small_up->image()); o->down_image(button_small_dn->image()); armbutton[23]=o;}
        class Fl_Image_Button
      }
      Fl_Button solo1 {
        callback {control->solo(0,o->value());}
        xywh {40 175 20 15} selection_color 2
        code0 {o->up_image(button_solo_up->image()); o->down_image(button_solo_dn->image()); solobutton[0]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo2 {
        callback {control->solo(1,o->value());}
        xywh {60 175 15 15} selection_color 2
        code0 {solobutton[1]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo3 {
        callback {control->solo(2,o->value());}
        xywh {75 175 15 15} selection_color 2
        code0 {solobutton[2]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo4 {
        callback {control->solo(3,o->value());}
        xywh {90 175 15 15} selection_color 2
        code0 {solobutton[3]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo5 {
        callback {control->solo(4,o->value());}
        xywh {105 175 15 15} selection_color 2
        code0 {solobutton[4]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo6 {
        callback {control->solo(5,o->value());}
        xywh {120 175 15 15} selection_color 2
        code0 {solobutton[5]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo7 {
        callback {control->solo(6,o->value());}
        xywh {135 175 15 15} selection_color 2
        code0 {solobutton[6]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo8 {
        callback {control->solo(7,o->value());}
        xywh {150 175 15 15} selection_color 2
        code0 {solobutton[7]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo9 {
        callback {control->solo(8,o->value());}
        xywh {235 175 15 15} selection_color 2
        code0 {solobutton[8]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo10 {
        callback {control->solo(9,o->value());}
        xywh {250 175 15 15} selection_color 2
        code0 {solobutton[9]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo11 {
        callback {control->solo(10,o->value());}
        xywh {265 175 15 15} selection_color 2
        code0 {solobutton[10]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo12 {
        callback {control->solo(11,o->value());}
        xywh {280 175 15 15} selection_color 2
        code0 {solobutton[11]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo13 {
        callback {control->solo(12,o->value());}
        xywh {295 175 15 15} selection_color 2
        code0 {solobutton[12]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo14 {
        callback {control->solo(13,o->value());}
        xywh {310 175 15 15} selection_color 2
        code0 {solobutton[13]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo15 {
        callback {control->solo(14,o->value());}
        xywh {325 175 15 15} selection_color 2
        code0 {solobutton[14]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo16 {
        callback {control->solo(15,o->value());}
        xywh {340 175 15 15} selection_color 2
        code0 {solobutton[15]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo17 {
        callback {control->solo(16,o->value());}
        xywh {430 175 15 15} selection_color 2
        code0 {solobutton[16]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo18 {
        callback {control->solo(17,o->value());}
        xywh {445 175 15 15} selection_color 2
        code0 {solobutton[17]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo19 {
        callback {control->solo(18,o->value());}
        xywh {460 175 15 15} selection_color 2
        code0 {solobutton[18]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo20 {
        callback {control->solo(19,o->value());}
        xywh {475 175 15 15} selection_color 2
        code0 {solobutton[19]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo21 {
        callback {control->solo(20,o->value());}
        xywh {490 175 15 15} selection_color 2
        code0 {solobutton[20]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo22 {
        callback {control->solo(21,o->value());}
        xywh {505 175 15 15} selection_color 2
        code0 {solobutton[21]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo23 {
        callback {control->solo(22,o->value());}
        xywh {520 175 15 15} selection_color 2
        code0 {solobutton[22]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button solo24 {
        callback {control->solo(23,o->value());}
        xywh {535 175 15 15} selection_color 2
        code0 {solobutton[23]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute1 {
        callback {control->mute(0,o->value());}
        xywh {40 192 20 15} selection_color 1
        code0 {o->up_image(button_mute_up->image()); o->down_image(button_mute_dn->image()); mutebutton[0]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute2 {
        callback {control->mute(1,o->value());}
        xywh {60 192 15 15} selection_color 1
        code0 {mutebutton[1]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute3 {
        callback {control->mute(2,o->value());}
        xywh {75 192 15 15} selection_color 1
        code0 {mutebutton[2]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute4 {
        callback {control->mute(3,o->value());}
        xywh {90 192 15 15} selection_color 1
        code0 {mutebutton[3]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute5 {
        callback {control->mute(4,o->value());}
        xywh {105 192 15 15} selection_color 1
        code0 {mutebutton[4]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute6 {
        callback {control->mute(5,o->value());}
        xywh {120 192 15 15} selection_color 1
        code0 {mutebutton[5]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute7 {
        callback {control->mute(6,o->value());}
        xywh {135 192 15 15} selection_color 1
        code0 {mutebutton[6]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute8 {
        callback {control->mute(7,o->value());}
        xywh {150 192 15 15} selection_color 1
        code0 {mutebutton[7]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute9 {
        callback {control->mute(8,o->value());}
        xywh {235 192 15 15} selection_color 1
        code0 {mutebutton[8]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute10 {
        callback {control->mute(9,o->value());}
        xywh {250 192 15 15} selection_color 1
        code0 {mutebutton[9]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute11 {
        callback {control->mute(10,o->value());}
        xywh {265 192 15 15} selection_color 1
        code0 {mutebutton[10]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute12 {
        callback {control->mute(11,o->value());}
        xywh {280 192 15 15} selection_color 1
        code0 {mutebutton[11]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute13 {
        callback {control->mute(12,o->value());}
        xywh {295 192 15 15} selection_color 1
        code0 {mutebutton[12]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute14 {
        callback {control->mute(13,o->value());}
        xywh {310 192 15 15} selection_color 1
        code0 {mutebutton[13]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute15 {
        callback {control->mute(14,o->value());}
        xywh {325 192 15 15} selection_color 1
        code0 {mutebutton[14]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute16 {
        callback {control->mute(15,o->value());}
        xywh {340 192 15 15} selection_color 1
        code0 {mutebutton[15]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute17 {
        callback {control->mute(16,o->value());}
        xywh {430 192 15 15} selection_color 1
        code0 {mutebutton[16]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute18 {
        callback {control->mute(17,o->value());}
        xywh {445 192 15 15} selection_color 1
        code0 {mutebutton[17]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute19 {
        callback {control->mute(18,o->value());}
        xywh {460 192 15 15} selection_color 1
        code0 {mutebutton[18]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute20 {
        callback {control->mute(19,o->value());}
        xywh {475 192 15 15} selection_color 1
        code0 {mutebutton[19]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute21 {
        callback {control->mute(20,o->value());}
        xywh {490 192 15 15} selection_color 1
        code0 {mutebutton[20]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute22 {
        callback {control->mute(21,o->value());}
        xywh {505 192 15 15} selection_color 1
        code0 {mutebutton[21]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute23 {
        callback {control->mute(22,o->value());}
        xywh {520 192 15 15} selection_color 1
        code0 {mutebutton[22]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Button mute24 {
        callback {control->mute(23,o->value());}
        xywh {535 192 15 15} selection_color 1
        code0 {mutebutton[23]=o;}
        class Fl_Image_Toggle_Button
      }
      Fl_Box arm_unarm_all {
        callback {hd24song* currsong=this->control->song();
if (currsong==NULL) return;

bool alltracksarmed=true;
for (unsigned int i=1;i<=currsong->logical_channels();i++) {
   if (!currsong->trackarmed(i)) {
      alltracksarmed=false;
      break;
   }
}
bool mustarm=false;
if (!alltracksarmed) {
   mustarm=true;
}
for (unsigned int i=1;i<=currsong->logical_channels();i++) {
   currsong->trackarmed(i,mustarm);
}}
        tooltip {Arm tracks} xywh {10 156 10 10} box OVAL_BOX color 1 selection_color 1
        class Fl_Button
      }
      Fl_Box {} {
        label S
        tooltip Solo xywh {10 176 15 14} color 1 selection_color 1 labelfont 1 labelsize 12
      }
      Fl_Box {} {
        label M
        tooltip Mute xywh {10 191 15 14} color 1 selection_color 1 labelfont 1 labelsize 12
      }
      Fl_Group infodisplay {open
        xywh {10 225 295 150} box DOWN_BOX color 0
      } {
        Fl_Box ho1 {
          image {images/7seg_8.gif} xywh {12 234 16 26}
          code0 {o->image(i7seg0->image()); o->redraw();}
        }
        Fl_Box ho2 {
          image {images/7seg_8.gif} xywh {27 234 16 26}
          code0 {o->image(i7seg0->image()); o->redraw();}
        }
        Fl_Box mi1 {
          image {images/7seg_8.gif} xywh {55 234 16 26}
          code0 {o->image(i7seg0->image()); o->redraw();}
        }
        Fl_Box mi2 {
          image {images/7seg_8.gif} xywh {70 234 16 26}
          code0 {o->image(i7seg0->image()); o->redraw();}
        }
        Fl_Box se1 {
          image {images/7seg_8.gif} xywh {98 234 16 26}
          code0 {o->image(i7seg0->image()); o->redraw();}
        }
        Fl_Box se2 {
          image {images/7seg_8.gif} xywh {113 234 16 26}
          code0 {o->image(i7seg0->image()); o->redraw();}
        }
        Fl_Box fr1 {
          image {images/7seg_8.gif} xywh {141 234 16 26}
          code0 {o->image(i7seg0->image()); o->redraw();}
        }
        Fl_Box fr2 {
          image {images/7seg_8.gif} xywh {156 234 16 26}
          code0 {o->image(i7seg0->image()); o->redraw();}
        }
        Fl_Box {} {
          label H
          xywh {42 247 12 14} labelfont 3 labelsize 11 labelcolor 6
        }
        Fl_Box {} {
          label M
          xywh {85 247 12 14} labelfont 3 labelsize 11 labelcolor 6
        }
        Fl_Box {} {
          label S
          xywh {128 247 12 14} labelfont 3 labelsize 11 labelcolor 6
        }
        Fl_Box {} {
          label F
          xywh {171 247 12 14} labelfont 3 labelsize 11 labelcolor 6
        }
        Fl_Box l1c0 {
          image {images/HD24_matrix_realsize.gif} xywh {13 274 20 26}
          code0 {this->dispcell[0][0]=o;}
        }
        Fl_Box l1c1 {
          image {images/HD24_matrix_realsize.gif} xywh {31 274 20 26}
          code0 {this->dispcell[1][0]=o;}
        }
        Fl_Box l1c2 {
          image {images/HD24_matrix_realsize.gif} xywh {49 274 20 26}
          code0 {this->dispcell[2][0]=o;}
        }
        Fl_Box l1c3 {
          image {images/HD24_matrix_realsize.gif} xywh {67 274 20 26}
          code0 {this->dispcell[3][0]=o;}
        }
        Fl_Box l1c4 {
          image {images/HD24_matrix_realsize.gif} xywh {85 274 20 26}
          code0 {this->dispcell[4][0]=o;}
        }
        Fl_Box l1c5 {
          image {images/HD24_matrix_realsize.gif} xywh {103 274 20 26}
          code0 {this->dispcell[5][0]=o;}
        }
        Fl_Box l1c6 {
          image {images/HD24_matrix_realsize.gif} xywh {121 274 20 26}
          code0 {this->dispcell[6][0]=o;}
        }
        Fl_Box l1c7 {
          image {images/HD24_matrix_realsize.gif} xywh {139 274 20 26}
          code0 {this->dispcell[7][0]=o;}
        }
        Fl_Box l1c8 {
          image {images/HD24_matrix_realsize.gif} xywh {157 274 20 26}
          code0 {this->dispcell[8][0]=o;}
        }
        Fl_Box l1c9 {
          image {images/HD24_matrix_realsize.gif} xywh {175 274 20 26}
          code0 {this->dispcell[9][0]=o;}
        }
        Fl_Box l1ca {
          image {images/HD24_matrix_realsize.gif} xywh {193 274 20 26}
          code0 {this->dispcell[10][0]=o;}
        }
        Fl_Box l1cb {
          image {images/HD24_matrix_realsize.gif} xywh {211 274 20 26}
          code0 {this->dispcell[11][0]=o;}
        }
        Fl_Box l1cc {
          image {images/HD24_matrix_realsize.gif} xywh {229 274 20 26}
          code0 {this->dispcell[12][0]=o;}
        }
        Fl_Box l1cd {
          image {images/HD24_matrix_realsize.gif} xywh {247 274 20 26}
          code0 {this->dispcell[13][0]=o;}
        }
        Fl_Box l1ce {
          image {images/HD24_matrix_realsize.gif} xywh {265 274 20 26}
          code0 {this->dispcell[14][0]=o;}
        }
        Fl_Box l1cf {
          image {images/HD24_matrix_realsize.gif} xywh {283 274 20 26}
          code0 {this->dispcell[15][0]=o;}
        }
        Fl_Box l2c0 {
          image {images/HD24_matrix_realsize.gif} xywh {12 304 20 26}
          code0 {this->dispcell[0][1]=o;}
        }
        Fl_Box l2c1 {
          image {images/HD24_matrix_realsize.gif} xywh {30 304 20 26}
          code0 {this->dispcell[1][1]=o;}
        }
        Fl_Box l2c2 {
          image {images/HD24_matrix_realsize.gif} xywh {48 304 20 26}
          code0 {this->dispcell[2][1]=o;}
        }
        Fl_Box l2c3 {
          image {images/HD24_matrix_realsize.gif} xywh {66 304 20 26}
          code0 {this->dispcell[3][1]=o;}
        }
        Fl_Box l2c4 {
          image {images/HD24_matrix_realsize.gif} xywh {84 304 20 26}
          code0 {this->dispcell[4][1]=o;}
        }
        Fl_Box l2c5 {
          image {images/HD24_matrix_realsize.gif} xywh {102 304 20 26}
          code0 {this->dispcell[5][1]=o;}
        }
        Fl_Box l2c6 {
          image {images/HD24_matrix_realsize.gif} xywh {120 304 20 26}
          code0 {this->dispcell[6][1]=o;}
        }
        Fl_Box l2c7 {
          image {images/HD24_matrix_realsize.gif} xywh {138 304 20 26}
          code0 {this->dispcell[7][1]=o;}
        }
        Fl_Box l2c8 {
          image {images/HD24_matrix_realsize.gif} xywh {156 304 20 26}
          code0 {this->dispcell[8][1]=o;}
        }
        Fl_Box l2c9 {
          image {images/HD24_matrix_realsize.gif} xywh {174 304 20 26}
          code0 {this->dispcell[9][1]=o;}
        }
        Fl_Box l2ca {
          image {images/HD24_matrix_realsize.gif} xywh {192 304 20 26}
          code0 {this->dispcell[10][1]=o;}
        }
        Fl_Box l2cb {
          image {images/HD24_matrix_realsize.gif} xywh {210 304 20 26}
          code0 {this->dispcell[11][1]=o;}
        }
        Fl_Box l2cc {
          image {images/HD24_matrix_realsize.gif} xywh {228 304 20 26}
          code0 {this->dispcell[12][1]=o;}
        }
        Fl_Box l2cd {
          image {images/HD24_matrix_realsize.gif} xywh {246 304 20 26}
          code0 {this->dispcell[13][1]=o;}
        }
        Fl_Box l2ce {
          image {images/HD24_matrix_realsize.gif} xywh {264 304 20 26}
          code0 {this->dispcell[14][1]=o;}
        }
        Fl_Box l2cf {
          image {images/HD24_matrix_realsize.gif} xywh {282 304 20 26}
          code0 {this->dispcell[15][1]=o;}
        }
        Fl_Box autoanythingled {
          label AUTO
          xywh {193 233 65 8} box FLAT_BOX color 93 labelfont 1 labelsize 8 hide
        }
        Fl_Box autoplayled {
          label PLAY
          xywh {215 242 24 8} box FLAT_BOX color 93 labelfont 1 labelsize 8 hide
        }
        Fl_Box autortnled {
          label RTN
          xywh {240 242 18 8} box FLAT_BOX color 93 labelfont 1 labelsize 8 hide
        }
        Fl_Box autorecled {
          label REC
          xywh {193 242 21 8} box FLAT_BOX color 1 labelfont 1 labelsize 8 align 16 hide
        }
        Fl_Box rehearseled {
          label REHEARSE
          xywh {193 251 65 8} box FLAT_BOX color 1 labelfont 1 labelsize 8
        }
        Fl_Box pitchled {
          label PITCH
          xywh {260 242 40 8} box FLAT_BOX color 6 labelfont 1 labelsize 8 hide
        }
      }
      Fl_Button button_rehearse {
        label REHEARSE
        callback {control->button_rehearse_call();}
        tooltip {Set Locate} xywh {310 290 50 20} type Toggle box FLAT_BOX down_box FLAT_BOX color 47 selection_color 18 labelfont 1 labelsize 9 labelcolor 7 align 5 deactivate
        code0 {o->up_image(button_lrc_up->image()); o->down_image(button_lrc_dn->image());}
        class Fl_Image_Toggle_Button
      }
      Fl_Button button_punchin {
        label {PUNCH IN}
        callback {control->handlelocatebutton(hd24song::LOCATEPOS_PUNCHIN);}
        tooltip {Set Locate} xywh {485 290 50 20} box FLAT_BOX down_box FLAT_BOX color 47 selection_color 18 labelfont 1 labelsize 9 labelcolor 7 align 1
        code0 {o->up_image(button_lrc_led_up->image()); o->down_image(button_lrc_led_dn->image());}
        class Fl_Image_Button
      }
      Fl_Button button_punchout {
        label {PUNCH OUT}
        callback {control->handlelocatebutton(hd24song::LOCATEPOS_PUNCHOUT);}
        tooltip {Set Locate} xywh {550 290 50 20} box FLAT_BOX down_box FLAT_BOX color 47 selection_color 18 labelfont 1 labelsize 9 labelcolor 7 align 9
        code0 {o->up_image(button_lrc_led_up->image()); o->down_image(button_lrc_led_dn->image());}
        class Fl_Image_Button
      }
      Fl_Button button_peakmode {
        label {Peak
mode}
        callback {this->currpeakmode=((this->currpeakmode)+1)%3;

for (unsigned int i=0;i<MAXCHANNELS;i++) {
	this->trackchan[i]->peakmode(this->currpeakmode);
}
switch (this->currpeakmode) 
{
	case 0: // "No" "Peak Hold"
		dispwrite(0,"       No       "
                            "   Peak Hold    ",2000);
		break;
	case 1: // "Momentary" "Peak Hold"
		dispwrite(0,"   Momentary    "
                            "   Peak Hold    ",2000);
		break;
	case 2: // "Continuous" "Peak Hold"
		dispwrite(0,"   Continuous   "
                            "   Peak Hold    ",2000);
		break;
	default:
		// ???????	
	        break;
}}
        tooltip arm xywh {10 375 50 30} color 8 selection_color 8 labelfont 1 labelsize 10 labelcolor 7
        code0 {o->clear_visible_focus();}
        class Fl_Button
      }
      Fl_Button button_peakclear {
        label {Peak
clear}
        callback {this->currpeakmode=((this->currpeakmode)+1)%3;

for (unsigned int i=0;i<MAXCHANNELS;i++) {
	this->trackchan[i]->peakreset();
}}
        tooltip arm xywh {60 375 50 30} color 8 selection_color 8 labelfont 1 labelsize 10 labelcolor 7
        code0 {o->clear_visible_focus();}
        class Fl_Button
      }
      Fl_Button button_autoinput {
        label {Auto
input}
        callback {/*
if (currenthd24==NULL) return;
if (button_autoinput->value()==1) {
	currenthd24->setautoinput(true);
} else {
	currenthd24->setautoinput(false);
}
*/}
        tooltip arm xywh {110 375 45 30} type Toggle color 8 selection_color 59 labelfont 1 labelsize 10 labelcolor 7
        code0 {o->clear_visible_focus();}
        class Fl_Button
      }
      Fl_Button button_allinput {
        label {All
input}
        callback {/*
if (currenthd24==NULL) return;
if (button_allinput->value()==0) {
	currenthd24->setallinput(false);
} else {
	currenthd24->setallinput(true);
}
*/}
        tooltip arm xywh {155 375 45 30} type Toggle color 8 selection_color 59 labelfont 1 labelsize 10 labelcolor 7
        code0 {o->clear_visible_focus();}
        class Fl_Button
      }
      Fl_Choice stereoinmap {
        label {Stereo input mapping} open
        xywh {463 390 140 20} down_box BORDER_BOX labelsize 12 align 5 textsize 12 deactivate
      } {
        MenuItem {} {
          label Normal
          xywh {5 5 36 21} labelsize 12
        }
        MenuItem {} {
          label {Swap Left and Right}
          xywh {15 15 36 21} labelsize 12
        }
        MenuItem {} {
          label {Mix to mono}
          xywh {15 15 36 21} labelsize 12
        }
        MenuItem {} {
          label {Use Left only}
          xywh {25 25 36 21} labelsize 12
        }
        MenuItem {} {
          label {Use Right only}
          xywh {35 35 36 21} labelsize 12
        }
      }
      Fl_Roller {} {
        label {Drag to Jog}
        callback {// scrubwheel calls button_scrub_call()}
        xywh {310 390 110 20} type Horizontal labelsize 12 align 1 minimum -1 step 2
        code0 {o->setui(this);}
        class ScrubWheel
      }
    }
  }
  decl {/* === Audio/transport ===================================================== */} {}
  decl {int hlbuttons_defaultcolor;} {public
  }
  Function {highlight_setbuttons(int value)} {open return_type void
  } {
    code {if (value==1) {
   if (button_loopstart!=NULL) {
   button_loopstart->up_image(button_lrc_led_on_up->image());
   button_loopstart->down_image(button_lrc_led_on_dn->image());
   }
   if (button_loopend!=NULL) {
   button_loopend->up_image(button_lrc_led_on_up->image());
   button_loopend->down_image(button_lrc_led_on_dn->image());
   }
   if (button_punchin!=NULL) {
   button_punchin->up_image(button_lrc_led_on_up->image());
   button_punchin->down_image(button_lrc_led_on_dn->image());
   }
   if (button_punchout!=NULL) {
   button_punchout->up_image(button_lrc_led_on_up->image());
   button_punchout->down_image(button_lrc_led_on_dn->image());
   }
} else {
   button_loopstart->up_image(button_lrc_led_up->image());
   button_loopstart->down_image(button_lrc_led_dn->image());
   button_loopend->up_image(button_lrc_led_up->image());
   button_loopend->down_image(button_lrc_led_dn->image());
   button_punchin->up_image(button_lrc_led_up->image());
   button_punchin->down_image(button_lrc_led_dn->image());
   button_punchout->up_image(button_lrc_led_up->image());
   button_punchout->down_image(button_lrc_led_dn->image());
}
   if (button_punchout!=NULL) { button_punchout->redraw(); }
   if (button_punchin!=NULL) { button_punchin->redraw(); }
   if (button_loopstart!=NULL) { button_loopstart->redraw(); }
   if (button_loopend!=NULL) { button_loopend->redraw();}} {}
  }
  Function {poll_callback(void* user)} {open return_type {static void}
  } {
    code {//HD24UserInterface* mythis=(HD24UserInterface*)user;
RecorderUI* mythis=(RecorderUI*)user;
int visible=0;
      if (mythis->recordergroup->visible())
      { 
	visible=1;
     } else {
        visible=0;
      }


if (mythis->control->ready()!=1) { return; }

if (mythis->dispwritecountdown>0)
{
	mythis->dispwritecountdown--;
	if (mythis->dispwritecountdown==0) {
		mythis->disprestore();
	}
}

if (mythis->busy!=1) {
	mythis->busy=1;
	mythis->blinkcounter=(mythis->blinkcounter+1)%BLINKRATE;

   if (visible==1) {
	for (unsigned int i=0;i<MAXCHANNELS;i++) {
		mythis->trackchan[i]->setval(mythis->control->data->trackpeak[i]);
	}

	Fl_Image* oldimg;
	Fl_Image* newimg=NULL;
	 
	string* dur=NULL;
               hd24song* mycurrsong=mythis->control->song();
	if (mycurrsong!=NULL) {
		dur=mycurrsong->display_cursor();
	   } else {
		dur=new string("00:00:00.00");
	   }

	   
	   oldimg=mythis->ho1->image(); 
	   mythis->ho1->image(mythis->i7seg[dur->c_str()[0]-'0']->image());
	   if (newimg!=oldimg) mythis->ho1->redraw();
	
	   oldimg=mythis->ho2->image(); 
	   mythis->ho2->image(mythis->i7seg[dur->c_str()[1]-'0']->image());
	   if (newimg!=oldimg) mythis->ho2->redraw();
	
	   oldimg=mythis->mi1->image(); 
	   mythis->mi1->image(mythis->i7seg[dur->c_str()[3]-'0']->image());
	   if (newimg!=oldimg) mythis->mi1->redraw();

	   oldimg=mythis->mi2->image(); 
	   mythis->mi2->image(mythis->i7seg[dur->c_str()[4]-'0']->image());
	   if (newimg!=oldimg) mythis->mi2->redraw();
	
	   oldimg=mythis->se1->image(); 
	   mythis->se1->image(mythis->i7seg[dur->c_str()[6]-'0']->image());
	   if (newimg!=oldimg) mythis->se1->redraw();

	   oldimg=mythis->se2->image(); 
	   mythis->se2->image(mythis->i7seg[dur->c_str()[7]-'0']->image());
	   if (newimg!=oldimg) mythis->se2->redraw();
	   oldimg=mythis->fr1->image(); 
	   mythis->fr1->image(mythis->i7seg[dur->c_str()[9]-'0']->image());
	   if (newimg!=oldimg) mythis->fr1->redraw();

	   oldimg=mythis->fr2->image(); 
	   mythis->fr2->image(mythis->i7seg[dur->c_str()[10]-'0']->image());
	   if (newimg!=oldimg) mythis->fr2->redraw();
	   if ((mythis->mustdisplaytimer) && (mycurrsong !=NULL))
	   {	
	      
	//	mythis->setstatus(*dur);
		__uint32 currloc=mycurrsong->cursorpos();
		if (mycurrsong->songlength_in_samples() >0) {
		    currloc=mycurrsong->cursorpos()/(mycurrsong->songlength_in_samples()/1000);
		} else {
		    currloc=0;
		}
		if (mythis->slidermoved!=0) {
		   mythis->slidermoved--;
		} else {
		   mythis->locationslider->value(currloc);
		}	
	   }
	   delete (dur);         
	}

}
mythis->busy=0;
//Fl::add_timeout(TIMEOUT,poll_callback,user); 

AudioSystem* audio=mythis->control->audio;

if (!audio->isinitialized()) return;
if (!audio->mustloop()) return;
audio->hd24_transport_locate((__sint64)(audio->looppos()));
audio->mustloop(false);
audio->looppos(0);} {}
  }
  Function {fl_check()} {open return_type void
  } {
    code {Fl::check();} {}
  }
  decl {int busy;} {public
  }
  decl {friend class ScrubWheel;} {}
  decl {int uiredrawcount; /* to limit refreshing UI */} {public
  }
  Function {finish()} {open return_type void
  } {
    code {if (this==NULL) return;

this->control->button_stop_call();} {}
  }
  Function {button_light(void* button,bool lit)} {open return_type void
  } {
    code {if (button==NULL) return;
if (((Fl_Image_Button*)button)==button_stop)
{
	if (lit==1)
	{
		button_stop->up_image(button_stop_uplit->image());
		button_stop->down_image(button_stop_dn->image());	
	}
	else
	{
		button_stop->up_image(button_stop_up->image());
		button_stop->down_image(button_stop_dn->image());		
	}
	button_stop->redraw();
	return;
}} {}
  }
  Function {button_up(void* button)} {open return_type void
  } {
    code {if (button==NULL)
{
	return;
}

if ((void*)button==(void*)button_stop)
{
	button_stop->value(0);
	button_stop->redraw();
	return;
}	
if ((void*)button==(void*)button_play)
{
	button_play->value(0);
	button_play->redraw();
	return;
}	
if ((void*)button==(void*)button_rec)
{
	button_rec->value(0);
	button_rec->redraw();
	return;
}	
if ((void*)button==(void*)button_rew)
{
	button_rew->value(0);
	button_rew->redraw();
	return;
}	
if ((void*)button==(void*)button_ffwd)
{
	button_ffwd->value(0);
	button_ffwd->redraw();
	return;
}} {}
  }
  Function {button_down(void* button)} {open return_type void
  } {
    code {if (button==NULL)
{
	return;
}

if ((void*)button==(void*)button_stop)
{
	button_stop->value(1);
	button_stop->redraw();
	return;
}	
if ((void*)button==(void*)button_play)
{
	button_play->value(1);
	button_play->redraw();
	return;
}	
if ((void*)button==(void*)button_rec)
{
	button_rec->value(1);
	button_rec->redraw();
	return;
}	
if ((void*)button==(void*)button_rew)
{
	button_rew->value(1);
	button_rew->redraw();
	return;
}	
if ((void*)button==(void*)button_ffwd)
{
	button_ffwd->value(1);
	button_ffwd->redraw();
	return;
}} {}
  }
}