fix

1 files changed, 26 insertions, 16 deletions

diff --git a/core/applets/vmemo/vmemo.cpp b/core/applets/vmemo/vmemo.cpp
index b80b378..e747a19 100644
--- a/core/applets/vmemo/vmemo.cpp
+++ b/core/applets/vmemo/vmemo.cpp
@@ -207,65 +207,66 @@ VMemo::VMemo( QWidget *parent, const char *_name )
   connect( t_timer, SIGNAL( timeout() ), SLOT( timerBreak() ) );
 
     Config vmCfg("Vmemo");
     vmCfg.setGroup("Defaults");
     int toggleKey = setToggleButton(vmCfg.readNumEntry("toggleKey", -1));
     useADPCM = vmCfg.readBoolEntry("use_ADPCM", 0);
 
     odebug << "toggleKey " << toggleKey << "" << oendl;
 
 //     if ( QFile::exists ( "/dev/sharp_buz" ) || QFile::exists ( "/dev/sharp_led" ))
 //          systemZaurus=TRUE;
 //     else
       systemZaurus = FALSE;
 
     myChannel = new QCopChannel( "QPE/VMemo", this );
     connect( myChannel, SIGNAL(received(const QCString&,const QByteArray&)),
              this, SLOT(receive(const QCString&,const QByteArray&)) );
 
     if( toggleKey != -1 ) {
                 odebug << "Register key " << toggleKey << "" << oendl;
       QCopEnvelope e("QPE/Launcher", "keyRegister(int,QCString,QCString)");
       //           e << 4096; // Key_Escape
       //          e << Key_F5; //4148
       e << toggleKey;
       e << QString("QPE/VMemo");
       e << QString("toggleRecord()");
     }
     if(toggleKey == 1)
         usingIcon = TRUE;
     else
         usingIcon = FALSE;
 //     if( vmCfg.readNumEntry("hideIcon",0) == 1)
-//       hide();
+        if (!usingIcon)
+                        hide();
     recording = FALSE;
     // }
 }
 
 VMemo::~VMemo() {
 }
 
 int VMemo::position()
 {
     return 6;
 }
 
 void VMemo::receive( const QCString &msg, const QByteArray &data ) {
   odebug << "Vmemo receive" << oendl;
   QDataStream stream( data, IO_ReadOnly );
 
   if (msg == "toggleRecord()")  {
       if (recording) {
           fromToggle = TRUE;
           stopRecording();
       }  else {
           fromToggle = TRUE;
           startRecording();
       }
   }
 }
 
 void VMemo::paintEvent( QPaintEvent* ) {
   QPainter p(this);
   p.drawPixmap( 0, 1,( const char** )  vmemo_xpm );
 }
 
@@ -346,65 +347,65 @@ bool VMemo::startRecording() {
     ::close(dsp);
     return FALSE;
   }
   if( record() ) {
 
   QString cmd;
   if( fileName.find(".wav",0,TRUE) == -1)
       fileName += ".wav";
 
   cmd.sprintf("mv %s "+fileName, pointer);
 // move tmp file to regular file here
 
   system(cmd.latin1());
 
   QArray<int> cats(1);
   cats[0] = config.readNumEntry("Category", 0);
 
   QString dlName("vm_");
   dlName += date;
   DocLnk l;
   l.setFile(fileName);
   l.setName(dlName);
   l.setType("audio/x-wav");
   l.setCategories(cats);
   l.writeLink();
   return TRUE;
   } else
       return FALSE;
 
 }
 
 void VMemo::stopRecording() {
-    show();
+//    show();
     odebug << "Stopped recording" << oendl;
     recording = FALSE;
     if(useAlerts) {
         msgLabel->close();
         msgLabel=0;
         delete msgLabel;
     }
     t_timer->stop();
     Config cfg("Vmemo");
     cfg.setGroup("Defaults");
 //     if( cfg.readNumEntry("hideIcon",0) == 1 )
 //         hide();
 }
 
 int VMemo::openDSP() {
   Config cfg("Vmemo");
   cfg.setGroup("Record");
 
   speed = cfg.readNumEntry("SampleRate", 22050);
   channels = cfg.readNumEntry("Stereo", 1) ? 2 : 1; // 1 = stereo(2), 0 = mono(1)
   if (cfg.readNumEntry("SixteenBit", 1)==1)  {
     format = AFMT_S16_LE;
     resolution = 16;
   } else {
     format = AFMT_U8;
     resolution = 8;
   }
 
   odebug << "samplerate: " << speed << ", channels " << channels << ", resolution " << resolution << "" << oendl;
 
   if(systemZaurus) {
     dsp = open("/dev/dsp1", O_RDONLY); //Zaurus needs /dev/dsp1
@@ -456,139 +457,148 @@ int VMemo::openWAV(const char *filename) {
   wav=track.handle();
     Config vmCfg("Vmemo");
     vmCfg.setGroup("Defaults");
   useADPCM = vmCfg.readBoolEntry("use_ADPCM", 0);
 
   WaveHeader wh;
 
   wh.main_chunk = RIFF;
   wh.length=0;
   wh.chunk_type = WAVE;
   wh.sub_chunk  = FMT;
   wh.sc_len     = 16;
   if(useADPCM)
       wh.format     = WAVE_FORMAT_DVI_ADPCM;//PCM_CODE;
   else
       wh.format     = PCM_CODE;
   wh.modus      = channels;
   wh.sample_fq  = speed;
   wh.byte_p_sec = speed * channels *  resolution/8;
   wh.byte_p_spl = channels * (resolution / 8);
   wh.bit_p_spl  = resolution;
   wh.data_chunk = DATA;
   wh.data_length= 0;
   //    odebug << "Write header channels " << wh.modus << ", speed " << wh.sample_fq << ", b/s "
   //           << wh.byte_p_sec << ", blockalign " << wh.byte_p_spl << ", bitrate " << wh.bit_p_spl << oendl;
   write (wav, &wh, sizeof(WaveHeader));
 
   return 1;
 }
 
 bool VMemo::record() {
         length = 0;
-    int bytesWritten = 0;
+                                int bytesWritten = 0;
         int result = 0;
         int value = 0;
+
         QString msg;
         msg.sprintf("Recording format %d", format);
         odebug << msg << oendl;
+
         Config config("Vmemo");
         config.setGroup("Record");
         int sRate = config.readNumEntry("SizeLimit", 30);
-        if(sRate > 0)
-                t_timer->start( sRate * 1000+1000, TRUE);
+                                odebug << "VMEMO rate" << sRate << oendl;
 
-    msg.sprintf("Recording format other");
-    odebug << msg << oendl;
+         if(sRate > 0) {
+                                                t_timer->start( sRate * 1000+1000, TRUE);
+                                }
+
+     msg.sprintf("Recording format other");
+     odebug << msg << oendl;
 
     config.setGroup("Defaults");
     useADPCM = config.readBoolEntry("use_ADPCM", 0);
 
-        int bufsize = config.readNumEntry("BufferSize",1024);
-        unsigned short sound[bufsize]; //, monoBuffer[bufsize];
+    int bufsize = config.readNumEntry("BufferSize",1024);
+    unsigned short sound[bufsize]; //, monoBuffer[bufsize];
     char abuf[bufsize / 2];
     short sbuf[bufsize];
-
+                odebug << "ready to record"<< oendl;
         if(useADPCM) {
+                                                odebug << "usr ADPCM" << oendl;
+                                                
                 while(recording) {
                         result = ::read(dsp, sbuf, bufsize); // adpcm read
                         if( result <= 0) {
                                 perror("recording error ");
                                 QMessageBox::message(tr("Note"),tr("error recording"));
                                 recording = FALSE;
                                 break;
                                 return FALSE;
                         }
                         adpcm_coder( sbuf, abuf, result/2, &encoder_state);
                         bytesWritten = ::write(wav, abuf, result/4); // adpcm write
                         length += bytesWritten;
 
                         if(length < 0) {
                                 recording = false;
                                 perror("dev/dsp's is a lookin' messy");
                                 QMessageBox::message("Vmemo","Error writing to file\n"+ fileName);
                                 break;
                                 return FALSE;
                         }
-                            //       printf("%d\r", length);
-                            //       fflush(stdout);
+                                   printf("%d\r", length);
+                                   fflush(stdout);
                         qApp->processEvents();
                 }
         } else {
+                                                odebug << "use regular wav" << oendl;
                 while(recording) {
                         result = ::read(dsp, sound, bufsize); // read
                         if( result <= 0) {
                                 perror("recording error ");
                                 QMessageBox::message(tr("Note"),tr("error recording"));
                                 recording = FALSE;
                                 break;
                                 return FALSE;
+                                                                                                }
 
                                 bytesWritten = ::write(wav, sound, result); // write
                                 length += bytesWritten;
 
                                 if(length < 0) {
                                         recording = false;
                                         perror("dev/dsp's is a lookin' messy");
                                         QMessageBox::message("Vmemo","Error writing to file\n"+ fileName);
                                         break;
                                         return FALSE;
                                 }
-                                    //       printf("%d\r", length);
-                                    //       fflush(stdout);
+//                                            printf("%d\r", length);
+//                                            fflush(stdout);
                                 qApp->processEvents();
                         }
+        //                                                                                      odebug << "result is " << result << oendl;
                 }
-        }
-            //  odebug << "file has length of " << length << " lasting " << (( length / speed) / channels) / 2 ) << " seconds" << oendl;
+                                odebug << "file has length of " << length << " lasting " << (( length / speed) / channels) / 2  << " seconds" << oendl;
 
         value = length + 36;
 
         lseek(wav, 4, SEEK_SET);
         write(wav, &value, 4);
         lseek(wav, 40, SEEK_SET);
 
         write(wav, &length, 4);
 
         track.close();
         odebug << "Track closed" << oendl;
 
         if( ioctl( dsp, SNDCTL_DSP_RESET,0) == -1)
                 perror("ioctl(\"SNDCTL_DSP_RESET\")");
 
         ::close(dsp);
 
         Config cfgO("OpieRec");
         cfgO.setGroup("Sounds");
 
         int nFiles = cfgO.readNumEntry( "NumberofFiles",0);
 
         QString currentFileName = fileName;
         QString currentFile = "vm_"+ date;
 
         float numberOfRecordedSeconds = (float) length / (float)speed * (float)2;
 
         cfgO.writeEntry( "NumberofFiles", nFiles + 1);
         cfgO.writeEntry( QString::number( nFiles + 1), currentFile);
         cfgO.writeEntry( currentFile, currentFileName);
 
         QString time;