Adaptions for QT_QWS_DEVFS

3 files changed, 21 insertions, 4 deletions

diff --git a/core/multimedia/opieplayer/audiodevice.cpp b/core/multimedia/opieplayer/audiodevice.cpp
index d01d2ba..6a38fc9 100644
--- a/core/multimedia/opieplayer/audiodevice.cpp
+++ b/core/multimedia/opieplayer/audiodevice.cpp
@@ -1,313 +1,322 @@
 /**********************************************************************
  ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
  **
  ** This file is part of Qtopia Environment.
  **
  ** This file may be distributed and/or modified under the terms of the
  ** GNU General Public License version 2 as published by the Free Software
  ** Foundation and appearing in the file LICENSE.GPL included in the
  ** packaging of this file.
  **
  ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  **
  ** See http://www.trolltech.com/gpl/ for GPL licensing information.
  **
  ** Contact info@trolltech.com if any conditions of this licensing are
  ** not clear to you.
  **
  **********************************************************************/
 // L.J.Potter added better error code Fri 02-15-2002 14:37:47
 
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 #include <qmessagebox.h>
 
 #include "audiodevice.h"
 
 
 #include <errno.h>
 
 #if ( defined Q_WS_QWS || defined(_WS_QWS_) ) && !defined(QT_NO_COP)
 #include "qpe/qcopenvelope_qws.h"
 #endif
 
 #if defined(Q_WS_X11) || defined(Q_WS_QWS)
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/soundcard.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 
 # if defined(QT_QWS_IPAQ)
 static const int sound_fragment_shift = 14;
 # else
 static const int sound_fragment_shift = 16;
 # endif
 static const int sound_fragment_bytes = (1<<sound_fragment_shift);
 //#endif
 
 
 class AudioDevicePrivate {
 public:
     int handle;
     unsigned int frequency;
     unsigned int channels;
     unsigned int bytesPerSample;
     unsigned int bufferSize;
 //#ifndef Q_OS_WIN32
     bool can_GETOSPACE;
     char* unwrittenBuffer;
     unsigned int unwritten;
 //#endif
 
     static int dspFd;
     static bool muted;
     static unsigned int leftVolume;
     static unsigned int rightVolume;
 };
 
 
 #ifdef Q_WS_QWS
 // This is for keeping the device open in-between playing files when
 // the device makes clicks and it starts to drive you insane! :)
 // Best to have the device not open when not using it though
 //#define KEEP_DEVICE_OPEN
 #endif
 
 
 int AudioDevicePrivate::dspFd = 0;
 bool AudioDevicePrivate::muted = FALSE;
 unsigned int AudioDevicePrivate::leftVolume = 0;
 unsigned int AudioDevicePrivate::rightVolume = 0;
 
 
 void AudioDevice::getVolume( unsigned int& leftVolume, unsigned int& rightVolume, bool &muted ) {
     muted = AudioDevicePrivate::muted;
     unsigned int volume;
+#ifdef QT_QWS_DEVFS
+    int mixerHandle = open( "/dev/sound/mixer", O_RDWR );
+#else
     int mixerHandle = open( "/dev/mixer", O_RDWR );
+#endif
     if ( mixerHandle >= 0 ) {
         if(ioctl( mixerHandle, MIXER_READ(0), &volume )==-1)
             perror("ioctl(\"MIXER_READ\")");
         close( mixerHandle );
     } else
         perror("open(\"/dev/mixer\")");
     leftVolume  = ((volume & 0x00FF) << 16) / 101;
     rightVolume = ((volume & 0xFF00) <<  8) / 101;
 }
 
 
 void AudioDevice::setVolume( unsigned int leftVolume, unsigned int rightVolume, bool muted ) {
     AudioDevicePrivate::muted = muted;
     if ( muted ) {
         AudioDevicePrivate::leftVolume = leftVolume;
         AudioDevicePrivate::rightVolume = rightVolume;
         leftVolume = 0;
         rightVolume = 0;
     } else {
         leftVolume  = ( (int) leftVolume < 0 ) ? 0 : ((  leftVolume > 0xFFFF ) ? 0xFFFF :  leftVolume );
         rightVolume = ( (int)rightVolume < 0 ) ? 0 : (( rightVolume > 0xFFFF ) ? 0xFFFF : rightVolume );
     }
       // Volume can be from 0 to 100 which is 101 distinct values
     unsigned int rV = (rightVolume * 101) >> 16;
 
 # if 0
     unsigned int lV = (leftVolume  * 101) >> 16;
     unsigned int volume = ((rV << 8) & 0xFF00) | (lV & 0x00FF);
     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
         if(ioctl( mixerHandle, MIXER_WRITE(0), &volume ) ==-1)
             perror("ioctl(\"MIXER_WRITE\")");
         close( mixerHandle );
     } else
         perror("open(\"/dev/mixer\")");
 
 # else
       // This is the way this has to be done now I guess, doesn't allow for
       // independant right and left channel setting, or setting for different outputs
     Config cfg("qpe"); // qtopia is "Sound"
     cfg.setGroup("Volume"); // qtopia is "Settings"
     cfg.writeEntry("VolumePercent",(int)rV); //qtopia is Volume
 # endif
 
 //#endif
 //    qDebug( "setting volume to: 0x%x", volume ); 
 #if ( defined Q_WS_QWS || defined(_WS_QWS_) ) && !defined(QT_NO_COP)
       // Send notification that the volume has changed
     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << muted; 
 #endif
 }
 
 
 
 AudioDevice::AudioDevice( unsigned int f, unsigned int chs, unsigned int bps ) {
    //    qDebug("creating new audio device");
 //     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << TRUE; 
     d = new AudioDevicePrivate;
     d->frequency = f;
     d->channels = chs;
     d->bytesPerSample = bps;
     //    qDebug("%d",bps);
     int format=0;
     if( bps == 8)  format  = AFMT_U8;
     else if( bps <= 0) format = AFMT_S16_LE;
     else format = AFMT_S16_LE;
     //    qDebug("AD- freq %d, channels %d, b/sample %d, bitrate %d",f,chs,bps,format);
     connect( qApp, SIGNAL( volumeChanged(bool) ), this, SLOT( volumeChanged(bool) ) );
 
     int fragments = 0x10000 * 8 + sound_fragment_shift;
     int capabilities = 0;
 
     
 #ifdef KEEP_DEVICE_OPEN
     if ( AudioDevicePrivate::dspFd == 0 ) {
 #endif
+#ifdef QT_QWS_DEVFS
+        if ( ( d->handle = ::open( "/dev/sound/dsp", O_WRONLY ) ) < 0 ) {
+#else
         if ( ( d->handle = ::open( "/dev/dsp", O_WRONLY ) ) < 0 ) {
+#endif
 
-//            perror("open(\"/dev/dsp\") sending to /dev/null instead");
         perror("open(\"/dev/dsp\")");
         QString errorMsg=tr("Somethin's wrong with\nyour sound device.\nopen(\"/dev/dsp\")\n")+(QString)strerror(errno)+tr("\n\nClosing player now.");
         QMessageBox::critical(0, "Vmemo", errorMsg, tr("Abort"));
         exit(-1); //harsh?
-//            d->handle = ::open( "/dev/null", O_WRONLY );
-          // WTF?!?!
         }
 #ifdef KEEP_DEVICE_OPEN 
         AudioDevicePrivate::dspFd = d->handle;
     } else {
         d->handle = AudioDevicePrivate::dspFd;
     }
 #endif
 
     if(ioctl( d->handle, SNDCTL_DSP_GETCAPS, &capabilities )==-1)
         perror("ioctl(\"SNDCTL_DSP_GETCAPS\")");
     if(ioctl( d->handle, SNDCTL_DSP_SETFRAGMENT, &fragments )==-1)
         perror("ioctl(\"SNDCTL_DSP_SETFRAGMENT\")");
     if(ioctl( d->handle, SNDCTL_DSP_SETFMT, & format )==-1)
         perror("ioctl(\"SNDCTL_DSP_SETFMT\")");
     //    qDebug("freq %d", d->frequency);
     if(ioctl( d->handle, SNDCTL_DSP_SPEED, &d->frequency )==-1)
         perror("ioctl(\"SNDCTL_DSP_SPEED\")");
     //    qDebug("channels %d",d->channels);
     if ( ioctl( d->handle, SNDCTL_DSP_CHANNELS, &d->channels ) == -1 ) {
         d->channels = ( d->channels == 1 ) ? 2 : d->channels;
         if(ioctl( d->handle, SNDCTL_DSP_CHANNELS, &d->channels )==-1)
             perror("ioctl(\"SNDCTL_DSP_CHANNELS\")");
     }
 //   QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << FALSE; 
 
     d->bufferSize = sound_fragment_bytes;
     d->unwrittenBuffer = new char[d->bufferSize];
     d->unwritten = 0;
     d->can_GETOSPACE = TRUE; // until we find otherwise
  
       //if ( chs != d->channels )       qDebug( "Wanted %d, got %d channels", chs, d->channels );
       //if ( f != d->frequency )        qDebug( "wanted %dHz, got %dHz", f, d->frequency );
       //if ( capabilities & DSP_CAP_BATCH )   qDebug( "Sound card has local buffer" );
       //if ( capabilities & DSP_CAP_REALTIME )qDebug( "Sound card has realtime sync" );
       //if ( capabilities & DSP_CAP_TRIGGER ) qDebug( "Sound card has precise trigger" );
       //if ( capabilities & DSP_CAP_MMAP )    qDebug( "Sound card can mmap" );
     
 }
     
 
 AudioDevice::~AudioDevice() {
    //    qDebug("destryo audiodevice");
 //    QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << TRUE;
     
 # ifndef KEEP_DEVICE_OPEN 
     close( d->handle );     // Now it should be safe to shut the handle
 # endif
     delete d->unwrittenBuffer;
     delete d;
 //   QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << FALSE;
     
 }
 
 
 void AudioDevice::volumeChanged( bool muted )
 {
     AudioDevicePrivate::muted = muted;
 }
 
 
 void AudioDevice::write( char *buffer, unsigned int length )
 {
     int t = ::write( d->handle, buffer, length );
     if ( t<0 ) t = 0;
     if ( t != (int)length) {
        //        qDebug("Ahhh!! memcpys 1");
         memcpy(d->unwrittenBuffer,buffer+t,length-t);
         d->unwritten = length-t;
     }
 //#endif
 }
 
 
 unsigned int AudioDevice::channels() const
 {
     return d->channels;
 }
 
 
 unsigned int AudioDevice::frequency() const
 {
     return d->frequency;
 }
 
 
 unsigned int AudioDevice::bytesPerSample() const
 {
     return d->bytesPerSample;
 }
 
 
 unsigned int AudioDevice::bufferSize() const
 {
     return d->bufferSize;
 }
 
 unsigned int AudioDevice::canWrite() const
 {
     audio_buf_info info;
     if ( d->can_GETOSPACE && ioctl(d->handle,SNDCTL_DSP_GETOSPACE,&info) ) {
         d->can_GETOSPACE = FALSE;
         fcntl( d->handle, F_SETFL, O_NONBLOCK );
     }
     if ( d->can_GETOSPACE ) {
         int t = info.fragments * sound_fragment_bytes;
         return QMIN(t,(int)bufferSize());
     } else {
         if ( d->unwritten ) {
             int t = ::write( d->handle, d->unwrittenBuffer, d->unwritten );
             if ( t<0 ) t = 0;
             if ( (unsigned)t!=d->unwritten ) {
                 memcpy(d->unwrittenBuffer,d->unwrittenBuffer+t,d->unwritten-t);
                 d->unwritten -= t;
             } else {
                 d->unwritten = 0;
             }
         }
         if ( d->unwritten )
             return 0;
         else
             return d->bufferSize;
     }
 }
 
 
 int AudioDevice::bytesWritten() {
     int buffered = 0;
     if ( ioctl( d->handle, SNDCTL_DSP_GETODELAY, &buffered ) ) {
        //        qDebug( "failed to get audio device position" );
         return -1;
     }
     return buffered;
 }
 
diff --git a/core/multimedia/opieplayer/libflash/libflashplugin.cpp b/core/multimedia/opieplayer/libflash/libflashplugin.cpp
index 538c695..78cf555 100644
--- a/core/multimedia/opieplayer/libflash/libflashplugin.cpp
+++ b/core/multimedia/opieplayer/libflash/libflashplugin.cpp
@@ -1,223 +1,227 @@
 /**********************************************************************
 ** Copyright (C) 2001 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include "libflashplugin.h"
 
 #if 0
 
 bool LibFlashPlugin::audioReadSamples( short *output, int channel, long samples, int stream ) {
 }
 
 
 bool LibFlashPlugin::audioReReadSamples( short *output, int channel, long samples, int stream ) {
 }
 
 
 bool LibFlashPlugin::audioReadMonoSamples( short *output, long samples, long& samplesRead, int stream ) {
     samplesRead = samples;
 }
 
 
 bool LibFlashPlugin::audioReadStereoSamples( short *output, long samples, long& samplesRead, int stream ) {
 }
 
 
 bool LibFlashPlugin::videoReadFrame( unsigned char **output_rows, int in_x, int in_y, int in_w, int in_h, ColorFormat color_model, int stream ) {
 }
 
 
 bool LibFlashPlugin::videoReadScaledFrame( unsigned char **output_rows, int in_x, int in_y, int in_w, int in_h, int out_w, int out_h, ColorFormat color_model, int stream ) {
 /*
     int format = MPEG3_RGB565;
     switch ( color_model ) {
 	case RGB565:	format = MPEG3_RGB565;   break;
 	case RGBA8888:	format = MPEG3_RGBA8888; break;
 	case BGRA8888:	format = MPEG3_BGRA8888; break;
     }
 */
 }
 
 
 bool LibFlashPlugin::videoReadYUVFrame( char *y_output, char *u_output, char *v_output, int in_x, int in_y, int in_w, int in_h, int stream ) {
 }
 
 
 FlashHandle file;
 FlashDisplay *fd;
 
 #endif
 
 
 LibFlashPlugin::LibFlashPlugin() {
     file = NULL;
     fd = 0;
 }
 #include <stdio.h>
 #include <stdlib.h>
 static int readFile(const char *filename, char **buffer, long *size)
 {
     FILE *in;
     char *buf;
     long length;
 
     printf("read files\n");
 
     in = fopen(filename,"r");
     if (in == 0) {
 	perror(filename);
 	return -1;
     }
     fseek(in,0,SEEK_END);
     length = ftell(in);
     rewind(in);
     buf = (char *)malloc(length);
     fread(buf,length,1,in);
     fclose(in);
 
     *size = length;
     *buffer = buf;
 
     return length;
 }
 
 static void showUrl(char *url, char * /*target*/, void * /*client_data*/) {
     printf("get url\n");
     printf("GetURL : %s\n", url);
 }
 
 static void getSwf(char *url, int level, void *client_data) {
     FlashHandle flashHandle = (FlashHandle) client_data;
     char *buffer;
     long size;
 
     printf("get swf\n");
 
     printf("LoadMovie: %s @ %d\n", url, level);
     if (readFile(url, &buffer, &size) > 0) {
 	FlashParse(flashHandle, level, buffer, size);
     }
 }
 
 bool LibFlashPlugin::open( const QString& fileName ) {
 
     printf("opening file\n");
 
     delete fd;
     fd = new FlashDisplay;
     fd->pixels = new int[320*240*4];
     fd->width = 200;
     fd->bpl = 320*2;
     fd->height = 300;
     fd->depth = 16;
     fd->bpp = 2;
     fd->flash_refresh = 25;
     fd->clip_x = 0;
     fd->clip_y = 0;
     fd->clip_width = 0;
     fd->clip_height = 0;
 
     char *buffer;
     long size;
     int status;
     struct FlashInfo fi;
 
     if (readFile(fileName.latin1(), &buffer, &size) < 0)
 	    exit(2);
 
     if (!(file = FlashNew()))
 	    exit(1);
 
     do
 	status = FlashParse(file, 0, buffer, size);
     while (status & FLASH_PARSE_NEED_DATA);
 
     free(buffer);
     FlashGetInfo(file, &fi);
     //FlashSettings(flashHandle, PLAYER_LOOP);
     FlashGraphicInit(file, fd);
+#ifdef QT_QWS_DEVFS
+    FlashSoundInit(file, "/dev/sound/dsp");
+#else
     FlashSoundInit(file, "/dev/dsp");
+#endif
     FlashSetGetUrlMethod(file, showUrl, 0);
     FlashSetGetSwfMethod(file, getSwf, (void*)file);
 
     printf("opened file\n");
 }
 
 // If decoder doesn't support audio then return 0 here
 bool LibFlashPlugin::audioSetSample( long sample, int stream ) { return TRUE; }
 long LibFlashPlugin::audioGetSample( int stream ) { return 0; }
 //bool LibFlashPlugin::audioReadMonoSamples( short *output, long samples, long& samplesRead, int stream ) { return TRUE; }
 //bool LibFlashPlugin::audioReadStereoSamples( short *output, long samples, long& samplesRead, int stream ) { return FALSE; }
 bool LibFlashPlugin::audioReadSamples( short *output, int channels, long samples, long& samplesRead, int stream ) { return FALSE; }
 //bool LibFlashPlugin::audioReadSamples( short *output, int channel, long samples, int stream ) { return TRUE; }
 //bool LibFlashPlugin::audioReReadSamples( short *output, int channel, long samples, int stream ) { return TRUE; }
 
 // If decoder doesn't support video then return 0 here
 int LibFlashPlugin::videoStreams() { return 1; }
 int LibFlashPlugin::videoWidth( int stream ) { return 300; }
 int LibFlashPlugin::videoHeight( int stream ) { return 200; }
 double LibFlashPlugin::videoFrameRate( int stream ) { return 25.0; }
 int LibFlashPlugin::videoFrames( int stream ) { return 1000000; }
 bool LibFlashPlugin::videoSetFrame( long frame, int stream ) { return TRUE; }
 long LibFlashPlugin::videoGetFrame( int stream ) { return 0; }
 bool LibFlashPlugin::videoReadFrame( unsigned char **output_rows, int in_x, int in_y, int in_w, int in_h, ColorFormat color_model, int stream ) { return TRUE; }
 #include <time.h>
 bool LibFlashPlugin::videoReadScaledFrame( unsigned char **output_rows, int in_x, int in_y, int in_w, int in_h, int out_w, int out_h, ColorFormat color_model, int stream ) {
         struct timeval wd;
         FlashEvent fe;
 
 /*
     delete fd;
     fd = new FlashDisplay;
     fd->pixels = output_rows[0];
     fd->width = 300; // out_w;
     fd->bpl = 640; // out_w*2;
     fd->height = 200;//out_h;
     fd->depth = 16;
     fd->bpp = 2;
     fd->flash_refresh = 50;
     fd->clip_x = 0;//in_x;
     fd->clip_y = 0;//in_y;
     fd->clip_width = 300;//in_w;
     fd->clip_height = 200;//in_h;
     FlashGraphicInit(file, fd);
 */
 
         long cmd = FLASH_WAKEUP;
         FlashExec(file, cmd, 0, &wd);
 
 	fe.type = FeRefresh;
 	cmd = FLASH_EVENT;
         FlashExec(file, cmd, &fe, &wd);
 /*
 	for (int i = 0; i < out_h; i++)
 	    memcpy( output_rows[i], (char*)fd->pixels + i*fd->bpl, QMIN( fd->width * fd->bpp, out_w * fd->bpp ) );
 */	
 	memcpy( output_rows[0], (char*)fd->pixels, out_w * out_h * 2 );
 }
 
 bool LibFlashPlugin::videoReadYUVFrame( char *y_output, char *u_output, char *v_output, int in_x, int in_y, int in_w, int in_h, int stream ) { return TRUE; }
 
 // Profiling
 double LibFlashPlugin::getTime() { return 0.0; }
 
 // Ignore if these aren't supported
 bool LibFlashPlugin::setSMP( int cpus ) { return TRUE; }
 bool LibFlashPlugin::setMMX( bool useMMX ) { return TRUE; }
 
 
diff --git a/core/multimedia/opieplayer/playlistwidget.cpp b/core/multimedia/opieplayer/playlistwidget.cpp
index efea385..b393230 100644
--- a/core/multimedia/opieplayer/playlistwidget.cpp
+++ b/core/multimedia/opieplayer/playlistwidget.cpp
@@ -991,488 +991,492 @@ void PlayListWidget::scanForVideo() {
    QListIterator<DocLnk> sdit( vFiles.children() );
    for ( ; sdit.current(); ++sdit ) {
       delete sdit.current();
    }
    Global::findDocuments(&vFiles, "video/*");
    videoScan = true;
 }
 
 void PlayListWidget::populateAudioView() {
 
    audioView->clear();
    StorageInfo storageInfo;
    const QList<FileSystem> &fs = storageInfo.fileSystems();
    if(!audioScan) scanForAudio();
 
    QListIterator<DocLnk> dit( files.children() );
    QListIterator<FileSystem> it ( fs );
 
    QString storage;
    for ( ; dit.current(); ++dit ) {
       for( ; it.current(); ++it ){
          const QString name = (*it)->name();
          const QString path = (*it)->path();
          if(dit.current()->file().find(path) != -1 ) storage=name;
       }
 
       QListViewItem * newItem;
       if ( QFile( dit.current()->file()).exists() || dit.current()->file().left(4) == "http" ) {
          long size;
          if( dit.current()->file().left(4) == "http" )
             size=0;
          else 
             size = QFile( dit.current()->file() ).size();
          //            qDebug(dit.current()->name());
          newItem= /*(void)*/ new QListViewItem( audioView, dit.current()->name(),
                                                 QString::number(size ), storage, dit.current()->file());
          newItem->setPixmap(0, Resource::loadPixmap( "opieplayer/musicfile" ));
       }
    }
 
 }
 
 void PlayListWidget::populateVideoView() {
     videoView->clear();
     StorageInfo storageInfo;
     const QList<FileSystem> &fs = storageInfo.fileSystems();
 
     if(!videoScan ) scanForVideo();
 
     QListIterator<DocLnk> Vdit( vFiles.children() );
     QListIterator<FileSystem> it ( fs );
     videoView->clear();
     QString storage;
     for ( ; Vdit.current(); ++Vdit ) {
         for( ; it.current(); ++it ){
             const QString name = (*it)->name();
             const QString path = (*it)->path();
             if( Vdit.current()->file().find(path) != -1 ) storage=name;
         }
 
         QListViewItem * newItem;
         if ( QFile( Vdit.current()->file()).exists() ) {
             newItem= /*(void)*/ new QListViewItem( videoView, Vdit.current()->name(),
                    QString::number( QFile( Vdit.current()->file() ).size() ),
                                                    storage, Vdit.current()->file());
             newItem->setPixmap(0, Resource::loadPixmap( "opieplayer/videofile" ));
         }
     }
 }
 
 void PlayListWidget::openFile() {
    QString filename, name;
    InputDialog *fileDlg;
    fileDlg = new InputDialog(this,tr("Open file or URL"),TRUE, 0);
    fileDlg->exec();
    if( fileDlg->result() == 1 ) {
       filename = fileDlg->text();
       //        qDebug( "Selected filename is " + filename );
       DocLnk lnk;
       Config cfg( "OpiePlayer" );
       cfg.setGroup("PlayList");
 
       QString m3uFile;
       m3uFile = filename;
       if(filename.left(4) == "http") {
          if(filename.find(":",8,TRUE) != -1) { //found a port
 
             m3uFile = filename;
             if( m3uFile.right( 1 ).find( '/' ) == -1) {
                m3uFile += "/";
             }
             filename = m3uFile;
          }
          lnk.setName( m3uFile ); //sets name
          lnk.setFile( filename ); //sets file name
          lnk.setIcon("opieplayer2/musicfile");
          d->selectedFiles->addToSelection(  lnk );
          writeCurrentM3u();
       }
       else if( filename.right( 3) == "m3u" ) {
          readm3u( filename );
 
       } else if( filename.right(3) == "pls" ) {
          readPls( filename );
       } else {
          lnk.setName( fullBaseName ( QFileInfo(filename)) ); //sets name
          lnk.setFile( filename ); //sets file name
          d->selectedFiles->addToSelection(  lnk);
          lnk.removeLinkFile();
          writeCurrentM3u();
       }
    }
             
    if( fileDlg ) {
       delete fileDlg;
    }
 }
 
 
 /*
 reads m3u and shows files/urls to playlist widget */
 void PlayListWidget::readm3u( const QString &filename ) { 
    //    qDebug( "read m3u filename " + filename );
 
    Om3u *m3uList;
    QString s, name;
    m3uList = new Om3u( filename, IO_ReadOnly );
    m3uList->readM3u();
    DocLnk lnk;
    for ( QStringList::ConstIterator it = m3uList->begin(); it != m3uList->end(); ++it ) {
       s = *it;
       //          qDebug("reading "+ s);
       if(s.left(4)=="http") {
          lnk.setName( s ); //sets file name
          lnk.setIcon("opieplayer2/musicfile");
 
          //          if(s.right(4) != '.' || s.right(5) != '.')
          if(s.right(4) != '.' || s.right(5) != '.' )
             if( s.right(1) != "/")
                lnk.setFile( s+"/"); //if url with no extension
             else
                lnk.setFile( s ); //sets file name
             
       }  else {
          //               if( QFileInfo( s ).exists() ) {
          lnk.setName( fullBaseName ( QFileInfo(s)));
          //                 if(s.right(4) == '.')   {//if regular file
          if(s.left(1) != "/")  { 
             //            qDebug("set link "+QFileInfo(filename).dirPath()+"/"+s);
             lnk.setFile( QFileInfo(filename).dirPath()+"/"+s);
             lnk.setIcon("SoundPlayer");
          } else {
             //            qDebug("set link2 "+s);
             lnk.setFile( s);
             lnk.setIcon("SoundPlayer");
          }
       }
       d->selectedFiles->addToSelection( lnk );
    }
    Config config( "OpiePlayer" );
    config.setGroup( "PlayList" );
 
    config.writeEntry("CurrentPlaylist",filename);
    config.write();
    currentPlayList=filename;
 
 //    m3uList->write();
    m3uList->close();
    if(m3uList) delete m3uList;
 
    d->selectedFiles->setSelectedItem( s);
    setCaption(tr("OpiePlayer: ")+ fullBaseName ( QFileInfo(filename)));
     
 }
 
 /*
 reads pls and adds files/urls to playlist  */
 void PlayListWidget::readPls( const QString &filename ) {
 
    //    qDebug( "pls filename is " + filename );
    Om3u *m3uList;
    QString s, name;
    m3uList = new Om3u( filename, IO_ReadOnly );
    m3uList->readPls();
 
    for ( QStringList::ConstIterator it = m3uList->begin(); it != m3uList->end(); ++it ) {
       s = *it;
       //        s.replace( QRegExp( "%20" )," " );
       DocLnk lnk( s );
       QFileInfo f( s );
       QString name = fullBaseName ( f);
 
       if( name.left( 4 ) == "http" ) {
          name = s.right( s.length() - 7);
       }  else {
          name = s;
       }
 
       name = name.right( name.length() - name.findRev( "\\", -1, TRUE) - 1 );
 
       lnk.setName( name );
       if( s.at( s.length() - 4) == '.') {// if this is probably a file
          lnk.setFile( s );
       } else { //if its a url
          if( name.right( 1 ).find( '/' ) == -1) {
             s += "/";
          }
          lnk.setFile( s );
       }
       lnk.setType( "audio/x-mpegurl" );
 
       lnk.writeLink();
       d->selectedFiles->addToSelection( lnk );
    }
 
    m3uList->close();
    if(m3uList) delete m3uList;
 }
 
 /*
  writes current playlist to current m3u file */
 void PlayListWidget::writeCurrentM3u() {
    //  qDebug("writing to current m3u");
   Config cfg( "OpiePlayer" );
   cfg.setGroup("PlayList");
   currentPlayList = cfg.readEntry("CurrentPlaylist","");
   Om3u *m3uList;
   m3uList = new Om3u( currentPlayList, IO_ReadWrite | IO_Truncate );
 
   if( d->selectedFiles->first()) {
   do {
      //      qDebug( "writeCurrentM3u " +d->selectedFiles->current()->file());
     m3uList->add( d->selectedFiles->current()->file() );
   }
   while ( d->selectedFiles->next() );
   //    qDebug( "<<<<<<<<<<<<>>>>>>>>>>>>>>>>>" );
   m3uList->write();
   m3uList->close();
 
   if(m3uList) delete m3uList;
   }
 }
 
   /*
  writes current playlist to m3u file */
 void PlayListWidget::writem3u() {
    InputDialog *fileDlg;
    fileDlg = new InputDialog( this, tr( "Save m3u Playlist " ), TRUE, 0);
    fileDlg->exec();
    QString name, filename, list;
    Om3u *m3uList;
 
    if( fileDlg->result() == 1 ) {
       name = fileDlg->text();
       //        qDebug( filename );
       if( name.find("/",0,true) != -1) {// assume they specify a file path
          filename = name;
          name = name.right(name.length()- name.findRev("/",-1,true) - 1 );
       }
       else //otherwise dump it somewhere noticable
          filename = QPEApplication::documentDir() + "/" + name;
 
       if( filename.right( 3 ) != "m3u" ) //needs filename extension
          filename += ".m3u";
         
       if( d->selectedFiles->first()) {
          m3uList = new Om3u(filename, IO_ReadWrite | IO_Truncate);
 
          do {
             m3uList->add( d->selectedFiles->current()->file());
          }
          while ( d->selectedFiles->next() );
          //    qDebug( list );
          m3uList->write();
          m3uList->close();
          if(m3uList) delete m3uList;
         
          if(fileDlg) delete fileDlg;
 
          DocLnk lnk;
          lnk.setFile( filename);
          lnk.setIcon("opieplayer2/playlist2");
          lnk.setName( name); //sets file name
 
          // qDebug(filename);
          Config config( "OpiePlayer" );
          config.setGroup( "PlayList" );
     
          config.writeEntry("CurrentPlaylist",filename);
          currentPlayList=filename;
 
          if(!lnk.writeLink()) {
             //            qDebug("Writing doclink did not work");
          }
 
          setCaption(tr("OpiePlayer: ") + name);
       }
    }
 }
 
 
 void PlayListWidget::keyReleaseEvent( QKeyEvent *e)
 {
     switch ( e->key() ) {
 ////////////////////////////// Zaurus keys
       case Key_F9: //activity
 //           if(audioUI->isHidden())
 //             audioUI->showMaximized();
           break;
       case Key_F10: //contacts
 //           if( videoUI->isHidden())
 //             videoUI->showMaximized();
           break;
       case Key_F11: //menu
           break;
       case Key_F12: //home
 //           doBlank();
           break;
       case Key_F13: //mail
 //           doUnblank();
           break;
       case Key_Q: //add to playlist
           addSelected();
           break;
       case Key_R: //remove from playlist
           removeSelected();
           break;
 //       case Key_P: //play
 //           qDebug("Play");
 //           playSelected();
 //           break;
       case Key_Space:
 //          playSelected(); puh
           break;
       case Key_1:
           tabWidget->setCurrentPage(0);
           break;
       case Key_2:
           tabWidget->setCurrentPage(1);
           break;
     case Key_3:
       tabWidget->setCurrentPage(2);
       break;
     case Key_4:
       tabWidget->setCurrentPage(3);         
       break;
     case Key_Down:
       if ( !d->selectedFiles->next() )
         d->selectedFiles->first();
 
       break;
     case Key_Up:
       if ( !d->selectedFiles->prev() )
         //        d->selectedFiles->last();
 
       break;
       
     }
 }
 
 void PlayListWidget::keyPressEvent( QKeyEvent *)
 {
 //    qDebug("Key press");
 //     switch ( e->key() ) {
 // ////////////////////////////// Zaurus keys
 //       case Key_A: //add to playlist
 //           qDebug("Add");
 //           addSelected();
 //           break;
 //       case Key_R: //remove from playlist
 //           removeSelected();
 //           break;
 //       case Key_P: //play
 //           qDebug("Play");
 //           playSelected();
 //           break;
 //       case Key_Space:
 //           qDebug("Play");
 //           playSelected();
 //           break;
 //     }
 }
 
 void PlayListWidget::doBlank() {
-   //    qDebug("do blanking");
+	// TODO: why do we blank this way, why don't we use ODevice or ScreenSaver?
+#ifdef QT_QWS_DEVFS
+   fd=open("/dev/fb/0",O_RDWR);
+#else
    fd=open("/dev/fb0",O_RDWR);
+#endif
    if (fd != -1) {
       ioctl(fd,FBIOBLANK,1);
       //            close(fd);
    }
 }
 
 void PlayListWidget::doUnblank() {
    // this crashes opieplayer with a segfault
    //      int fd;
    //       fd=open("/dev/fb0",O_RDWR);
    //    qDebug("do unblanking");
    if (fd != -1) {
       ioctl(fd,FBIOBLANK,0);
       close(fd);
    }
    QCopEnvelope h("QPE/System", "setBacklight(int)");
    h <<-3;// v[1]; // -3 Force on
 }
 
 void PlayListWidget::populateSkinsMenu() {
    int item = 0;
    defaultSkinIndex = 0;
    QString skinName;
    Config cfg( "OpiePlayer" );
    cfg.setGroup("Options" );
    QString skin = cfg.readEntry( "Skin", "default" );
 
    QDir skinsDir( QPEApplication::qpeDir() + "/pics/opieplayer2/skins" );
    skinsDir.setFilter( QDir::Dirs );
    skinsDir.setSorting(QDir::Name );
    const QFileInfoList *skinslist = skinsDir.entryInfoList();
    QFileInfoListIterator it( *skinslist );
    QFileInfo *fi;
    while ( ( fi = it.current() ) ) {
       skinName =  fi->fileName();
       //        qDebug(  fi->fileName() );
       if( skinName != "." &&  skinName != ".." && skinName !="CVS" )  {
          item = skinsMenu->insertItem( fi->fileName() ) ;
       }
       if( skinName == "default" ) {
          defaultSkinIndex = item;
       }
       if( skinName == skin ) {
          skinsMenu->setItemChecked( item, TRUE );
       }
       ++it;
    }
 }
 
 void PlayListWidget::skinsMenuActivated( int item ) {
    for( int i = defaultSkinIndex; i > defaultSkinIndex - skinsMenu->count(); i-- ) {
       skinsMenu->setItemChecked( i, FALSE );
    }
    skinsMenu->setItemChecked( item, TRUE );
 
    Config cfg( "OpiePlayer" );
    cfg.setGroup("Options");
    cfg.writeEntry("Skin", skinsMenu->text( item ) );
 }
 
 void PlayListWidget::qcopReceive(const QCString &msg, const QByteArray &data) {
    //   qDebug("qcop message "+msg );
    QDataStream stream ( data, IO_ReadOnly );
    if ( msg == "play()" ) { //plays current selection
       btnPlay( true);
    } else if ( msg == "stop()" ) {
       mediaPlayerState->setPlaying( false);
    } else if ( msg == "togglePause()" ) {
       mediaPlayerState->togglePaused();
    } else if ( msg == "next()" ) { //select next in lis
       mediaPlayerState->setNext();      
    } else if ( msg == "prev()" ) { //select previous in list
       mediaPlayerState->setPrev();      
    } else if ( msg == "toggleLooping()" ) { //loop or not loop
       mediaPlayerState->toggleLooping();
    } else if ( msg == "toggleShuffled()" ) { //shuffled or not shuffled
       mediaPlayerState->toggleShuffled();
    } else if ( msg == "volUp()" ) { //volume more
       //       emit moreClicked();
       //       emit moreReleased();
    } else if ( msg == "volDown()" ) { //volume less
       //       emit lessClicked();
       //       emit lessReleased();
    } else if ( msg == "play(QString)" ) { //play this now
       QString file;
       stream >> file;
       setDocumentEx( (const QString &) file);
    } else if ( msg == "add(QString)" ) { //add to playlist
       QString file;
       stream >> file;
       QFileInfo fileInfo(file);
       DocLnk lnk;
       lnk.setName( fileInfo.baseName() ); //sets name
       lnk.setFile( file ); //sets file name
       addToSelection( lnk );
    } else if ( msg == "rem(QString)" ) { //remove from playlist
       QString file;
       stream >> file;
    } else if ( msg == "setDocument(QString)" ) { //loop or not loop
       QCopEnvelope h("QPE/Application/opieplayer", "raise()");
    }
 }