3 files changed, 40 insertions, 44 deletions

diff --git a/noncore/multimedia/opierec/qtrec.cpp b/noncore/multimedia/opierec/qtrec.cpp
index 9b761aa..9d3d5cf 100644
--- a/noncore/multimedia/opierec/qtrec.cpp
+++ b/noncore/multimedia/opierec/qtrec.cpp
@@ -627,876 +627,863 @@ void QtRec::init() {
                 QHBoxLayout *Layout19a;
                 Layout19a = new QHBoxLayout( tab_5);
                 Layout19a->setSpacing( 2 );
                 Layout19a->setMargin( 0 );
 
                 Layout15 = new QVBoxLayout( this);
                 Layout15->setSpacing( 2 );
                 Layout15->setMargin( 0 );
 
                 Layout15b = new QVBoxLayout( this);
                 Layout15b->setSpacing( 2 );
                 Layout15b->setMargin( 0 );
 
                 TextLabel2 = new QLabel( tab_5, "InputLabel" );
                 TextLabel2->setText( tr( "In"));
                 TextLabel2->setFixedWidth( 35);
                 Layout15->addWidget( TextLabel2 );
 
                 TextLabel3 = new QLabel( tab_5, "OutputLabel" );
                 TextLabel3->setText( tr( "Out" ) );
                 Layout15b->addWidget( TextLabel3 );
 
                 InputSlider = new QSlider( -100, 0, 10, 0, QSlider::Vertical, tab_5, (const char *) "InputSlider" );
                 InputSlider->setTickmarks( QSlider::Both);
                 Layout15->addWidget( InputSlider);
 
                 OutputSlider = new QSlider( -100,0,10,0, QSlider::Vertical,tab_5,(const char *) "OutputSlider" );
                 OutputSlider->setTickmarks( QSlider::Both);
 
                 Layout15b->addWidget( OutputSlider );
 
                 outMuteCheckBox = new QCheckBox ( tr("mute"), tab_5 );
                 Layout15->addWidget( outMuteCheckBox );
 
                 inMuteCheckBox = new QCheckBox ( tr("mute"), tab_5 );
                 inMuteCheckBox-> setFocusPolicy ( QWidget::NoFocus );
                 Layout15b->addWidget( inMuteCheckBox );
 
 
                 Layout19a->addLayout( Layout15 );
                 Layout19a->addLayout( Layout15b );
 
                 fillDirectoryCombo();
 
                 TabWidget->insertTab( tab_3, tr( "Options" ) );
 
                 TabWidget->insertTab( tab_5, tr( "Volume" ) );
 
                 waveform = new Waveform( this, "waveform" );
                 waveform->setMinimumSize( QSize( 0, 50 ) );
 
                 layout->addMultiCellWidget( waveform, 8, 8, 0, 8);
                 waveform->setBackgroundColor ( black );
 }
 
 void QtRec::initIconView() {
                 ListView1->clear();
                 Config cfg("OpieRec");
                 cfg.setGroup("Sounds");
                 QString temp;
                 QPixmap image0( ( const char** ) image0_data );
 
                 int nFiles = cfg.readNumEntry("NumberofFiles",0);
 //    owarn << "init number of files " << nFiles << "" << oendl;
 
                 for(int i = 1; i <= nFiles; i++) {
 
                                 QListViewItem * item;
                                 QString fileS, mediaLocation, fileDate,  filePath;
 
                                 temp.sprintf( "%d",i);
                                 temp = cfg.readEntry( temp,""); //reads currentFile
                                 filePath = cfg.readEntry( temp,""); //currentFileName
 
                                 QFileInfo info(filePath);
                                 fileDate = info.lastModified().toString();
 
                                 fileS = cfg.readEntry( filePath, "0" );// file length in seconds
                                 mediaLocation = getStorage( filePath);
                                 if( info.exists()) {
         //                                      owarn << "new item " << temp << oendl;
                                                 item = new QListViewItem( ListView1, temp,  fileS /*,  mediaLocation, fileDate*/);
                                                 item->setPixmap( 0, image0);
                                                 if( currentFileName == filePath)
                                                                 ListView1->setSelected( item, true);
                                 }
                 }
 }
 
 void QtRec::initConnections() {
                 connect(qApp,SIGNAL(aboutToQuit()),SLOT(cleanUp()));
 
                 connect(toBeginningButton,SIGNAL(pressed()),this,SLOT(rewindPressed()));
                 connect(toBeginningButton,SIGNAL(released()),this,SLOT(rewindReleased()));
                 connect(toEndButton,SIGNAL(pressed()),this,SLOT(FastforwardPressed()));
                 connect(toEndButton,SIGNAL(released()),this,SLOT(FastforwardReleased()));
+
                 connect(deleteSoundButton,SIGNAL(released()),this,SLOT(deleteSound()));
+
                 connect(Stop_PushButton,SIGNAL(released()),this,SLOT(doPlayBtn()));
+        //      connect(Stop_PushButton,SIGNAL(released()),this,SLOT(doPlayBtn()));
+
+        //      connect(Rec_PushButton,SIGNAL(released()),this,SIGNAL(startRecording()));
                 connect(Rec_PushButton,SIGNAL(released()),this,SLOT(newSound()));
 
                 connect(TabWidget,SIGNAL(currentChanged(QWidget*)),this,SLOT(thisTab(QWidget*)));
 
                 connect(OutputSlider,SIGNAL(sliderReleased()),this,SLOT(changedOutVolume()));
                 connect(InputSlider,SIGNAL(sliderReleased()),this,SLOT(changedInVolume()));
 
                 connect(sampleRateComboBox,SIGNAL(activated(int)),this,SLOT(changesamplerateCombo(int)));
                 connect(bitRateComboBox,SIGNAL(activated(int)),this,SLOT(changebitrateCombo(int)));
                 connect(directoryComboBox,SIGNAL(activated(int)),this,SLOT(changeDirCombo(int)));
                 connect(sizeLimitCombo,SIGNAL(activated(int)),this,SLOT(changeSizeLimitCombo(int)));
 
                 connect(stereoCheckBox,SIGNAL(toggled(bool)),this,SLOT(changeStereoCheck(bool)));
                 connect(outMuteCheckBox,SIGNAL(toggled(bool)),this,SLOT(doVolMuting(bool)));
                 connect(inMuteCheckBox,SIGNAL(toggled(bool)),this,SLOT(doMicMuting(bool)));
 
                 connect(ListView1,SIGNAL(doubleClicked(QListViewItem*)),this,SLOT(itClick(QListViewItem*)));
                 connect(ListView1,SIGNAL(mouseButtonPressed(int,QListViewItem*,const QPoint&,int)),this,SLOT(listPressed(int,QListViewItem*,const QPoint&,int)));
 
                 connect(timeSlider,SIGNAL(sliderMoved(int)),this,SLOT(changeTimeSlider(int)));
                 connect(timeSlider,SIGNAL(sliderPressed()),this,SLOT(timeSliderPressed()));
                 connect(timeSlider,SIGNAL(sliderReleased()),this,SLOT(timeSliderReleased()));
 
                 connect(compressionCheckBox,SIGNAL(toggled(bool)),this,SLOT(compressionSelected(bool)));
                 connect(autoMuteCheckBox,SIGNAL(toggled(bool)),this,SLOT(slotAutoMute(bool)));
 }
 
 void QtRec::initConfig() {
                 int index, fred, i;
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
 
                 index = cfg.readNumEntry("samplerate",22050);
                 bool ok;
 
                 for(int ws=0;ws<sampleRateComboBox->count();ws++) {
                                 fred = sampleRateComboBox->text(ws).toInt(&ok, 10);
                                 if( index == fred) {
                                                 filePara.sampleRate  = fred;
                                                 sampleRateComboBox->setCurrentItem(ws);
                                 }
                 }
 
                 i = cfg.readNumEntry("bitrate",16);
                 if(i == 16)
                                 bitRateComboBox->setCurrentItem( 1);
                 else    if(i == 24)
                                 bitRateComboBox->setCurrentItem( 2);
                 else    if(i == 32)
                                 bitRateComboBox->setCurrentItem( 3);
                 else
                                 bitRateComboBox->setCurrentItem( 0);
 
                 filePara.resolution = i;
 
                 i = cfg.readNumEntry("sizeLimit", 5 );
                 QString temp;
                 sizeLimitCombo->setCurrentItem((i/5));
 
                 stereoCheckBox->setChecked( cfg.readBoolEntry("stereo", 1));
                 if( stereoCheckBox->isChecked()) {
                                 filePara.channels = 2;
                 } else {
                                 filePara.channels = 1;
                 }
 
                 compressionCheckBox->setChecked( cfg.readBoolEntry("wavCompression",1));
                 if( compressionCheckBox->isChecked()) {
                                 bitRateComboBox->setCurrentItem(1);
                                 bitRateComboBox->setEnabled(false);
                                 filePara.resolution=16;
                 }
 
                 autoMuteCheckBox->setChecked( cfg.readBoolEntry("useAutoMute",0));
                 if( autoMuteCheckBox->isChecked())
                                 slotAutoMute(true);
                 else
                                 slotAutoMute(false);
 
                 Config cofg( "qpe");
                 cofg.setGroup( "Volume");
                 outMuteCheckBox->setChecked( cofg.readBoolEntry( "Mute",0));
                 inMuteCheckBox->setChecked( cofg.readBoolEntry( "MicMute",0));
 }
 
 void QtRec::stop() {
         //      owarn << "STOP" << oendl;
                 setRecordButton(false);
 
-                if( !recording)
+                if( !recording) {
+                                emit stopPlaying();
                                 endPlaying();
-                else
+                } else {
+                                emit stopRecording();
                                 endRecording();
+                }
                 timeSlider->setValue(0);
 }
 
 void QtRec::doPlayBtn() {
 
                 if(!stopped) {
         //                      playLabel2->setText(tr("Play"));
                                 stop();
                 } else {
                                 if(ListView1->currentItem() == 0) return;
         //                      playLabel2->setText(tr("Stop"));
                                 currentFile = ListView1->currentItem()->text(0);
                                 start();
                 }
 }
 
 void QtRec::start() { //play
                 if( stopped) {
                                 QPixmap image3( ( const char** ) image3_data );
                                 Stop_PushButton->setPixmap( image3 );
                                 Stop_PushButton->setDown( true);
                                 stopped = false;
                                 paused = false;
                                 secCount = 1;
 
                                 if( openPlayFile())
                                                 if( setupAudio( false))  //recording is false
                                                                 doPlay();
                 }
 }
 
 bool QtRec::rec() { //record
                 QString timeString;
                 timeString.sprintf("%.0f",  0.0);
         //      timeLabel->setText( timeString+ " seconds");
                 if(!stopped) {
                                 monitoring = true;
                                 return false;
                 } else {
                                 secCount = 1;
         //                      playLabel2->setText(tr("Stop"));
                                 monitoring = false;
                                 setRecordButton( true);
 
                                 if( setupAudio( true))
                                                 if(setUpFile())  {
                                                                 int fileSize = 0;
                                                                 Config cfg("OpieRec");
                                                                 cfg.setGroup("Settings");
-//             odebug << "<<<<<<<Device bits " << soundDevice->getDeviceBits()
-//                    << ", device rate " << soundDevice->getDeviceRate()
-//                    << ", device channels " << soundDevice->getDeviceChannels() << oendl;
-
-                                                                        //filePara.sampleRate = cfg.readNumEntry("samplerate", 22050);
-//             odebug << "sample rate is " << filePara.sampleRate << "" << oendl;
                                                                 filePara.SecondsToRecord = getCurrentSizeLimit();
-
-//             odebug << "size limit " << filePara.SecondsToRecord << " sec" << oendl;
                                                                 int diskSize = checkDiskSpace( (const QString &) wavFile->trackName());
 
                                                                 if( filePara.SecondsToRecord == 0) {
                                                                                 fileSize = diskSize;
                                                                 } else if( filePara.format == WAVE_FORMAT_PCM) {
 //                odebug << "WAVE_FORMAT_PCM" << oendl;
                                                                                 fileSize = (filePara.SecondsToRecord ) * filePara.channels
                                                                                                 * filePara.sampleRate * ( filePara.resolution / 8) + 1000;
                                                                 } else {
 //                odebug << "WAVE_FORMAT_DVI_ADPCM" << oendl;
                                                                                 fileSize = ((filePara.SecondsToRecord) * filePara.channels
                                                                                                                                 * filePara.sampleRate * ( filePara.resolution / 8) ) / 4 + 250;
                                                                 }
 
                                                                 filePara.samplesToRecord = fileSize;
                                                                 odebug << "filesize should be " << filePara.samplesToRecord
                                                                                          << ", bits " << filePara.resolution << ", rate " << filePara.sampleRate;
                                                                 if( paused) {
                                                                                 paused = false;
                                                                 }
                                                                         //                  else {
                                                                 odebug << "Setting timeslider " << filePara.samplesToRecord << "" << oendl;
                                                                         //           if(fileSize != 0)
                                                                 timeSlider->setRange(0, filePara.samplesToRecord);
                                                                         //                  }
 
                                                                 if( diskSize < fileSize/1024) {
                                                                                 QMessageBox::warning(this,
                                                                                                                                                                  tr("Low Disk Space"),
                                                                                                                                                                  tr("You are running low of\nrecording space\n"
                                                                                                                                                                                 "or a card isn't being recognized"));
                                                                                 stopped = true; //we need to be stopped
                                                                                 stop();
                                                                 } else {
                                                                                 QString msg;
                                                                                 msg.sprintf("%d, %d, %d", filePara.sampleRate, filePara.channels, filePara.resolution);
 #ifdef DEV_VERSION
                                                                                 setCaption( msg);
 #endif
                                                                                 filePara.fileName=currentFile.latin1();
                                                                                 odebug << "Start recording" << oendl;
                                                                                 stopped = false;
 
 #ifdef THREADED
                                                                                 odebug << "Start recording thread" << oendl;
                                                                                 pthread_t thread1;
                                                                                 pthread_create( &thread1, NULL, (void * (*)(void *))quickRec, NULL/* &*/);
 #endif
                                                                                 toBeginningButton->setEnabled( false);
                                                                                 toEndButton->setEnabled( false);
 
                                                                                 startTimer(1000);
 #ifndef THREADED
                                                                                 quickRec();
 #endif
                                                                 }
                                                 } //end setUpFile
                 } //end setupAudio
                 return true;
 }
 /*
   This happens when a tab is selected*/
 void QtRec::thisTab(QWidget* widg) {
                 if(widg != NULL) {
                                 int index = TabWidget->currentPageIndex();
 
                                 if(index == 0) { //file page
                                 }
 
                                 if(index == 1) { //control page
                                                 fillDirectoryCombo();
 //       soundDevice->getOutVol();
 //       soundDevice->getInVol();
                                 }
 
                                 if( index==2) { //help page
                                 }
 
                                 qApp->processEvents();
                                 update();
                 }
 }
 
 void QtRec::getOutVol( ) {
                 filePara.outVol = soundDevice->getOutVolume();
 //   odebug << "out vol " << filePara.outVol << "" << oendl;
                 OutputSlider->setValue( -filePara.outVol);
 }
 
 void QtRec::getInVol() {
                 filePara.inVol = soundDevice->getInVolume();
 //    odebug << "in vol " << filePara.inVol << "" << oendl;
                 InputSlider->setValue( -filePara.inVol);
 }
 
 void QtRec::changedOutVolume() {
                 soundDevice->changedOutVolume( -OutputSlider->value());
 }
 
 void QtRec::changedInVolume( ) {
                 soundDevice->changedInVolume( -InputSlider->value());
 }
 
 
 bool QtRec::setupAudio( bool b) {
                 bool ok;
                 int  sampleformat, stereo, flags;
                 QString dspString, mixerString;
 
                 filePara.resolution = bitRateComboBox->currentText().toInt( &ok,10);  //16
 
                 if( !b) {
 // we want to play
 #ifdef PDAUDIO //ALSA
                                 if( filePara.resolution == 16 || compressionCheckBox->isChecked() ) {
                                                 sampleformat = SND_PCM_FORMAT_S16;
                                                 filePara.resolution = 16;
                                 } else if( filePara.resolution == 24 || compressionCheckBox->isChecked() ) {
                                                 sampleformat = SND_PCM_FORMAT_S24;
                                                 filePara.resolution = 24;
                                 } else if( filePara.resolution == 32 || compressionCheckBox->isChecked() ) {
                                                 sampleformat = SND_PCM_FORMAT_S32;
                                                 filePara.resolution = 32;
                                 } else {
                                                 sampleformat = SND_PCM_FORMAT_U8;
                                                 filePara.resolution = 8;
                                 }
 #else
 // we want to play
                                 if( filePara.resolution == 16 || compressionCheckBox->isChecked() ) {
                                                 sampleformat = AFMT_S16_LE;
                                                 filePara.resolution = 16;
                                 } else {
                                                 sampleformat = AFMT_U8;
                                                 filePara.resolution = 8;
                                 }
 #endif
 
                                 stereo = filePara.channels;
                                 flags = O_WRONLY;
                                 recording = false;
                 } else { // we want to record
 
 #ifdef PDAUDIO //ALSA
                                 if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "16")
                                                 sampleformat = SND_PCM_FORMAT_S16;
                                 else if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "24")
                                                 sampleformat = SND_PCM_FORMAT_S24;
                                 else if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "32")
                                                 sampleformat = SND_PCM_FORMAT_S32;
                                 else
                                                 sampleformat = SND_PCM_FORMAT_U8;
 
 #else
                                 if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "16")
                                                 sampleformat = AFMT_S16_LE;
                                 else
                                                 sampleformat = AFMT_U8;
 
                                 if( !compressionCheckBox->isChecked()) {
                                                 filePara.format = WAVE_FORMAT_PCM;
 //          odebug << "WAVE_FORMAT_PCM" << oendl;
                                 }  else {
                                                 filePara.format = WAVE_FORMAT_DVI_ADPCM;
                                                 sampleformat = AFMT_S16_LE;
 //          odebug << "WAVE_FORMAT_DVI_ADPCM" << oendl;
                                 }
 #endif
 
                                 stereo = filePara.channels;
 //        filePara.sampleRate = sampleRateComboBox->currentText().toInt( &ok,10);//44100;
                                 flags= O_RDWR;
 //        flags= O_RDONLY;
                                 recording = true;
                 }
-
-                        // if(soundDevice) delete soundDevice;
+                
                 owarn << "<<<<<<<<<<<<<<<<<<<open dsp " << filePara.sampleRate << " " << filePara.channels << " " << sampleformat << "" << oendl;
         //      owarn << "change waveform settings" << oendl;
                 waveform->changeSettings( filePara.sampleRate, filePara.channels );
 
                 soundDevice = new Device( this, b); //open rec
 //    soundDevice->openDsp();
                 soundDevice->reset();
 
                 odebug << "device has been made " << soundDevice->sd << "" << oendl;
 
                         //////////////////         <<<<<<<<<<<<>>>>>>>>>>>>
                 soundDevice->setDeviceFormat( sampleformat);
                 soundDevice->setDeviceChannels( filePara.channels);
                 soundDevice->setDeviceRate( filePara.sampleRate);
                 soundDevice->getDeviceFragSize();
 #ifdef QT_QWS_EBX
                 int frag = FRAGSIZE;
                 soundDevice->setFragSize( frag);
                 soundDevice->getDeviceFragSize();
 #endif
                         /////////////////
                 filePara.sd = soundDevice->sd;
 
                 if ( filePara.sd == -1) {
 
                                 monitoring = false;
                                 stopped = true;
                                 update();
                                 setCaption( tr( "OpieRecord " )+ QString::number(VERSION) );
                                 return false;
                 }
                 if(autoMute)
                                 doMute(false);
 
                 return true;
 }
 
 
 bool QtRec::setUpFile() { //setup file for recording
-//    odebug << "Setting up wavfile" << oendl;
-//  if(wavFile) delete wavFile;
                 wavFile = new WavFile( this, (const QString &)"",
                                                                                                          true,
                                                                                                          filePara.sampleRate,
                                                                                                          filePara.channels,
                                                                                                          filePara.resolution,
                                                                                                          filePara.format);
 
                 filePara.fd = wavFile->wavHandle();
                 if(filePara.fd == -1) {
                                 return false;
                 } else {
-//      filePara.channels=1;
                 }
                 return true;
 }
 
 /// <<<<<<<<<<<<<<<<  PLAY >>>>>>>>>>>>>>>>>>>
 bool QtRec::doPlay() {
 
                 if( !paused) {
                                 total = 0;
                                 filePara.numberOfRecordedSeconds = 0;
                 } else {
                                 paused = false;
                                 secCount = (int)filePara.numberOfRecordedSeconds;
                 }
                 playing = true;
                 stopped = false;
                 recording = false;
 
                 QString num;
                 odebug << "Play number of samples " << filePara.numberSamples << "" << oendl;
 
 //   timeSlider->setRange( 0, filePara.numberSamples);
 
                 timeString.sprintf("%f",  filePara.numberOfRecordedSeconds);
         //      timeLabel->setText( timeString+ tr(" seconds"));
 
                 QString msg;
                 msg.sprintf("%d, %d, %d",
                                                                 filePara.sampleRate,
                                                                 filePara.channels,
                                                                 filePara.resolution);
 #ifdef DEV_VERSION
                 setCaption( msg);
 #endif
 
                 startTimer( 1000);
 #ifdef THREADED
                 pthread_t thread2;
                 pthread_create( &thread2, NULL, (void * (*)(void *))playIt, NULL/* &*/);
 #endif
 
                 toBeginningButton->setEnabled( false);
                 toEndButton->setEnabled( false);
 #ifndef  THREADED
                 playIt();
 #endif
                 return true;
 }
 
 
 void QtRec::changebitrateCombo(int i) {
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 int bits = 0;
                 if( i == 1) { bits = 16; }
                 else if( i == 2) { bits = 24; }
                 else if( i == 3) { bits = 32; }
                 else { bits=8; }
                 cfg.writeEntry("bitrate", bits);
                 filePara.resolution = bits;
                 cfg.write();
 }
 
 void QtRec::changesamplerateCombo(int i) {
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 int rate=0;
                 bool ok;
                 rate = sampleRateComboBox->text(i).toInt(&ok, 10);
                 cfg.writeEntry( "samplerate",rate);
                 filePara.sampleRate=rate;
                 odebug << "Change sample rate " << rate << "" << oendl;
                 cfg.write();
 }
 
 
 void QtRec::changeDirCombo(int index) {
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 QString sName = directoryComboBox->text(index);
 
                 StorageInfo storageInfo;
                 const QList<FileSystem> &fs = storageInfo.fileSystems();
                 QListIterator<FileSystem> it ( fs );
                 QString storage;
                 for( ; it.current(); ++it ){
                                 if( sName == (*it)->name()+" "+  (*it)->path() ||
                                                 (*it)->name() == sName ) {
                                                 const QString path = (*it)->path();
                                                 recDir = path;
                                                 cfg.writeEntry("directory", recDir);
                                                 odebug << "new rec dir "+recDir << oendl;
                                 }
                 }
                 cfg.write();
 }
 
 
 void QtRec::changeSizeLimitCombo(int) {
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 cfg.writeEntry("sizeLimit", getCurrentSizeLimit() );
                 cfg.write();
 }
 
 void QtRec::newSound() {
                 if( !rec()) {
                                 endRecording();
                                 deleteSound();
                 }
 }
 
 void QtRec::itClick(QListViewItem *item) {
                 currentFile = item->text(0);
                 setCaption("OpieRecord  "+currentFile);
 }
 
 void QtRec::deleteSound() {
                 Config cfg("OpieRec");
                 cfg.setGroup("Sounds");
                 if( ListView1->currentItem() == NULL)
                                 return;
-// #ifndef DEV_VERSION
-        //      switch ( QMessageBox::warning(this,tr("Delete"),
-        //                                                                                                                              tr("Do you really want to <font size=+2><B>DELETE</B></font>\nthe selected file?"),
-        //                                                                                                                              tr("Yes"),tr("No"),0,1,1) ) {
-        //              case 0:
-// #endif
-                                //      {
                 QString file = ListView1->currentItem()->text(0);
                 QString fileName;
                 fileName = cfg.readEntry( file, "");
                 QFile f( fileName);
                 if( f.exists())
                                 if( !f.remove())
                                                 QMessageBox::message( tr("Error"), tr("Could not remove file."));
 
                 int nFiles = cfg.readNumEntry( "NumberofFiles",0);
                 bool found = false;
                 for(int i=0;i<nFiles+1;i++) {
 
                                 if( cfg.readEntry( QString::number(i),"").find( file,0,true) != -1) {
                                                 found = true;
                                                 cfg.writeEntry( QString::number(i), cfg.readEntry( QString::number(i+1),""));
                                 }
                                 if(found)
                                                 cfg.writeEntry( QString::number(i), cfg.readEntry( QString::number(i+1),""));
                 }
 
                 cfg.removeEntry( cfg.readEntry( file));
                 cfg.removeEntry( file);
                 cfg.writeEntry( "NumberofFiles", nFiles-1);
                 cfg.write();
 
                 ListView1->takeItem( ListView1->currentItem() );
                 delete ListView1->currentItem();
 
                 ListView1->clear();
                 ListView1->setSelected( ListView1->firstChild(), true);
                 initIconView();
                 update();
                 setCaption( tr( "OpieRecord " ));
 }
 
 void QtRec::keyPressEvent( QKeyEvent *e) {
 
                 switch ( e->key() ) {
                                         //  case Key_F1:
                                         //     if(stopped && !recording)
                                         //       newSound();
                                         //     else
                                         //       stop();
                                         //    break;
                                         //   case Key_F2: {
                                         //     if( !e->isAutoRepeat())
                                         //     rewindPressed();
                                         //   }
                                         //     break;
                                         //   case Key_F3: {
                                         //     if( !e->isAutoRepeat())
                                         //     FastforwardPressed();
                                         //   }
                                         //     break;
 
                                         ////////////////////////////// Zaurus keys
                         case Key_F9: //activity
                                         break;
                         case Key_F10: //contacts
                                         break;
                         case Key_F11: //menu
                                         break;
                         case Key_F12: //home
                                         break;
                         case Key_F13: //mail
                                         break;
                         case Key_Space:
                                         break;
                         case Key_Delete:
                                         break;
                         case Key_Up:
                                                 //    stop();
                                         break;
                         case Key_Down:
                                                 //    newSound();
                                         break;
                         case Key_Left: {
                                         odebug << "rewinding" << oendl;
                                         if( !e->isAutoRepeat())
                                                         rewindPressed();
                         }
                                         break;
                         case Key_Right: {
                                         if( !e->isAutoRepeat())
                                                         FastforwardPressed();
                         }
                                         break;
                 }
 }
 
 void  QtRec::keyReleaseEvent( QKeyEvent *e) {
                 switch ( e->key() ) {
                                         //   case Key_F1:
                                         //      if(stopped && !recording)
                                         //        newSound();
                                         //      else
                                         //        stop();
                                         //     break;
                                         //   case Key_F2:
                                         //     rewindReleased();
                                         //     break;
                                         //   case Key_F3:
                                         //     FastforwardReleased();
                                         //     break;
 
                                         ////////////////////////////// Zaurus keys
                         case Key_F9: //activity
                                         break;
                         case Key_F10: //contacts
                                         break;
                         case Key_F11: //menu
                                         break;
                         case Key_F12: //home
                                         if(stopped)
                                                         doPlayBtn();
                                         else
                                                         stop();
                                         break;
                         case Key_F13: //mail
                                         break;
                         case Key_Space:
                                         if(stopped && !recording)
                                                         newSound();
                                         else
                                                         stop();
                                         break;
                         case Key_Delete:
                                         deleteSound();
                                         break;
                         case Key_Up:
                                                 //      stop();
                                         odebug << "Up" << oendl;
                                         break;
                         case Key_Down:
                                                 //      start();
                                                 //      odebug << "Down" << oendl;
                                                 //    newSound();
                                         break;
                         case Key_Left:
                                         odebug << "Left" << oendl;
                                         rewindReleased();
                                         break;
                         case Key_Right:
                                         odebug << "Right" << oendl;
                                         FastforwardReleased();
                                         break;
                 }
 }
 
 void QtRec::endRecording() {
                 
                 monitoring = false;
                 recording = false;
                 stopped = true;
                 waveform->reset();
                 setRecordButton( false);
 
                 toBeginningButton->setEnabled( true);
                 toEndButton->setEnabled( true);
 
                 killTimers();
 
                 if(autoMute)
                                 doMute( true);
 
                 soundDevice->closeDevice( true);
 
                 if( wavFile->track.isOpen()) {
                                 wavFile->adjustHeaders( filePara.fd, filePara.numberSamples);
-                                        //    soundDevice->sd=-1;
                                 filePara.numberSamples = 0;
-                                        //      filePara.sd=-1;
                                 wavFile->closeFile();
                                 filePara.fd=0;
 
                                 if( wavFile->isTempFile()) {
 // move tmp file to regular file
                                                 QString cmd;
                                                 cmd.sprintf("mv "+ wavFile->trackName() + " " + wavFile->currentFileName);
                                                 odebug << "moving tmp file to "+currentFileName << oendl;
                                                 system( cmd.latin1());
                                 }
 
                                 odebug << "Just moved " + wavFile->currentFileName << oendl;
                                 Config cfg("OpieRec");
                                 cfg.setGroup("Sounds");
 
                                 int nFiles = cfg.readNumEntry( "NumberofFiles",0);
 
                                 currentFile = QFileInfo( wavFile->currentFileName).fileName();
                                 currentFile = currentFile.left( currentFile.length() - 4);
 
                                 cfg.writeEntry( "NumberofFiles", nFiles + 1);
                                 cfg.writeEntry( QString::number( nFiles + 1), currentFile);
                                 cfg.writeEntry( currentFile, wavFile->currentFileName);
 
                                 QString time;
                                 time.sprintf("%.2f", filePara.numberOfRecordedSeconds);
                                 cfg.writeEntry( wavFile->currentFileName, time );
                                 odebug << "writing config numberOfRecordedSeconds "+time << oendl;
 
                                 cfg.write();
                                 odebug << "finished recording" << oendl;
         //                      timeLabel->setText("");
                 }
 
 //      if(soundDevice) delete soundDevice;
 
                 timeSlider->setValue(0);
                 initIconView();
                 selectItemByName( currentFile);
                 setCaption( tr( "OpieRecord " ));
                 
 }
 
 void QtRec::endPlaying() {
                 monitoring = false;
                 recording = false;
                 playing = false;
                 stopped = true;
                 waveform->reset();
 //   errorStop();
     odebug << "end playing" << oendl;
                 setRecordButton( false);
 
                 toBeginningButton->setEnabled( true);
                 toEndButton->setEnabled( true);
 
                 if(autoMute)
                                 doMute( true);
 
                 soundDevice->closeDevice( false);
                 soundDevice->sd = -1;
                         //  if(soundDevice) delete soundDevice;
     odebug << "file and sound device closed" << oendl;
         //      timeLabel->setText("");
                 total = 0;
                 filePara.numberSamples = 0;
                 filePara.sd = -1;
 //   wavFile->closeFile();
                 filePara.fd = 0;
 //  if(wavFile) delete wavFile; //this crashes
 
     odebug << "track closed" << oendl;
                 killTimers();
         //      owarn << "reset slider" << oendl;
                 timeSlider->setValue(0);
 
 //      if(soundDevice) delete soundDevice;
 
 }
 
 bool QtRec::openPlayFile() {
                 qWarning("opening file");
                 qApp->processEvents();
                 if( currentFile.isEmpty()) {
                                 QMessageBox::message(tr("Opierec"),tr("Please select file to play"));
                                 endPlaying();
                                 return false;
                 }
                 QString currentFileName;
                 Config cfg("OpieRec");
                 cfg.setGroup("Sounds");
                 int nFiles = cfg.readNumEntry( "NumberofFiles", 0);
                 for(int i=0;i<nFiles+1;i++) { //look for file
                                 if( cfg.readEntry( QString::number(i),"").find( currentFile,0,true) != -1) {
                                                 currentFileName = cfg.readEntry( currentFile, "" );
                                                 odebug << "opening for play: " + currentFileName << oendl;
diff --git a/noncore/multimedia/opierec/qtrec.h b/noncore/multimedia/opierec/qtrec.h
index 642048a..6e81af6 100644
--- a/noncore/multimedia/opierec/qtrec.h
+++ b/noncore/multimedia/opierec/qtrec.h
@@ -1,187 +1,196 @@
 /****************************************************************************
  ** Created: Thu Jan 17 11:19:45 2002
 copyright 2002 by L.J. Potter ljp@llornkcor.com
 ****************************************************************************/
 #ifndef QTREC_H
 #define QTREC_H
 #define VERSION 20040628
 
 #include <qpe/ir.h>
 
 #include <qfile.h>
 #include <qimage.h>
 #include <qlineedit.h>
 #include <qpixmap.h>
 #include <qvariant.h>
 #include <qwidget.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "device.h"
 #include "wavFile.h"
 
 class QButtonGroup;
 class QCheckBox;
 class QComboBox;
 class QGridLayout; 
 class QGroupBox;
 class QHBoxLayout; 
 class QIconView;
 class QIconViewItem;
 class QLabel;
 class QLabel;
 class QListView;
 class QListViewItem;
 class QPushButton;
 class QSlider;
 class QTabWidget;
 class QTimer;
 class QVBoxLayout; 
 class QLineEdit;
 
 #define MAX_TRACKS 2
 //#define BUFSIZE 4096
 // #define BUFSIZE 8182 //Z default buffer size
 #define BUFSIZE 1024
 //#define BUFSIZE 2048
 #define FRAGSIZE 0x7fff000A;
 
 #define WAVE_FORMAT_DVI_ADPCM (0x0011)
 #define WAVE_FORMAT_PCM (0x0001)
 //AFMT_IMA_ADPCM
 
 class QtRec : public QWidget
 { 
    Q_OBJECT
 
 public:
     static QString appName() { return QString::fromLatin1("opierec"); }
    QtRec( QWidget* parent=0, const char* name=0, WFlags fl=0 );
    ~QtRec();
    QSlider *OutputSlider,*InputSlider;
 
+signals:
+         void stopRecording();
+         void startRecording();
+         void stopPlaying();
+         void startPlaying();
+
 public slots:
+
 private:
 //    int fragment;
    int fd1;
    int secCount;
    QString timeString; 
 
    QLineEdit *renameBox;
    QGroupBox* GroupBox1;
    QString currentFile;
    QString date, currentFileName, tmpFileName;
    QTimer *t_timer;
    bool needsStereoOut, paused;
    bool useTmpFile, autoMute;
 
    bool eventFilter( QObject * , QEvent * );
    void okRename();
    void cancelRename();
    QString getStorage(const QString &);
    bool rec();
    int getCurrentSizeLimit();
    long checkDiskSpace(const QString &);
    void doMute(bool);
    void errorStop();
    void fillDirectoryCombo();
    void getInVol();
    void getOutVol();
    void init();
    void initConfig();
    void initConnections();
    void selectItemByName(const QString &);
    void setRecordButton(bool);
    void start();
    void stop();
    void timerEvent( QTimerEvent *e );
     
 private slots:
+   void endPlaying();
+   void endRecording();
 
    void FastforwardPressed();
    void FastforwardReleased();
+
    void changeDirCombo(int);
    void changeSizeLimitCombo(int);
    void changeTimeSlider(int);
    void changebitrateCombo(int);
    void changeStereoCheck( bool);
 
    void changedInVolume();
    void changedOutVolume();
    void changesamplerateCombo(int);
+
    void cleanUp();
    void compressionSelected(bool);
    void deleteSound();
    void doBeam();
    void doMenuPlay();  
    void doMicMuting(bool);
    void doPlayBtn();
    void doRename();
    void doVolMuting(bool); 
    void forwardTimerTimeout();
    void itClick(QListViewItem *item);
    void listPressed(int, QListViewItem *, const QPoint&, int);
    void newSound();
    void rewindPressed();
    void rewindReleased();
    void rewindTimerTimeout();
    void slotAutoMute(bool);
    void thisTab(QWidget*);
    void timeSliderPressed();
    void timeSliderReleased();
    void timerBreak();
    void initIconView();
 /*     void changedOutVolume(int); */
 /*    void changedInVolume(int); */
 
 protected:
 
    WavFile *wavFile;
    QButtonGroup *ButtonGroup1;
    QCheckBox *outMuteCheckBox, *inMuteCheckBox, *compressionCheckBox, *autoMuteCheckBox, *stereoCheckBox;
    QComboBox* sampleRateComboBox, * bitRateComboBox, *directoryComboBox, *sizeLimitCombo;
    QHBoxLayout* Layout12;
    QHBoxLayout* Layout13;
    QHBoxLayout* Layout14;
    QHBoxLayout* Layout16;
    QHBoxLayout* Layout17;
    QHBoxLayout* Layout19;
    QIconView *IconView1;
    QLabel *NewSoundLabel,*playLabel2;
    QLabel *TextLabel3, *TextLabel1, *TextLabel2;
    QListView *ListView1;
    QPushButton *Stop_PushButton, *Play_PushButton, *Rec_PushButton,  *NewSoundButton, *deleteSoundButton, *toBeginningButton, *toEndButton;
    QString recDir;
    QTabWidget *TabWidget;
    QTimer *t, *rewindTimer, *forwardTimer;
    QVBoxLayout* Layout15;
    QVBoxLayout* Layout15b;
    QVBoxLayout* Layout18;
    QWidget *tab, *tab_2, *tab_3, *tab_4, *tab_5;
    int sliderPos, total;
 //    short inbuffer[BUFSIZE], outbuffer[BUFSIZE];
 //    unsigned short unsigned_inbuffer[BUFSIZE], unsigned_outbuffer[BUFSIZE];
    QGroupBox *sampleGroup, *bitGroup, *dirGroup, *sizeGroup;
 /*     short inbuffer[65536], outbuffer[65536]; */
 /*     unsigned short unsigned_inbuffer[65536], unsigned_outbuffer[65536]; */
 
 
    bool doPlay();
    bool openPlayFile();
    bool setUpFile();
    bool setupAudio( bool b);
-   void endPlaying();
-   void endRecording();
    void fileBeamFinished( Ir *ir);
    void keyPressEvent( QKeyEvent *e);
    void keyReleaseEvent( QKeyEvent *e);
    void receive( const QCString &, const QByteArray & );
    void showListMenu(QListViewItem * );
 #ifndef THREADED
    void quickRec();
          void playIt();
 #endif
          
 };
 
 #endif // QTREC_H
diff --git a/noncore/multimedia/opierec/wavFile.cpp b/noncore/multimedia/opierec/wavFile.cpp
index b53c416..a0423f0 100644
--- a/noncore/multimedia/opierec/wavFile.cpp
+++ b/noncore/multimedia/opierec/wavFile.cpp
@@ -59,256 +59,256 @@ bool WavFile::newFile() {
   QString currentFile=date;
   if(currentFileName.right(1).find("/",0,true) == -1)
     currentFileName += "/" + date;
   else
     currentFileName += date;
   currentFileName+=".wav";
 
 //  odebug << "set up file for recording: "+currentFileName << oendl;
   char pointer[] = "/tmp/opierec-XXXXXX";
   int fd = 0;
 
   if( currentFileName.find("/mnt",0,true) == -1
       && currentFileName.find("/tmp",0,true) == -1 ) {
     // if destination file is most likely in flash (assuming jffs2)
     // we have to write to a different filesystem first
 
     useTmpFile = true;
     if(( fd = mkstemp( pointer)) < 0 ) {
        perror("mkstemp failed");
        return false;
     }
 
 //    odebug << "Opening tmp file " << pointer << "" << oendl;
     track.setName( pointer);
 
   } else { //just use regular file.. no moving
 
     useTmpFile = false;
     track.setName( currentFileName);
   }
   if(!track.open( IO_ReadWrite | IO_Truncate)) {
     QString errorMsg=(QString)strerror(errno);
     odebug << errorMsg << oendl;
     QMessageBox::message("Note", "Error opening file.\n" +errorMsg);
 
     return false;
   } else {
     setWavHeader( track.handle() , &hdr);
   }
 return true;
 }
 
 WavFile::~WavFile() {
 
     closeFile();
 }
 
 void WavFile::closeFile() {
     if(track.isOpen())
         track.close();
 }
 
 int WavFile::openFile(const QString &currentFileName) {
                 qWarning("open play file "+currentFileName);;
     closeFile();
 
                 track.setName(currentFileName);
 
                 if(!track.open(IO_ReadOnly)) {
                                 QString errorMsg=(QString)strerror(errno);
                                 odebug << "<<<<<<<<<<< "+errorMsg+currentFileName << oendl;
                                 QMessageBox::message("Note", "Error opening file.\n" +errorMsg);
                                 return -1;
                 } else {
                                 parseWavHeader( track.handle());
                 }
                 return track.handle();
 }
 
 bool WavFile::setWavHeader(int fd, wavhdr *hdr) {
 
   strncpy((*hdr).riffID, "RIFF", 4); // RIFF
   strncpy((*hdr).wavID, "WAVE", 4); //WAVE
   strncpy((*hdr).fmtID, "fmt ", 4); // fmt
   (*hdr).fmtLen = 16; // format length = 16
 
   if( wavFormat == WAVE_FORMAT_PCM) {
     (*hdr).fmtTag = 1; // PCM
 //    odebug << "set header  WAVE_FORMAT_PCM" << oendl;
   }
   else {
     (*hdr).fmtTag = WAVE_FORMAT_DVI_ADPCM; //intel ADPCM
  //    odebug << "set header  WAVE_FORMAT_DVI_ADPCM" << oendl;
   }
 
   //  (*hdr).nChannels = 1;//filePara.channels;// ? 2 : 1*/; // channels
   (*hdr).nChannels = wavChannels;// ? 2 : 1*/; // channels
 
   (*hdr).sampleRate = wavSampleRate; //samples per second
   (*hdr).avgBytesPerSec = (wavSampleRate)*( wavChannels*(wavResolution/8)); // bytes per second
   (*hdr).nBlockAlign = wavChannels*( wavResolution/8); //block align
   (*hdr).bitsPerSample = wavResolution; //bits per sample 8, or 16
 
   strncpy((*hdr).dataID, "data", 4);
 
   write( fd,hdr, sizeof(*hdr));
-   owarn << "writing header: bitrate " << wavResolution << ", samplerate " << wavSampleRate << ",  channels " << wavChannels << oendl;
+//   owarn << "writing header: bitrate " << wavResolution << ", samplerate " << wavSampleRate << ",  channels " << wavChannels << oendl;
   return true;
 }
 
 bool WavFile::adjustHeaders(int fd, int total) {
   lseek(fd, 4, SEEK_SET);
   int i = total + 36;
   write( fd, &i, sizeof(i));
   lseek( fd, 40, SEEK_SET);
   write( fd, &total, sizeof(total));
-  owarn << "adjusting header " << total << "" << oendl;
+//  owarn << "adjusting header " << total << "" << oendl;
   return true;
 }
 
 int WavFile::parseWavHeader(int fd) {
-  owarn << "Parsing wav header" << oendl;
+//  owarn << "Parsing wav header" << oendl;
   char string[4];
   int found;
   short fmt;
   unsigned short ch, bitrate;
   unsigned long samplerrate, longdata;
 
   if (read(fd, string, 4) < 4) {
-    owarn << " Could not read from sound file." << oendl;
+//    owarn << " Could not read from sound file." << oendl;
     return -1;
   }
   if (strncmp(string, "RIFF", 4)) {
-    owarn << " not a valid WAV file." << oendl;
+//    owarn << " not a valid WAV file." << oendl;
     return -1;
   }
   lseek(fd, 4, SEEK_CUR);
   if (read(fd, string, 4) < 4) {
-    owarn << "Could not read from sound file." << oendl;
+//    owarn << "Could not read from sound file." << oendl;
     return -1;
   }
   if (strncmp(string, "WAVE", 4)) {
-    owarn << "not a valid WAV file." << oendl;
+//    owarn << "not a valid WAV file." << oendl;
     return -1;
   }
   found = 0;
 
   while (!found) {
     if (read(fd, string, 4) < 4) {
-      owarn << "Could not read from sound file." << oendl;
+//      owarn << "Could not read from sound file." << oendl;
       return -1;
     }
     if (strncmp(string, "fmt ", 4)) {
       if (read(fd, &longdata, 4) < 4) {
-        owarn << "Could not read from sound file." << oendl;
+//        owarn << "Could not read from sound file." << oendl;
         return -1;
       }
       lseek(fd, longdata, SEEK_CUR);
     } else {
       lseek(fd, 4, SEEK_CUR);
       if (read(fd, &fmt, 2) < 2) {
-        owarn << "Could not read format chunk." << oendl;
+//        owarn << "Could not read format chunk." << oendl;
         return -1;
       }
       if (fmt != WAVE_FORMAT_PCM && fmt != WAVE_FORMAT_DVI_ADPCM) {
-        owarn << "Wave file contains unknown format. Unable to continue." << oendl;
+//        owarn << "Wave file contains unknown format. Unable to continue." << oendl;
         return -1;
       }
       wavFormat = fmt;
       //      compressionFormat=fmt;
-      owarn << "compressionFormat is " << fmt << "" << oendl;
+//      owarn << "compressionFormat is " << fmt << "" << oendl;
       if (read(fd, &ch, 2) < 2) {
-        owarn << "Could not read format chunk." << oendl;
+//        owarn << "Could not read format chunk." << oendl;
         return -1;
       } else {
         wavChannels = ch;
-        owarn << "File has " << ch << " channels" << oendl;
+//        owarn << "File has " << ch << " channels" << oendl;
       }
       if (read(fd, &samplerrate, 4) < 4) {
-        owarn << "Could not read from format chunk." << oendl;
+//        owarn << "Could not read from format chunk." << oendl;
         return -1;
       } else {
         wavSampleRate = samplerrate;
         //                sampleRate = samplerrate;
-        owarn << "File has samplerate of " << (int) samplerrate << "" << oendl;
+//        owarn << "File has samplerate of " << (int) samplerrate << "" << oendl;
       }
       lseek(fd, 6, SEEK_CUR);
       if (read(fd, &bitrate, 2) < 2) {
-        owarn << "Could not read format chunk." << oendl;
+//        owarn << "Could not read format chunk." << oendl;
         return -1;
       }  else {
         wavResolution=bitrate;
         //                 resolution =  bitrate;
-        owarn << "File has bitrate of " << bitrate << "" << oendl;
+//        owarn << "File has bitrate of " << bitrate << "" << oendl;
       }
       found++;
     }
   }
   found = 0;
   while (!found) {
     if (read(fd, string, 4) < 4) {
       odebug << "Could not read from sound file." << oendl;
       return -1;
     }
 
     if (strncmp(string, "data", 4)) {
       if (read(fd, &longdata, 4)<4) {
         odebug << "Could not read from sound file." << oendl;
         return -1;
       }
 
       lseek(fd, longdata, SEEK_CUR);
     } else {
       if (read(fd, &longdata, 4) < 4) {
         odebug << "Could not read from sound file." << oendl;
         return -1;
       } else {
         wavNumberSamples =  longdata;
          odebug << "file hase length of " << (int)longdata << ""
                 << "lasting "
                 << (int)(( longdata / wavSampleRate) / wavChannels) / ( wavChannels*( wavResolution/8))
                 << " seconds" << oendl;
 //        wavSeconds = (( longdata / wavSampleRate) / wavChannels) / ( wavChannels*( wavResolution/8));
 
   return longdata;
       }
     }
   }
 
   lseek(fd, 0, SEEK_SET);
 
   return 0;
 }
 
 QString WavFile::trackName() {
     return track.name();
 }
 
 int WavFile::wavHandle(){
   return track.handle();
 }
 
 int WavFile::getFormat() {
 return wavFormat;
 }
 
 int WavFile::getResolution() {
 return wavResolution;
 }
 
 int WavFile::getSampleRate() {
  return wavSampleRate;
 }
 
 int WavFile::getNumberSamples() {
  return wavNumberSamples;
 }
 
 bool WavFile::isTempFile() {
 return useTmpFile;
 }
 
 int WavFile::getChannels() {
 
    return wavChannels;
 }