support for DEVFS

3 files changed, 27 insertions, 0 deletions

diff --git a/noncore/multimedia/opieplayer2/mediaplayer.cpp b/noncore/multimedia/opieplayer2/mediaplayer.cpp
index 7b4bfd9..e6afbd8 100644
--- a/noncore/multimedia/opieplayer2/mediaplayer.cpp
+++ b/noncore/multimedia/opieplayer2/mediaplayer.cpp
@@ -1,403 +1,407 @@
 #include "mediaplayer.h"
 #include "audiowidget.h"
 #include "videowidget.h"
 #include "volumecontrol.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 
 /* QT */
 #include <qfileinfo.h>
 
 /* STD */
 #include <linux/fb.h>
 #include <sys/file.h>
 #include <sys/ioctl.h>
 
 #define FBIOBLANK 0x4611
 
 MediaPlayer::MediaPlayer( PlayListWidget &_playList, MediaPlayerState &_mediaPlayerState, QObject *parent, const char *name )
     : QObject( parent, name ), volumeDirection( 0 ), mediaPlayerState( _mediaPlayerState ), playList( _playList ) {
 
     m_audioUI = 0;
     m_videoUI = 0;
     m_xineControl = 0;
     xine = new XINE::Lib( XINE::Lib::InitializeInThread );
 
     fd=-1;fl=-1;
     playList.setCaption( tr( "OpiePlayer: Initializating" ) );
 
     qApp->processEvents();
     //    QPEApplication::grabKeyboard(); // EVIL
     connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
 
     connect( &mediaPlayerState, SIGNAL( playingToggled(bool) ), this, SLOT( setPlaying(bool) ) );
 
 // What is pauseCheck good for? (Simon)
 //    connect( &mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( pauseCheck(bool) ) );
 
     connect( &mediaPlayerState, SIGNAL( next() ), this, SLOT( next() ) );
     connect( &mediaPlayerState, SIGNAL( prev() ), this, SLOT( prev() ) );
     connect( &mediaPlayerState, SIGNAL( blankToggled(bool) ), this, SLOT ( blank(bool) ) );
 
     volControl = new VolumeControl;
     Config cfg( "OpiePlayer" );
     cfg.setGroup("PlayList");
     QString currentPlaylist = cfg.readEntry( "CurrentPlaylist", "default");
     playList.setCaption( tr( "OpiePlayer: " ) + QFileInfo(currentPlaylist).baseName() );
 
     m_skinLoader = new SkinLoader;
     m_skinLoader->schedule( AudioWidget::guiInfo() );
     m_skinLoader->schedule( VideoWidget::guiInfo() );
     m_skinLoader->start();
 }
 
 MediaPlayer::~MediaPlayer() {
     // this shold never happen, but one never knows...
     if ( xine ) {
         xine->ensureInitialized();
         delete xine;
     }
     delete m_xineControl;
     delete m_audioUI;
     delete m_videoUI;
     delete volControl;
 }
 
 void MediaPlayer::pauseCheck( bool b ) {
      if ( b && !mediaPlayerState.isPlaying() ) {
          mediaPlayerState.setPaused( FALSE );
      }
 }
 
 void MediaPlayer::play() {
     mediaPlayerState.setPlaying( FALSE );
     mediaPlayerState.setPlaying( TRUE );
 }
 
 void MediaPlayer::setPlaying( bool play ) {
     if ( !play ) {
         return;
     }
 
     if ( mediaPlayerState.isPaused() ) {
         mediaPlayerState.setPaused( FALSE );
         return;
     }
 
     QString tickerText, time, fileName;
     if ( playList.currentTab() != PlayListWidget::CurrentPlayList ) {
         //if playing in file list.. play in a different way
         // random and looping settings enabled causes problems here,
         // since there is no selected file in the playlist, but a selected file in the file list,
         // so we remember and shutoff
         l = mediaPlayerState.isLooping();
         if(l) {
             mediaPlayerState.setLooping( false );
         }
         r = mediaPlayerState.isShuffled();
         mediaPlayerState.setShuffled( false );
     }
 
     PlayListWidget::Entry playListEntry = playList.currentEntry();
     fileName = playListEntry.name;
     xineControl()->play( playListEntry.file );
 
     long seconds = mediaPlayerState.length();
     time.sprintf("%li:%02i", seconds/60, (int)seconds%60 );
 
     if( fileName.left(4) == "http" ) {
         fileName = QFileInfo( fileName ).baseName();
        if ( xineControl()->getMetaInfo().isEmpty() ) {
            tickerText = tr( " File: " ) + fileName;
        } else {
            tickerText = xineControl()->getMetaInfo();
        }
     } else {
         if ( xineControl()->getMetaInfo().isEmpty() ) {
             tickerText = tr( " File: " ) + fileName + tr( ", Length: " ) + time + "  ";
         } else {
             tickerText = xineControl()->getMetaInfo() + " Length: " + time + "  ";
         }
     }
     audioUI()->setTickerText( tickerText );
 }
 
 
 void MediaPlayer::prev() {
     if( playList.currentTab() == PlayListWidget::CurrentPlayList ) { //if using the playlist
         if ( playList.prev() ) {
             play();
         } else if ( mediaPlayerState.isLooping() ) {
             if ( playList.last() ) {
                 play();
             }
         } else {
             mediaPlayerState.setList();
         }
     }
 }
 
 
 void MediaPlayer::next() {
 
     if(playList.currentTab() == PlayListWidget::CurrentPlayList) { //if using the playlist
         if ( playList.next() ) {
             play();
         } else if ( mediaPlayerState.isLooping() ) {
             if ( playList.first() ) {
                 play();
             }
         } else {
             mediaPlayerState.setList();
         }
     } else { //if playing from file list, let's just stop
         odebug << "<<<<<<<<<<<<<<<<<stop for filelists" << oendl; 
         mediaPlayerState.setPlaying(false);
         mediaPlayerState.setDisplayType( MediaPlayerState::MediaSelection );
         if(l) mediaPlayerState.setLooping(l);
         if(r) mediaPlayerState.setShuffled(r);
     }
     qApp->processEvents();
 }
 
 
 void MediaPlayer::startDecreasingVolume() {
     volumeDirection = -1;
     startTimer( 100 );
     volControl->decVol(2);
 }
 
 
 void MediaPlayer::startIncreasingVolume() {
     volumeDirection = +1;
     startTimer( 100 );
     volControl->incVol(2);
 }
 
 
 bool drawnOnScreenDisplay = FALSE;
 unsigned int onScreenDisplayVolume = 0;
 const int yoff = 110;
 
 void MediaPlayer::stopChangingVolume() {
     killTimers();
     // Get rid of the on-screen display stuff
     drawnOnScreenDisplay = FALSE;
     onScreenDisplayVolume = 0;
     int w=0;
     int h=0;
     if( !xineControl()->hasVideo() ) {
         w = audioUI()->width();
         h = audioUI()->height();
         audioUI()->repaint( ( w - 200 ) / 2, h - yoff, 200 + 9, 70, FALSE );
     } else {
         w = videoUI()->width();
         h = videoUI()->height();
         videoUI()->repaint( ( w - 200 ) / 2, h - yoff, 200 + 9, 70, FALSE );
     }
 }
 
 
 void MediaPlayer::timerEvent( QTimerEvent * ) {
     if ( volumeDirection == +1 ) {
         volControl->incVol( 2 );
     } else if ( volumeDirection == -1 ) {
         volControl->decVol( 2 );
     }
 
 
       // TODO FIXME
       // huh??
     unsigned int v= 0;
     v = volControl->volume();
     v = v / 10;
 
     if ( drawnOnScreenDisplay && onScreenDisplayVolume == v ) {
         return;
     }
 
     int w=0; int h=0;
     if( !xineControl()->hasVideo() ) {
         w = audioUI()->width();
         h = audioUI()->height();
 
         if ( drawnOnScreenDisplay ) {
             if ( onScreenDisplayVolume > v ) {
                 audioUI()->repaint( ( w - 200 ) / 2 + v * 20 + 0, h - yoff + 40, ( onScreenDisplayVolume - v ) * 20 + 9, 30, FALSE );
             }
         }
         drawnOnScreenDisplay = TRUE;
         onScreenDisplayVolume = v;
         QPainter p( audioUI() );
         p.setPen( QColor( 0x10, 0xD0, 0x10 ) );
         p.setBrush( QColor( 0x10, 0xD0, 0x10 ) );
 
         QFont f;
         f.setPixelSize( 20 );
         f.setBold( TRUE );
         p.setFont( f );
         p.drawText( (w - 200) / 2, h - yoff + 20, tr("Volume") );
 
         for ( unsigned int i = 0; i < 10; i++ ) {
             if ( v > i ) {
                 p.drawRect( ( w - 200 ) / 2 + i * 20 + 0, h - yoff + 40, 9, 30 );
             } else {
                 p.drawRect( ( w - 200 ) / 2 + i * 20 + 3, h - yoff + 50, 3, 10 );
             }
         }
     } else {
         w = videoUI()->width();
         h = videoUI()->height();
 
         if ( drawnOnScreenDisplay ) {
             if ( onScreenDisplayVolume > v ) {
                 videoUI()->repaint( (w - 200) / 2 + v * 20 + 0, h - yoff + 40, ( onScreenDisplayVolume - v ) * 20 + 9, 30, FALSE );
             }
         }
         drawnOnScreenDisplay = TRUE;
         onScreenDisplayVolume = v;
         QPainter p( videoUI() );
         p.setPen( QColor( 0x10, 0xD0, 0x10 ) );
         p.setBrush( QColor( 0x10, 0xD0, 0x10 ) );
 
         QFont f;
         f.setPixelSize( 20 );
         f.setBold( TRUE );
         p.setFont( f );
         p.drawText( (w - 200) / 2, h - yoff + 20, tr( "Volume" ) );
 
         for ( unsigned int i = 0; i < 10; i++ ) {
             if ( v > i ) {
                 p.drawRect( (w - 200) / 2 + i * 20 + 0, h - yoff + 40, 9, 30 );
             } else {
                 p.drawRect( (w - 200) / 2 + i * 20 + 3, h - yoff + 50, 3, 10 );
             }
         }
     }
 }
 
 
 void MediaPlayer::blank( bool b ) {
+#ifdef QT_QWS_DEVFS
+    fd=open("/dev/fb/0",O_RDWR);
+#else
     fd=open("/dev/fb0",O_RDWR);
+#endif
 #ifdef QT_QWS_SL5XXX
     fl= open( "/dev/fl", O_RDWR );
 #endif
     if (fd != -1) {
         if ( b ) {
             odebug << "do blanking" << oendl; 
 #ifdef QT_QWS_SL5XXX
             ioctl( fd, FBIOBLANK, 1 );
             if(fl !=-1) {
                 ioctl( fl, 2 );
                 ::close(fl);
             }
 #else
             ioctl( fd, FBIOBLANK, 3 );
 #endif
             isBlanked = TRUE;
         } else {
             odebug << "do unblanking" << oendl; 
             ioctl( fd, FBIOBLANK, 0);
 #ifdef QT_QWS_SL5XXX
             if(fl != -1) {
                 ioctl( fl, 1);
                 ::close(fl);
             }
 #endif
             isBlanked = FALSE;
         }
         close( fd );
     } else {
         odebug << "<< /dev/fb0 could not be opened  >>" << oendl; 
     }
 }
 
 void MediaPlayer::keyReleaseEvent( QKeyEvent *e) {
     switch ( e->key() ) {
 ////////////////////////////// Zaurus keys
       case Key_Home:
           break;
       case Key_F9: //activity
           break;
       case Key_F10: //contacts
           break;
       case Key_F11: //menu
           break;
       case Key_F12: //home
           odebug << "Blank here" << oendl; 
 //          mediaPlayerState->toggleBlank();
           break;
       case Key_F13: //mail
           odebug << "Blank here" << oendl; 
           //  mediaPlayerState->toggleBlank();
           break;
     }
 }
 
 void MediaPlayer::cleanUp() {// this happens on closing
      Config cfg( "OpiePlayer" );
      mediaPlayerState.writeConfig( cfg );
      playList.writeDefaultPlaylist( );
 
 //     QPEApplication::grabKeyboard();
 //     QPEApplication::ungrabKeyboard();
 }
 
 void MediaPlayer::recreateAudioAndVideoWidgets() const
 {
     delete m_skinLoader;
 
     delete m_xineControl;
     delete m_audioUI;
     delete m_videoUI;
     m_audioUI = new AudioWidget( playList, mediaPlayerState, 0, "audioUI" );
     m_videoUI = new VideoWidget( playList, mediaPlayerState, 0, "videoUI" );
 
     connect( m_audioUI,  SIGNAL( moreClicked() ), this, SLOT( startIncreasingVolume() ) );
     connect( m_audioUI,  SIGNAL( lessClicked() ),  this, SLOT( startDecreasingVolume() ) );
     connect( m_audioUI,  SIGNAL( moreReleased() ), this, SLOT( stopChangingVolume() ) );
     connect( m_audioUI,  SIGNAL( lessReleased() ), this, SLOT( stopChangingVolume() ) );
 
     connect( m_videoUI,  SIGNAL( moreClicked() ), this, SLOT( startIncreasingVolume() ) );
     connect( m_videoUI,  SIGNAL( lessClicked() ),  this, SLOT( startDecreasingVolume() ) );
     connect( m_videoUI,  SIGNAL( moreReleased() ), this, SLOT( stopChangingVolume() ) );
     connect( m_videoUI,  SIGNAL( lessReleased() ), this, SLOT( stopChangingVolume() ) );
 
     if ( !xine )
         xine = new XINE::Lib( XINE::Lib::InitializeImmediately );
 
     m_xineControl = new XineControl( xine, m_videoUI->vidWidget(), mediaPlayerState );
 
     xine = 0;
 }
 
 AudioWidget *MediaPlayer::audioUI() const
 {
     if ( !m_audioUI )
         recreateAudioAndVideoWidgets();
     return m_audioUI;
 }
 
 VideoWidget *MediaPlayer::videoUI() const
 {
     if ( !m_videoUI )
         recreateAudioAndVideoWidgets();
     return m_videoUI;
 }
 
 XineControl *MediaPlayer::xineControl() const
 {
     if ( !m_xineControl )
         recreateAudioAndVideoWidgets();
     return m_xineControl;
 }
 
 void MediaPlayer::reloadSkins()
 {
     audioUI()->loadSkin();
     videoUI()->loadSkin();
 }
 
diff --git a/noncore/multimedia/opierec/device.cpp b/noncore/multimedia/opierec/device.cpp
index 683f0a5..cb47b77 100644
--- a/noncore/multimedia/opierec/device.cpp
+++ b/noncore/multimedia/opierec/device.cpp
@@ -1,358 +1,374 @@
 // device.cpp
 
 #include "device.h"
 
 #include <qpe/config.h>
 #include <qpe/qcopenvelope_qws.h>
 
 /* STD */
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <sys/soundcard.h>
 #include <unistd.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include <errno.h>
 
 //extern QtRec *qperec;
 
 Device::Device( QObject * parent, const char * dsp, const char * mixr, bool record )
         : QObject( parent)
 {
     dspstr = (char *)dsp;
     mixstr = (char *)mixr;
 
     devForm=-1;
     devCh=-1;
     devRate=-1;
 
     if( !record){ //playing
         qDebug( "setting up DSP for playing" );
         flags = O_WRONLY;
     } else { //recording
         qDebug( "setting up DSP for recording" );
         flags = O_RDWR;
 //        flags = O_RDONLY;
 
 //        selectMicInput();
 
     }
 }
 
 bool Device::openDsp() {
     if( openDevice( flags) == -1) {
         perror("<<<<<<<<<<<<<<ioctl(\"Open device\")");
         return false;
     }
     return true;
 }
 
 int Device::openDevice( int flags) {
 /*     pid_t pid;
      int status;
      int pipefd[2];
      char message[20];
      if (pipe(pipefd) == -1){
          perror ("Error creating pipe");
 exit(1);
      }
      switch (pid = fork()) {
        case -1:
            perror("The fork failed!");
            break;
        case 0: {
  */
 qDebug( "Opening %s",dspstr);
  if (( sd = ::open( dspstr, flags)) == -1) {
               perror("open(\"/dev/dsp\")");
               QString errorMsg="Could not open audio device\n /dev/dsp\n"
                   +(QString)strerror(errno);
               qDebug( "XXXXXXXXXXXXXXXXXXXXXXX  "+errorMsg );
               return -1;
           }
 
 qDebug( "Opening mixer" );
     int mixerHandle=0;
+#ifdef QT_QWS_DEVFS
+        if  (( mixerHandle = open("/dev/sound/mixer",O_RDWR))<0) {
+#else
         if  (( mixerHandle = open("/dev/mixer",O_RDWR))<0) {
+#endif
             perror("open(\"/dev/mixer\")");
               QString errorMsg="Could not open audio device\n /dev/dsp\n"
                   +(QString)strerror(errno);
               qDebug( "XXXXXXXXXXXXXXXXXXXXXX  "+errorMsg );
         }
 
         if(ioctl(sd,SNDCTL_DSP_RESET,0)<0){
             perror("ioctl RESET");
         }
 //           sprintf(message, "%d", sd);
 
 /*           QFile f1("/pid");
            f1.open(IO_WriteOnly );
            f1.writeBlock(message, strlen(message));
            f1.close();
  */
   /*               close(pipefd[0]);
                  write(pipefd[1], message, sizeof(message));
      close(pipefd[1]);
  //              qDebug( "" + soundDevice->sd );
            _exit(0);
        }
        default:
           // pid greater than zero is parent getting the child's pid
            printf("Child's pid is %d\n",pid);
            QString s;
                 close(pipefd[1]);
                 read(pipefd[0], message, sizeof(message));
     s = message;
                  close(pipefd[0]);
 
 //     while(wait(NULL)!=pid)
   //             ;
            printf("child %ld terminated normally, return status is zero\n", (long) pid);
              */
        //    filePara.sd=(long) pid;
    /*        QFile f2("/pid");
            f2.open(IO_ReadOnly);
            QTextStream t(&f2);
  //                for(int f=0; f < t.atEnd() ;f++) {
            s = t.readLine();
  //               }
            */
 //     bool ok;
 //           sd = s.toInt(&ok, 10);
 //           qDebug( "<<<<<<<<<<<<<>>>>>>>>>>>>"+s );
 
 //           f2.close();
 //     }
 ::close(mixerHandle );
 //         qDebug( "open device " + dspstr );
 //     qDebug( "success! " + sd );
     return sd;
 }
 
 
 int Device::getOutVolume( ) {
     unsigned int volume;
     int mixerHandle = open( mixstr, O_RDWR );
     if ( mixerHandle >= 0 ) {
         if(ioctl( mixerHandle, MIXER_READ(SOUND_MIXER_VOLUME), &volume )==-1)
             perror("<<<<<<<<<<<<<<ioctl(\"MIXER_READ\")");
         ::close( mixerHandle );
     } else
         perror("open(\"/dev/mixer\")");
     printf("<<<<<<<<<<<<<<<<<<<<output volume %d\n",volume);
 
     Config cfg("qpe");
     cfg.setGroup("Volume");
 
     return cfg.readNumEntry("VolumePercent");
 }
 
 int Device::getInVolume() {
     unsigned int volume=0;
     int mixerHandle = ::open( mixstr, O_RDWR );
     if ( mixerHandle >= 0 ) {
         if(ioctl( mixerHandle, MIXER_READ(SOUND_MIXER_MIC), &volume )==-1)
             perror("<<<<<<<<<<<<<<<ioctl(\"MIXER_READ\")");
         ::close( mixerHandle );
     } else
         perror("open(\"/dev/mixer\")");
     printf("<<<<<<<<<<<<<<input volume %d\n", volume );
     Config cfg("qpe");
     cfg.setGroup("Volume");
 
     return cfg.readNumEntry("Mic");
 }
 
 void Device::changedOutVolume(int vol) {
     int level = (vol << 8) + vol;
     int fd = 0;
+#ifdef QT_QWS_DEVFS
+    if ((fd = open("/dev/sound/mixer", O_RDWR))>=0) {
+#else
     if ((fd = open("/dev/mixer", O_RDWR))>=0) {
+#endif
         if(ioctl(fd, MIXER_WRITE(SOUND_MIXER_VOLUME), &level) == -1)
             perror("ioctl(\"MIXER_IN_WRITE\")");
 
         Config cfg("qpe");
         cfg.setGroup("Volume");
         cfg.writeEntry("VolumePercent", QString::number( vol ));
         QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << false;
         qDebug("changing output vol %d" ,vol );
     }
     ::close(fd);
 }
 
 void Device::changedInVolume(int vol ) {
     int level = (vol << 8) + vol;
     int fd = 0;
+#ifdef QT_QWS_DEVFS
+    if ((fd = open("/dev/sound/mixer", O_RDWR))>=0) {
+#else
     if ((fd = open("/dev/mixer", O_RDWR))>=0) {
+#endif
         if(ioctl(fd, MIXER_WRITE(SOUND_MIXER_MIC), &level) == -1)
             perror("ioctl(\"MIXER_IN_WRITE\")");
         Config cfg("qpe");
         cfg.setGroup("Volume");
         cfg.writeEntry("Mic", QString::number(vol ));
         QCopEnvelope( "QPE/System", "micChange(bool)" ) << false;
         qDebug("changing input volume %d",vol);
     }
     ::close(fd);
 }
 
 bool Device::selectMicInput() {
 
   int md=0;
   int info=MIXER_WRITE(SOUND_MIXER_MIC);
+#ifdef QT_QWS_DEVFS
+  md = ::open(  "/dev/sound/mixer", O_RDWR );
+#else
   md = ::open(  "/dev/mixer", O_RDWR );
+#endif
   if ( md == -1)
   perror("open(\"/dev/mixer\")");
   else {
   if( ioctl( md, SOUND_MIXER_WRITE_RECSRC, &info) == -1)
   perror("ioctl(\"SOUND_MIXER_WRITE_RECSRC\")");
   ::close(md);
   return false;
   }
   ::close(md);
 
     return true;
 }
 
 bool Device::closeDevice( bool) {
 //      if(b) {//close now
 //          if (ioctl( sd, SNDCTL_DSP_RESET, 0) == -1) {
 //              perror("ioctl(\"SNDCTL_DSP_RESET\")");
 //          }
 //      } else { //let play
 //          if (ioctl( sd, SNDCTL_DSP_SYNC, 0) == -1) {
 //              perror("ioctl(\"SNDCTL_DSP_SYNC\")");
 //          }
 //      }
 
     ::close( sd); //close sound device
 //    sdfd=0;
  //   sd=0;
 //    qDebug( "closed dsp" );
     return true;
 }
 
 bool Device::setDeviceFormat( int form) {
     qDebug( "set device res %d: %d ",form, sd );
     if (ioctl( sd, SNDCTL_DSP_SETFMT,  &form)==-1) { //set format
         perror("ioctl(\"SNDCTL_DSP_SETFMT\")");
         return false;
     }
     devRes=form;
     return true;
 }
 
 bool Device::setDeviceChannels( int ch) {
     qDebug( "set channels %d: %d",ch ,sd);
     if (ioctl( sd, SNDCTL_DSP_CHANNELS, &ch)==-1) {
         perror("ioctl(\"SNDCTL_DSP_CHANNELS\")");
         return false;
     }
     devCh=ch;
     return true;
 }
 
 bool Device::setDeviceRate( int rate) {
     qDebug( "set rate %d: %d",rate,sd);
     if (ioctl( sd, SNDCTL_DSP_SPEED, &rate) == -1) {
         perror("ioctl(\"SNDCTL_DSP_SPEED\")");
         return false;
     }
 
     devRate=rate;
 
     return true;
 }
 
 int Device::getRes() {
     return devRes;
 }
 
 int Device::getFormat() {
     return devForm;
 }
 
 int Device::getRate() {
     return devRate;
 }
 
 int Device::getChannels() {
     return devCh;
 }
 
 int Device::getDeviceFormat() {
     return 0;
 }
 
 
 int Device::getDeviceRate() {
     int dRate=0;
     if (ioctl( sd, SOUND_PCM_READ_RATE, &dRate) == -1) {
         perror("ioctl(\"SNDCTL_PCM_READ_RATE\")");
     }
     return dRate;
 
 }
 
 int Device::getDeviceBits() {
     int dBits=0;
 #ifndef QT_QWS_EBX // zaurus doesnt have this
      if (ioctl( sd, SOUND_PCM_READ_BITS, &dBits) == -1) {
          perror("ioctl(\"SNDCTL_PCM_READ_BITS\")");
      }
 #endif
     return dBits;
 }
 
 int Device::getDeviceChannels() {
     int dCh=0;
     if (ioctl( sd, SOUND_PCM_READ_CHANNELS, &dCh) == -1) {
         perror("ioctl(\"SNDCTL_PCM_READ_CHANNELS\")");
     }
     return dCh;
 }
 
 int Device::getDeviceFragSize() {
     int frag_size;
 
     if (ioctl( sd, SNDCTL_DSP_GETBLKSIZE, &frag_size) == -1) {
       qDebug( "no fragsize" );
     } else {
       qDebug( "driver says frag size is %d",frag_size);
     }
     return frag_size;
 }
 
 bool Device::setFragSize(int frag) {
     if (ioctl(sd, SNDCTL_DSP_SETFRAGMENT, &frag)) {
         perror("ioctl(\"SNDCTL_DSP_SETFRAGMENT\")");
         return false;
     }
     return true;
 }
 
 bool Device::reset() {
   closeDevice(true);
   openDsp();
          if (ioctl( sd, SNDCTL_DSP_RESET, 0) == -1) {
              perror("ioctl(\"SNDCTL_DSP_RESET\")");
        return false;
          }
    return true;
 }
 
 int Device::devRead(int soundDescriptor, short *buf, int size) {
                 Q_UNUSED(soundDescriptor);
    int number = 0;
    number = ::read(  sd /*soundDescriptor*/, (char *)buf, size);
    return number;
 }
 
 int Device::devWrite(int soundDescriptor, short * buf, int size) {
                 Q_UNUSED(soundDescriptor);
                 int bytesWritten = 0;
    bytesWritten = ::write( sd /*soundDescriptor*/, buf, size);
    return bytesWritten;
 }
 
 
diff --git a/noncore/multimedia/opierec/qtrec.cpp b/noncore/multimedia/opierec/qtrec.cpp
index 1141faa..c237726 100644
--- a/noncore/multimedia/opierec/qtrec.cpp
+++ b/noncore/multimedia/opierec/qtrec.cpp
@@ -1,853 +1,860 @@
 /****************************************************************************
          // qtrec.cpp
  Created: Thu Jan 17 11:19:58 2002
  copyright 2002 by L.J. Potter <ljp@llornkcor.com>
 ****************************************************************************/
 #define DEV_VERSION
 
 #include "pixmaps.h"
 #include "qtrec.h"
 #include "waveform.h"
 extern "C" {
 #include "adpcm.h"
 }
 
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/config.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/storage.h>
 using namespace Opie::Core;
 
 /* QT */
 #include <qcheckbox.h>
 #include <qcombobox.h>
 #include <qdir.h>
 #include <qgroupbox.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlistview.h>
 #include <qmessagebox.h>
 #include <qpopupmenu.h>
 #include <qpushbutton.h>
 #include <qslider.h>
 #include <qtabwidget.h>
 #include <qtimer.h>
 
 /* STD */
 #include <errno.h>
 #include <fcntl.h>
 #include <math.h>
 #include <mntent.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <sys/soundcard.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/vfs.h>
 #include <unistd.h>
 #include <sys/wait.h>
 #include <sys/signal.h>
 #include <pthread.h>
 
 #ifdef PDAUDIO //ALSA
 #include <alsa/asoundlib.h>
 static int deviceSampleRates[8] = { 32000, 44100, 48000, 88200, 96000, 176400, 192000, -1 };
 static int deviceBitRates[] = { 8, 16, 24, 32, -1 };
 #else //OSS
 static int deviceSampleRates[6] = { 11025, 16000, 22050, 32000, 44100, -1 };
 static int deviceBitRates[] = { 8, 16, -1 };
 #endif
 
 #if defined(QT_QWS_SL5XXX)
 ///#if defined(QT_QWS_EBX)
 
 #define DSPSTROUT "/dev/dsp"
 #define DSPSTRMIXEROUT "/dev/mixer"
 
 #ifdef SHARP
 #define DSPSTRIN "/dev/dsp1"
 #define DSPSTRMIXERIN "/dev/mixer1"
 #else
 #define DSPSTRIN "/dev/dsp"
 #define DSPSTRMIXERIN "/dev/mixer"
 #endif
 
 #else
 
+#ifdef QT_QWS_DEVFS
+#define DSPSTROUT "/dev/sound/dsp"
+#define DSPSTRIN "/dev/sound/dsp"
+#define DSPSTRMIXERIN "/dev/sound/mixer"
+#define DSPSTRMIXEROUT "/dev/sound/mixer"
+#else
 #define DSPSTROUT "/dev/dsp"
 #define DSPSTRIN "/dev/dsp"
 #define DSPSTRMIXERIN "/dev/mixer"
 #define DSPSTRMIXEROUT "/dev/mixer"
+#endif
 
 #endif
 
 //#define ZAURUS 0
 struct adpcm_state encoder_state;
 struct adpcm_state decoder_state;
 
 typedef struct {
                 int sampleRate;
                         /*      int fragSize; */
                         /*      int blockSize; */
                 int resolution; //bitrate
                 int channels; //number of channels
                 int fd; //file descriptor
                 int sd; //sound device descriptor
                 int numberSamples; //total number of samples
                 int SecondsToRecord; // number of seconds that should be recorded
                 float numberOfRecordedSeconds; //total number of samples recorded
                 int samplesToRecord; //number of samples to be recorded
                 int inVol; //input volume
                 int outVol; //output volume
                 int format; //wavfile format PCM.. ADPCM
                 const  char *fileName; //name of fiel to be played/recorded
 } fileParameters;
 
 fileParameters filePara;
 
 bool monitoring, recording, playing;
 bool stopped;
 QLabel *timeLabel;
 QSlider *timeSlider;
 int sd;
 
 Waveform* waveform;
 Device *soundDevice;
 
 
 #ifdef THREADED
 void quickRec()
 #else
                 void QtRec::quickRec()
 #endif
 {
 
                 odebug << ( filePara.numberSamples/filePara.sampleRate * filePara.channels ) << oendl;
                 odebug << "samples " << filePara.numberSamples << ", rate " << filePara.sampleRate
                                          << ", channels " << filePara.channels << oendl;
 
                 int total = 0;  // Total number of bytes read in so far.
                 int bytesWritten, number;
 
                 bytesWritten = 0;
                 number = 0;
                 QString num;
                 int level = 0;
                 int threshold = 0;
    int bits = filePara.resolution;
    odebug << "bits " << bits << "" << oendl;
 
                 if( filePara.resolution == 16 ) { //AFMT_S16_LE)
        odebug << "AFMT_S16_LE size " << filePara.SecondsToRecord << "" << oendl;
        odebug << "samples to record " << filePara.samplesToRecord << "" << oendl;
        odebug << "" << filePara.sd << "" << oendl;
                                 level = 7;
                                 threshold = 0;
 
                                 if( filePara.format == WAVE_FORMAT_DVI_ADPCM) {
           odebug << "start recording WAVE_FORMAT_DVI_ADPCM" << oendl;
 // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_DVI_ADPCM  >>>>>>>>>>>>>>>>>>>>>>
                                                 char abuf[ BUFSIZE/2 ];
                                                 short sbuf[ BUFSIZE ];
                                                 short sbuf2[ BUFSIZE ];
                                                 memset( abuf, 0, BUFSIZE/2);
                                                 memset( sbuf, 0, BUFSIZE);
                                                 memset( sbuf2, 0, BUFSIZE);
 
                                                 for(;;) {
                                                                 if ( stopped) {
                                                                                 odebug << "quickRec:: stopped" << oendl;
                                                                                 break;
                                                                 }
 
 //             number=::read( filePara.sd, sbuf, BUFSIZE);
                                                                 number =  soundDevice->devRead( filePara.sd, sbuf, BUFSIZE);
 
                                                                 if(number <= 0) {
                                                                                 perror("recording error ");
                                                                                 odebug << "" << filePara.fileName << " " << number << "" << oendl;
                                                                                 stopped = true;
                                                                                 return;
                                                                 }
                                                                         //if(stereo == 2) {
 //        adpcm_coder( sbuf2, abuf, number/2, &encoder_state);
                                                                 adpcm_coder( sbuf, abuf, number/2, &encoder_state);
 
                                                                 bytesWritten = ::write( filePara.fd , (short *)abuf, number/4);
 
                                                                 waveform->newSamples( sbuf, number );
 
                                                                 total += bytesWritten;
                                                                 filePara.numberSamples = total;
                                                                 timeSlider->setValue( total);
 
          printf("%d, bytes %d,total %d\r",number, bytesWritten, total);
          fflush(stdout);
 
                                          filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate * (float)2/ filePara.channels;
 
                                                                 qApp->processEvents();
                                                                 if( total >= filePara.samplesToRecord) {
                                                                                 stopped = true;
                                                                                 break;
                                                                 }
                                                 }
                                 } else {
                                                         // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_PCM   >>>>>>>>>>>>>>>>>>>>>>
                                                 odebug << "start recording WAVE_FORMAT_PCM" << oendl;
                                                 short inbuffer[ BUFSIZE ], outbuffer[ BUFSIZE ];
                                                 memset( inbuffer, 0, BUFSIZE);
                                                 memset( outbuffer, 0, BUFSIZE);
 
                                                 for(;;) {
                                                                 if ( stopped) {
                                                                                 odebug << "quickRec:: stopped" << oendl;
                                                                                 stopped = true;
                                                                                 break;  // stop if playing was set to false
                                                                                 return;
                                                                 }
 
                                                                 number = soundDevice->devRead( soundDevice->sd /*filePara.sd*/, (short *)inbuffer, BUFSIZE);
 
                                                                 if( number <= 0) {
                                                                                 perror( "recording error ");
                                                                                 odebug << filePara.fileName << oendl;
                                                                                 stopped = true;
                                                                                 return;
                                                                 }
 
                                                                 bytesWritten = ::write( filePara.fd , inbuffer, number);
                                                                 waveform->newSamples( inbuffer, number );
 
                                                                 if( bytesWritten < 0) {
                                                                                 perror("File writing error ");
                                                                                 stopped = true;
                                                                                 return;
                                                                 }
 
                                                                 total += bytesWritten;
 
                                                                 filePara.numberSamples = total;
 
                                                                 if( filePara.SecondsToRecord != 0)
                                                                                 timeSlider->setValue( total);
          printf("%d, bytes %d,total %d\r",number,  bytesWritten , total);
          fflush(stdout);
 
                                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate
                                                                                 / (float)2/filePara.channels;
                                                                 qApp->processEvents();
 
                                                                 if( total >= filePara.samplesToRecord) {
                                                                                 stopped = true;
                                                                                 break;
                                                                 }
                                                 }
                                 } //end main loop
 
                 } else {
 // <<<<<<<<<<<<<<<<<<<<<<<   format = AFMT_U8;
                                 unsigned char unsigned_inbuffer[ BUFSIZE ], unsigned_outbuffer[ BUFSIZE ];
                                 memset( unsigned_inbuffer, 0, BUFSIZE);
                                 memset( unsigned_outbuffer, 0, BUFSIZE);
 
                                 for(;;) {
                                                 if ( stopped) {
                                                                 odebug << "quickRec:: stopped" << oendl;
                                                                 break;  // stop if playing was set to false
                                                 }
 
                                                 number = ::read( soundDevice->sd /*filePara.sd*/ , unsigned_inbuffer, BUFSIZE);
                                                 bytesWritten = ::write( filePara.fd , unsigned_inbuffer, number);
             waveform->newSamples( (const short *) unsigned_inbuffer, number );
 
                                                 if(bytesWritten < 0) {
                                                                 stopped = true;
                                                                 QMessageBox::message("Note","<p>There was a problem writing to the file</p>");
                                                                 perror("File writing error ");
                                                                 return;
                                                 }
 
                                                 total += bytesWritten;
                                                 filePara.numberSamples = total;
                                                         //             printf("%d, bytes %d,total %d \r",number,  bytesWritten , total);
                                                         //             fflush(stdout);
                                                 if( filePara.SecondsToRecord !=0)
                                                                 timeSlider->setValue( total);
 
                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate;
 
                                                 qApp->processEvents();
                                                 if( total >= filePara.samplesToRecord) {
                                                                 stopped = true;
                                                                 break;
                                                 }
                                 } //end main loop
                 }
 } /// END quickRec()
 
 
 #ifdef THREADED
 void playIt()
 #else
                 void QtRec::playIt()
 #endif
 {
                 int bytesWritten = 0;
                 int number = 0;
                 int total = 0;  // Total number of bytes read in so far.
                 if( filePara.resolution == 16 ) { //AFMT_S16_LE) {
                                 if( filePara.format == WAVE_FORMAT_DVI_ADPCM) {
                                                 char abuf[ BUFSIZE / 2 ];
                                                 short sbuf[ BUFSIZE ];
                                                 short sbuf2[ BUFSIZE * 2 ];
                                                 memset( abuf, 0, BUFSIZE / 2);
                                                 memset( sbuf, 0, BUFSIZE);
                                                 memset( sbuf2, 0, BUFSIZE * 2);
 // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_DVI_ADPCM  >>>>>>>>>>>>>>>>>>>>>>
                                                 for(;;) {  // play loop
                                                                 if ( stopped) {
                                                                                 break;
                                                                                 return;
                                                                 }// stop if playing was set to false
 
                                                                 number = ::read( filePara.fd, abuf, BUFSIZE / 2);
                                                                 adpcm_decoder( abuf, sbuf, number * 2, &decoder_state);
 
 //                 for (int i=0;i< number * 2; 2 * i++) { //2*i is left channel
 //                     sbuf2[i+1]=sbuf2[i]=sbuf[i];
 //                 }
                                                                 bytesWritten = write ( filePara.sd, sbuf, number * 4);
                                                                 waveform->newSamples( (const short *)sbuf, number *4);
                                                                         //          if(filePara.channels==1)
                                                                         //              total += bytesWritten/2; //mono
                                                                         //          else
                                                                 total += bytesWritten;
                                                                 filePara.numberSamples = total/4;
                                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / 2;
 
                                                                 timeSlider->setValue( total/4);
 //            timeString.sprintf("%.2f", filePara.numberOfRecordedSeconds);
 //         if(filePara.numberOfRecordedSeconds>1)
 //            timeLabel->setText( timeString+ tr(" seconds"));
 //                              printf("playing number %d, bytes %d, total %d\n",number,  bytesWritten, total/4);
 //                              fflush(stdout);
 
                                                                 qApp->processEvents();
 
                                                                 if( /*total >= filePara.numberSamples || */ bytesWritten == 0) {
 //            if( total >= filePara.numberSamples ){//||  secCount > filePara.numberOfRecordedSeconds ) {
                                                                                 stopped = true;
                                                                                 break;
                                                                 }
                                                 }
                                 } else {
                                                         // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_PCM   >>>>>>>>>>>>>>>>>>>>>>
                                                 short inbuffer[ BUFSIZE ], outbuffer[ BUFSIZE ];
                                                 memset( inbuffer, 0, BUFSIZE);
                                                 memset( outbuffer, 0, BUFSIZE);
 
                                                 for(;;) {  // play loop
                                                                 if ( stopped) {
                                                                                 break;
                                                                                 return;
                                                                 }
 // stop if playing was set to false
                                                                 number = ::read( filePara.fd, inbuffer, BUFSIZE);
 //                 for (int i=0;i< number * 2; 2 * i++) { //2*i is left channel
 //                       //        for (int i=0;i< number ; i++) { //2*i is left channel
 //                     outbuffer[i+1]= outbuffer[i]=inbuffer[i];
 //                 }
                                                                 bytesWritten = ::write( filePara.sd, inbuffer, number);
                                                                 waveform->newSamples( inbuffer, number);
                                                                         //-------------->>>> out to device
                                                                         //        total+=bytesWritten;
                                                                         //          if(filePara.channels==1)
                                                                         //              total += bytesWritten/2; //mono
                                                                         //          else
                                                                 total += bytesWritten;
                                                                 timeSlider->setValue( total);
 
                                                                 filePara.numberSamples = total;
                                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / (float)2;
 
 //             timeString.sprintf("%.2f",filePara.numberOfRecordedSeconds);
 //             timeLabel->setText( timeString + tr(" seconds"));
 
                                                                 qApp->processEvents();
 
                                                                 if( /*total >= filePara.numberSamples || */ bytesWritten == 0) {
                                                                                 owarn << "Jane! Stop this crazy thing!" << oendl;
                                                                                 stopped = true;
 //                playing = false;
                                                                                 break;
                                                                 }
                                                 }
 //             printf("\nplaying number %d, bytes %d, total %d\r",number,  bytesWritten, total);
 //             fflush(stdout);
                                 } //end loop
                 } else {
 /////////////////////////////// format = AFMT_U8;
                                 unsigned char unsigned_inbuffer[ BUFSIZE ]; //, unsigned_outbuffer[BUFSIZE];
                                 memset( unsigned_inbuffer, 0, BUFSIZE);
                                 for(;;) {
 // main loop
                                                 if (stopped) {
                                                                 break;  // stop if playing was set to false
                                                                 return;
                                                 }
                                                 number = ::read( filePara.fd, unsigned_inbuffer, BUFSIZE);
 //data = (val >> 8) ^ 0x80;
                                                         //          unsigned_outbuffer = (unsigned_inbuffer >> 8) ^ 0x80;
                                                 bytesWritten = write ( filePara.sd, unsigned_inbuffer, number);
                                                 waveform->newSamples(  (const short *)unsigned_inbuffer, bytesWritten );
                                                 total += bytesWritten;
 
             timeSlider->setValue( total);
                                                 filePara.numberSamples = total;
 
                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate;
 //          timeString.sprintf("%.2f",filePara.numberOfRecordedSeconds);
 //          timeLabel->setText( timeString + tr(" seconds"));
                                                 qApp->processEvents();
 
                                                 if( /*total >= filePara.numberSamples || */ bytesWritten == 0) {
 //         if( total >= filePara.numberSamples ) {
                                                                 stopped = true;
                                                                 break;
                                                 }
 //                      printf("Writing number %d, bytes %d, total %d, numberSamples %d\r",number,  bytesWritten , total, filePara.numberSamples);
 //                      fflush(stdout);
                                 }
                 }
 }
 
 
 QtRec::QtRec( QWidget* parent,  const char* name, WFlags fl )
                                 : QWidget( parent, name, fl )
 {
                 if ( !name )
                                 setName( "OpieRec" );
                 init();
                 initConfig();
                 initConnections();
                 renameBox = 0;
 
 // open sound device to get volumes
                 Config hwcfg("OpieRec");
                 hwcfg.setGroup("Hardware");
 
 
                 soundDevice = new Device( this,
                                                                                                                         hwcfg.readEntry( "Audio",DSPSTROUT),
                                                                                                                         hwcfg.readEntry( "Mixer",DSPSTRMIXEROUT), false);
 //      soundDevice = new Device( this, hwcfg.readEntry( "Audio","hw:0"), hwcfg.readEntry( "Mixer","hw:0"), false);
 
 //     soundDevice->setDeviceFormat(AFMT_S16_LE);
 //     soundDevice->setDeviceChannels(1);
 //     soundDevice->setDeviceRate( 22050);
 
                 getInVol();
                 getOutVol();
 
                 soundDevice->closeDevice( true);
                 soundDevice->sd = -1;
                 soundDevice = 0;
                 wavFile = 0;
 
 //      if( soundDevice) delete soundDevice;
 
                 initIconView();
 
                 if( autoMute)
                                 doMute( true);
                 ListView1->setFocus();
                 playing = false;
 }
 
 QtRec::~QtRec() {
 //   if( soundDevice) delete soundDevice;
 
 }
 
 void QtRec::cleanUp() {
 
                 if( !stopped) {
                                 stopped = true;
                                 endRecording();
                 }
 
                 ListView1->clear();
 
                 if( autoMute)
                                 doMute(false);
 
 //      if( wavFile) delete wavFile;
 // if(soundDevice) delete soundDevice;
 }
 
 void QtRec::init() {
 
                 needsStereoOut = false;
                 QPixmap image3( ( const char** ) image3_data );
                 QPixmap image4( ( const char** ) image4_data );
                 QPixmap image6( ( const char** ) image6_data );
 
                 stopped = true;
                 setCaption( tr( "OpieRecord " ) + QString::number(VERSION) );
                 QGridLayout *layout = new QGridLayout( this );
                 layout->setSpacing( 2);
                 layout->setMargin( 2);
 
                 TabWidget = new QTabWidget( this, "TabWidget" );
                 layout->addMultiCellWidget(TabWidget, 0, 7, 0, 8);
 //    TabWidget->setTabShape(QTabWidget::Triangular);
 
                         ///**********<<<<<<<<<<<<>>>>>>>>>>>>***************
                 tab = new QWidget( TabWidget, "tab" );
 
                 QGridLayout *layout1 = new QGridLayout( tab);
                 layout1->setSpacing( 2);
                 layout1->setMargin( 2);
 
                 timeSlider = new QSlider( 0,100,10,0, QSlider::Horizontal, tab, (const char *) "timeSlider" );
                 layout1->addMultiCellWidget( timeSlider, 1, 1, 0, 3);
 
         //      timeLabel = new QLabel( tab, "TimeLabel" );
         //      layout1->addMultiCellWidget( timeLabel, 0, 0, 0, 3);
 
         //      playLabel2 = new QLabel(tab, "PlayLabel2" );
         //      playLabel2->setText(tr("Play") );
         //      playLabel2->setFixedHeight( 18);
         //      layout1->addMultiCellWidget( playLabel2, 0, 0, 4, 4);
 
                 Stop_PushButton = new QPushButton(  tab, "Stop_PushButton" );
                 layout1->addMultiCellWidget( Stop_PushButton, 1, 1, 4, 4);
                 Stop_PushButton->setFixedSize( 22, 22);
                 Stop_PushButton->setPixmap( image4 );
 
                 toBeginningButton = new QPushButton(  tab, "Beginning_PushButton" );
                 layout1->addMultiCellWidget(toBeginningButton, 1, 1, 5, 5);
                 toBeginningButton->setFixedSize( 22, 22);
                 toBeginningButton->setPixmap( Resource::loadPixmap("fastback") );
 
                 toEndButton = new QPushButton(  tab, "End_PushButton" );
                 layout1->addMultiCellWidget( toEndButton, 1, 1, 6, 6);
                 toEndButton->setFixedSize( 22, 22);
                 toEndButton->setPixmap(  Resource::loadPixmap( "fastforward" )  );
 
         //      QLabel *recLabel2;
         //      recLabel2 = new QLabel( tab, "recLabel2" );
         //      recLabel2->setText(tr("Rec"));
         //      recLabel2->setFixedHeight( 18);
         //      layout1->addMultiCellWidget( recLabel2, 0, 0, 7, 7);
 
                 Rec_PushButton = new QPushButton( tab, "Rec_PushButton" );
                 layout1->addMultiCellWidget(  Rec_PushButton, 1, 1, 7, 7);
                 Rec_PushButton->setFixedSize( 22, 22);
                 Rec_PushButton->setPixmap( image6 );
 
                 t = new QTimer( this );
                 connect( t, SIGNAL( timeout() ), SLOT( timerBreak() ) );
 
                 rewindTimer = new QTimer( this );
                 connect( rewindTimer, SIGNAL( timeout() ),
                                                  this, SLOT( rewindTimerTimeout() ) );
 
                 forwardTimer = new QTimer( this );
                 connect( forwardTimer, SIGNAL( timeout() ),
                                                  this, SLOT( forwardTimerTimeout() ) );
 
                 deleteSoundButton  = new QPushButton( tab, "deleteSoundButton" );
                 layout1->addMultiCellWidget( deleteSoundButton, 1, 1, 8, 8);
                 deleteSoundButton->setText( tr( "Del" ) );
 
                 ListView1 = new QListView( tab, "IconView1" );
                 layout1->addMultiCellWidget( ListView1, 2, 2, 0, 8);
 
                 ListView1->addColumn( tr( "Name" ) );
         //      ListView1->setColumnWidth( 0, 140);
                 ListView1->setSorting( 1, false);
                 ListView1->addColumn( tr( "Time" ) ); //in seconds
         //      ListView1->setColumnWidth( 1, -1);
         //      ListView1->addColumn( tr("Location") );
         //      ListView1->setColumnWidth( 2, -1);
         //      ListView1->addColumn( tr("Date") );
         //      ListView1->setColumnWidth( 3, -1);
                 ListView1->setColumnWidthMode(0, QListView::Maximum);
         //      ListView1->setColumnWidthMode(1, QListView::Maximum);
 
         //      ListView1->setColumnWidthMode( 0, QListView::Manual);
                 ListView1->setColumnAlignment( 1, QListView::AlignCenter);
         //      ListView1->setColumnAlignment( 2, QListView::AlignRight);
         //      ListView1->setColumnAlignment( 3, QListView::AlignLeft);
                 ListView1->setAllColumnsShowFocus( true );
                 QPEApplication::setStylusOperation( ListView1->viewport(), QPEApplication::RightOnHold);
 
                 TabWidget->insertTab( tab, tr( "Files" ) );
 
                         ///**********<<<<<<<<<<<<>>>>>>>>>>>>***************
                 tab_3 = new QWidget( TabWidget, "tab_3" );
                 QGridLayout *glayout3 = new QGridLayout( tab_3 );
                 glayout3->setSpacing( 2);
                 glayout3->setMargin( 2);
                         ////////////////////////////////////
                 sampleGroup = new QGroupBox( tab_3, "samplegroup" );
                 sampleGroup->setTitle( tr( "Sample Rate" ) );
                 sampleGroup->setFixedSize( 95,50);
 
                 sampleRateComboBox = new QComboBox( false, sampleGroup, "SampleRateComboBox" );
                 sampleRateComboBox->setGeometry( QRect( 10, 20, 80, 25 ) );
 //#ifndef QT_QWS_EBX
                 QString s;
                 int z = 0;
                 while( deviceSampleRates[z] != -1) {
                                 sampleRateComboBox->insertItem( s.setNum( deviceSampleRates[z], 10));
                                 z++;
                 }
 
 
                 glayout3->addMultiCellWidget(  sampleGroup, 0, 0, 0, 0);
 
                 sizeGroup= new QGroupBox( tab_3, "sizeGroup" );
                 sizeGroup->setTitle( tr( "Limit Size" ) );
                 sizeGroup->setFixedSize( 80, 50);
 
                 sizeLimitCombo = new QComboBox( false, sizeGroup, "sizeLimitCombo" );
                 sizeLimitCombo ->setGeometry( QRect( 5, 20, 70, 25 ) );
                 sizeLimitCombo->insertItem(tr("Unlimited"));
 
                 for(int i=1;i<13; i++) {
                                 sizeLimitCombo->insertItem( QString::number( i * 5));
                 }
 
 
                 glayout3->addMultiCellWidget(  sizeGroup, 0, 0, 1, 1);
                 dirGroup = new QGroupBox( tab_3, "dirGroup" );
                 dirGroup->setTitle( tr( "File Directory" ) );
                 dirGroup->setFixedSize( 130, 50);
 
                 directoryComboBox = new QComboBox( false, dirGroup, "dirGroup" );
                 directoryComboBox->setGeometry( QRect( 10, 15, 115, 25 ) );
 
                 glayout3->addMultiCellWidget(  dirGroup, 1, 1, 0, 0);
 
                 bitGroup = new QGroupBox( tab_3, "bitGroup" );
                 bitGroup->setTitle( tr( "Bit Depth" ) );
                 bitGroup->setFixedSize( 65, 50);
 
                 bitRateComboBox = new QComboBox( false, bitGroup, "BitRateComboBox" );
 
                 z = 0;
                 while( deviceBitRates[z] != -1) {
                                 bitRateComboBox->insertItem( s.setNum( deviceBitRates[z], 10) );
                                 z++;
                 }
 
                 bitRateComboBox->setGeometry( QRect( 5, 20, 50, 25 ) );
 
                 glayout3->addMultiCellWidget(  bitGroup, 1, 1, 1, 1);
 
                 compressionCheckBox = new QCheckBox ( tr("Wave Compression (smaller files)"), tab_3 );
 
                 autoMuteCheckBox = new QCheckBox ( tr("Auto Mute"), tab_3 );
                 stereoCheckBox = new QCheckBox ( tr("Stereo"), tab_3 );
 
                 glayout3->addMultiCellWidget( compressionCheckBox, 2, 2, 0, 3);
                 glayout3->addMultiCellWidget( autoMuteCheckBox, 3, 3, 0, 0);
                 glayout3->addMultiCellWidget( stereoCheckBox, 3, 3, 1, 1);
 
                 tab_5 = new QWidget( TabWidget, "tab_5" );
 
                 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->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)5, (QSizePolicy::SizeType)3, waveform->sizePolicy().hasHeightForWidth() ) );
                 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);
 //      odebug << "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()) {
                                                 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( 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;
                 }