commited by ljp (llornkcor) reverted to qpe's interface for compatibility. Added playlist features:

save, remove, and have different ones. Uncommented code for background image and added opielogo.

25 files changed, 505 insertions, 285 deletions

diff --git a/core/multimedia/opieplayer/audiodevice.cpp b/core/multimedia/opieplayer/audiodevice.cpp
index 9a10eb4..5fef792 100644
--- a/core/multimedia/opieplayer/audiodevice.cpp
+++ b/core/multimedia/opieplayer/audiodevice.cpp
@@ -1,370 +1,371 @@
 /**********************************************************************
 ** 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 "audiodevice.h"
 
 #if ( defined Q_WS_QWS || defined(_WS_QWS_) ) && !defined(QT_NO_COP)
 #include "qpe/qcopenvelope_qws.h"
 #endif
 
 #ifdef Q_WS_WIN
 #include <windows.h>
 #include <mmsystem.h>
 #include <mmreg.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(Q_OS_WIN32)
 static const int expectedBytesPerMilliSecond = 2 * 2 * 44000 / 1000;
 static const int timerResolutionMilliSeconds = 30;
 static const int sound_fragment_bytes = timerResolutionMilliSeconds * expectedBytesPerMilliSecond;
 #else
 # 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 Q_OS_WIN32
     HWAVEOUT handle;
     WAVEFORMATEX formatData;
     formatData.cbSize = sizeof(WAVEFORMATEX);
     formatData.wFormatTag = WAVE_FORMAT_PCM;
     formatData.nAvgBytesPerSec = 4 * 44000;
     formatData.nBlockAlign = 4;
     formatData.nChannels = 2;
     formatData.nSamplesPerSec = 44000;
     formatData.wBitsPerSample = 16;
     waveOutOpen(&handle, WAVE_MAPPER, &formatData, 0L, 0L, CALLBACK_NULL);
     if ( waveOutGetVolume( handle, (LPDWORD)&volume ) )
 //  qDebug( "get volume of audio device failed" );
     waveOutClose( handle );
     leftVolume = volume & 0xFFFF;
     rightVolume = volume >> 16;
 #else
     int mixerHandle = open( "/dev/mixer", O_RDWR );
     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;
 #endif
 }
 
 
 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 );
     }
 #ifdef Q_OS_WIN32
     HWAVEOUT handle;
     WAVEFORMATEX formatData;
     formatData.cbSize = sizeof(WAVEFORMATEX);
     formatData.wFormatTag = WAVE_FORMAT_PCM;
     formatData.nAvgBytesPerSec = 4 * 44000;
     formatData.nBlockAlign = 4;
     formatData.nChannels = 2;
     formatData.nSamplesPerSec = 44000;
     formatData.wBitsPerSample = 16;
     waveOutOpen(&handle, WAVE_MAPPER, &formatData, 0L, 0L, CALLBACK_NULL);
     unsigned int volume = (rightVolume << 16) | leftVolume;
     if ( waveOutSetVolume( handle, volume ) )
 //  qDebug( "set volume of audio device failed" );
     waveOutClose( handle );
 #else
     // 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;
     if ( ( mixerHandle = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
         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("Sound");
     cfg.setGroup("System");
     cfg.writeEntry("Volume",(int)rV);
 # 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 ) {
-    d = new AudioDevicePrivate;
+  qDebug("creating new audio device");
+  d = new AudioDevicePrivate;
     d->frequency = f;
     d->channels = chs;
     d->bytesPerSample = bps;
-//    qDebug("%d",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);
+    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
     if ( ( d->handle = ::open( "/dev/dsp", O_WRONLY ) ) < 0 ) {
         perror("open(\"/dev/dsp\") sending to /dev/null instead");
         d->handle = ::open( "/dev/null", O_WRONLY );
     }
 #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\")");
     }
 
     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() {
 #ifdef Q_OS_WIN32
     waveOutClose( (HWAVEOUT)d->handle );
 #else
 # ifndef KEEP_DEVICE_OPEN 
     close( d->handle );     // Now it should be safe to shut the handle
 # endif
     delete d->unwrittenBuffer;
     delete d;
 #endif
 }
 
 
 void AudioDevice::volumeChanged( bool muted )
 {
     AudioDevicePrivate::muted = muted;
 }
 
 
 void AudioDevice::write( char *buffer, unsigned int length )
 {
 #ifdef Q_OS_WIN32
     // returns immediately and (to be implemented) emits completedIO() when finished writing
     WAVEHDR *lpWaveHdr = (WAVEHDR *)malloc( sizeof(WAVEHDR) );
     // maybe the buffer should be copied so that this fool proof, but its a performance hit
     lpWaveHdr->lpData = buffer;
     lpWaveHdr->dwBufferLength = length;
     lpWaveHdr->dwFlags = 0L;
     lpWaveHdr->dwLoops = 0L;
     waveOutPrepareHeader( (HWAVEOUT)d->handle, lpWaveHdr, sizeof(WAVEHDR) );
     // waveOutWrite returns immediately. the data is sent in the background. 
     if ( waveOutWrite( (HWAVEOUT)d->handle, lpWaveHdr, sizeof(WAVEHDR) ) )
   qDebug( "failed to write block to audio device" );
     // emit completedIO();
 #else
     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
 {
 #ifdef Q_OS_WIN32
     return bufferSize(); // Any better?
 #else
     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;
     }
 #endif
 }
 
 
 int AudioDevice::bytesWritten() {
 #ifdef Q_OS_WIN32
     MMTIME pmmt = { TIME_BYTES, 0 };
     if ( ( waveOutGetPosition( (HWAVEOUT)d->handle, &pmmt, sizeof(MMTIME) ) != MMSYSERR_NOERROR ) || ( pmmt.wType != TIME_BYTES ) ) {
   qDebug( "failed to get audio device position" );
   return -1;
     }
     return pmmt.u.cb;
 #else
     int buffered = 0;
     if ( ioctl( d->handle, SNDCTL_DSP_GETODELAY, &buffered ) ) {
   qDebug( "failed to get audio device position" );
   return -1;
     }
     return buffered;
 #endif
 }
 
diff --git a/core/multimedia/opieplayer/inputDialog.cpp b/core/multimedia/opieplayer/inputDialog.cpp
new file mode 100644
index 0000000..b443747
--- a/dev/null
+++ b/core/multimedia/opieplayer/inputDialog.cpp
@@ -0,0 +1,45 @@
+/****************************************************************************
+** Form implementation generated from reading ui file 'inputDialog.ui'
+**
+** Created: Sat Mar 2 07:55:03 2002
+**      by:  The User Interface Compiler (uic)
+**
+** WARNING! All changes made in this file will be lost!
+****************************************************************************/
+#include "inputDialog.h"
+
+#include <qlineedit.h>
+#include <qlayout.h>
+#include <qvariant.h>
+#include <qtooltip.h>
+#include <qwhatsthis.h>
+
+/* 
+ *  Constructs a InputDialog which is a child of 'parent', with the 
+ *  name 'name' and widget flags set to 'f' 
+ *
+ *  The dialog will by default be modeless, unless you set 'modal' to
+ *  TRUE to construct a modal dialog.
+ */
+InputDialog::InputDialog( QWidget* parent,  const char* name, bool modal, WFlags fl )
+    : QDialog( parent, name, modal, fl )
+{
+    if ( !name )
+  setName( "InputDialog" );
+    resize( 234, 50 ); 
+    setMaximumSize( QSize( 240, 50 ) );
+    setCaption( tr(name ) );
+
+    LineEdit1 = new QLineEdit( this, "LineEdit1" );
+    LineEdit1->setGeometry( QRect( 10, 10, 216, 22 ) ); 
+}
+
+/*  
+ *  Destroys the object and frees any allocated resources
+ */
+InputDialog::~InputDialog()
+{
+    inputText= LineEdit1->text();
+  
+}
+
diff --git a/core/multimedia/opieplayer/inputDialog.h b/core/multimedia/opieplayer/inputDialog.h
new file mode 100644
index 0000000..26d5cd0
--- a/dev/null
+++ b/core/multimedia/opieplayer/inputDialog.h
@@ -0,0 +1,31 @@
+/****************************************************************************
+** Form interface generated from reading ui file 'inputDialog.ui'
+**
+** Created: Sat Mar 2 07:54:46 2002
+**      by:  The User Interface Compiler (uic)
+**
+** WARNING! All changes made in this file will be lost!
+****************************************************************************/
+#ifndef INPUTDIALOG_H
+#define INPUTDIALOG_H
+
+#include <qvariant.h>
+#include <qdialog.h>
+class QVBoxLayout; 
+class QHBoxLayout; 
+class QGridLayout; 
+class QLineEdit;
+
+class InputDialog : public QDialog
+{ 
+    Q_OBJECT
+
+public:
+    InputDialog( QWidget* parent = 0, const char* name = 0, bool modal = FALSE, WFlags fl = 0 );
+    ~InputDialog();
+    QString inputText;
+    QLineEdit* LineEdit1;
+
+};
+
+#endif // INPUTDIALOG_H
diff --git a/core/multimedia/opieplayer/libmad/libmadplugin.h b/core/multimedia/opieplayer/libmad/libmadplugin.h
index d163458..b240b77 100644
--- a/core/multimedia/opieplayer/libmad/libmadplugin.h
+++ b/core/multimedia/opieplayer/libmad/libmadplugin.h
@@ -1,110 +1,110 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #ifndef LIBMAD_PLUGIN_H 
 #define LIBMAD_PLUGIN_H
 
 #include <qstring.h>
-//#include <qpe/mediaplayerplugininterface.h>
-#include "../mediaplayerplugininterface.h"
+#include <qpe/mediaplayerplugininterface.h>
+/* #include "../mediaplayerplugininterface.h" */
 
 
 // #define OLD_MEDIAPLAYER_API
 
 
 class LibMadPluginData;
 
 
 class LibMadPlugin : public MediaPlayerDecoder {
 
 public:
     LibMadPlugin();
     ~LibMadPlugin();
 
     const char *pluginName() { return "LibMadPlugin"; }
     const char *pluginComment() { return "This is the libmad library that has been wrapped as a plugin"; }
     double pluginVersion() { return 1.0; }
 
     bool isFileSupported( const QString& );
     bool open( const QString& );
     bool close();
     bool isOpen();
     const QString &fileInfo() { return info; }
 
     // If decoder doesn't support audio then return 0 here
     int audioStreams();
     int audioChannels( int stream ); 
     int audioFrequency( int stream );
     int audioSamples( int stream );
     bool audioSetSample( long sample, int stream );
-    int audioBitsPerSample(int) {return 0;}
+/*     int audioBitsPerSample(int) {return 0;} */
     long audioGetSample( int stream );
 #ifdef OLD_MEDIAPLAYER_API
     bool audioReadMonoSamples( short *output, long samples, long& samplesRead, int stream );
     bool audioReadStereoSamples( short *output, long samples, long& samplesRead, int stream );
     bool audioReadSamples( short *output, int channel, long samples, int stream );
     bool audioReReadSamples( short *output, int channel, long samples, int stream );
 #else
     bool audioReadSamples( short *output, int channels, long samples, long& samplesRead, int stream );
 #endif
 
 
     bool read();
     bool decode( short *output, long samples, long& samplesRead );
     void printID3Tags();
 
 
     // If decoder doesn't support video then return 0 here
     int videoStreams() { return 0; }
     int videoWidth( int ) { return 0; }
     int videoHeight( int ) { return 0; }
     double videoFrameRate( int ) { return 0.0; }
     int videoFrames( int ) { return 0; }
     bool videoSetFrame( long, int ) { return FALSE; }
     long videoGetFrame( int ) { return 0; }
     bool videoReadFrame( unsigned char **, int, int, int, int, ColorFormat, int ) { return FALSE; }
     bool videoReadScaledFrame( unsigned char **, int, int, int, int, int, int, ColorFormat, int ) { return FALSE; }
     bool videoReadYUVFrame( char *, char *, char *, int, int, int, int, int ) { return FALSE; }
 
     // Profiling
     double getTime();
 
     // Ignore if these aren't supported
     bool setSMP( int ) { return FALSE; }
     bool setMMX( bool ) { return FALSE; }
 
     // Capabilities
     bool supportsAudio() { return TRUE; }
     bool supportsVideo() { return FALSE; }
     bool supportsYUV() { return FALSE; }
     bool supportsMMX() { return TRUE; }
     bool supportsSMP() { return FALSE; }
     bool supportsStereo() { return TRUE; }
     bool supportsScaling() { return FALSE; }
 
     long getPlayTime() { return -1; }
 
 private:
     LibMadPluginData *d;
     QString info;
 
 };
 
 
 #endif
diff --git a/core/multimedia/opieplayer/libmad/libmadpluginimpl.cpp b/core/multimedia/opieplayer/libmad/libmadpluginimpl.cpp
index 028c658..67779e8 100644
--- a/core/multimedia/opieplayer/libmad/libmadpluginimpl.cpp
+++ b/core/multimedia/opieplayer/libmad/libmadpluginimpl.cpp
@@ -1,70 +1,70 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #include "libmadplugin.h"
 #include "libmadpluginimpl.h"
 
 
 LibMadPluginImpl::LibMadPluginImpl()
     : libmadplugin(0), ref(0)
 {
 }
 
 
 LibMadPluginImpl::~LibMadPluginImpl()
 {
     if ( libmadplugin )
-        delete libmadplugin;
+  delete libmadplugin;
 }
 
 
 MediaPlayerDecoder *LibMadPluginImpl::decoder()
 {
     if ( !libmadplugin )
-        libmadplugin = new LibMadPlugin;
+  libmadplugin = new LibMadPlugin;
     return libmadplugin;
 }
 
 
 MediaPlayerEncoder *LibMadPluginImpl::encoder()
 {
     return NULL;
 }
 
 
 #ifndef QT_NO_COMPONENT
 
 
 QRESULT LibMadPluginImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
-    if ( ( uuid == IID_QUnknown ) || ( uuid == IID_MediaPlayerPlugin ) )
-        *iface = this, (*iface)->addRef();
+    if ( ( uuid == IID_QUnknown ) || ( uuid == IID_MediaPlayerPlugin )  )
+  *iface = this, (*iface)->addRef();
     return QS_OK;
 }
 
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( LibMadPluginImpl )
 }
 
 
 #endif
 
diff --git a/core/multimedia/opieplayer/libmad/libmadpluginimpl.h b/core/multimedia/opieplayer/libmad/libmadpluginimpl.h
index bc864ee..9b35b90 100644
--- a/core/multimedia/opieplayer/libmad/libmadpluginimpl.h
+++ b/core/multimedia/opieplayer/libmad/libmadpluginimpl.h
@@ -1,52 +1,52 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #ifndef LIBMAD_PLUGIN_IMPL_H 
 #define LIBMAD_PLUGIN_IMPL_H
 
-//#include <qpe/mediaplayerplugininterface.h>
-#include "../mediaplayerplugininterface.h"
+#include <qpe/mediaplayerplugininterface.h>
+//#include "../mediaplayerplugininterface.h"
 
 
 class LibMadPlugin;
 
 
 class LibMadPluginImpl : public MediaPlayerPluginInterface
 {
 public:
     LibMadPluginImpl();
     virtual ~LibMadPluginImpl();
 
 #ifndef QT_NO_COMPONENT
 
     QRESULT queryInterface( const QUuid&, QUnknownInterface** );
     Q_REFCOUNT
 
 #endif
 
     virtual MediaPlayerDecoder *decoder();
     virtual MediaPlayerEncoder *encoder();
 private:
     LibMadPlugin *libmadplugin;
     ulong ref;
 };
 
 
 #endif
 
diff --git a/core/multimedia/opieplayer/libmpeg3/libmpeg3plugin.h b/core/multimedia/opieplayer/libmpeg3/libmpeg3plugin.h
index bd31706..b573e84 100644
--- a/core/multimedia/opieplayer/libmpeg3/libmpeg3plugin.h
+++ b/core/multimedia/opieplayer/libmpeg3/libmpeg3plugin.h
@@ -1,122 +1,121 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #ifndef LIBMPEG3_PLUGIN_H 
 #define LIBMPEG3_PLUGIN_H
 
 #include <qstring.h>
 #include <qapplication.h>
 #include "libmpeg3.h"
 #include "mpeg3protos.h"
-//#include <qpe/mediaplayerplugininterface.h>
-#include "../mediaplayerplugininterface.h"
+#include <qpe/mediaplayerplugininterface.h>
 
 
 // #define OLD_MEDIAPLAYER_API
 
 
 class LibMpeg3Plugin : public MediaPlayerDecoder {
 
 public:
     LibMpeg3Plugin() { file = NULL; }
     ~LibMpeg3Plugin() { close(); }
 
     const char *pluginName() { return "LibMpeg3Plugin"; }
     const char *pluginComment() { return "This is the libmpeg3 library writen by ... which has been modified by trolltech to use fixed point maths"; }
     double pluginVersion() { return 1.0; }
 
     bool isFileSupported( const QString& fileName ) { return mpeg3_check_sig( (char *)fileName.latin1() ) == 1; }
     bool open( const QString& fileName ) { file = mpeg3_open( (char *)fileName.latin1() ); return file != NULL; }
     bool close() { if ( file ) { int r = mpeg3_close( file ); file = NULL; return r == 1; } return FALSE; }
     bool isOpen() { return file != NULL; }
     const QString &fileInfo() { return strInfo = ""; }
 
     // If decoder doesn't support audio then return 0 here
     int audioStreams() { return file ? mpeg3_total_astreams( file ) : 0; }
     int audioChannels( int stream ) { return file ? mpeg3_audio_channels( file, stream ) : 0; }
     int audioFrequency( int stream ) { return file ? mpeg3_sample_rate( file, stream ) : 0; }
-    int audioBitsPerSample(int) { return 0;}
+/*     int audioBitsPerSample(int) { return 0;} */
     int audioSamples( int stream ) { return file ? mpeg3_audio_samples( file, stream ) : 0; } 
     bool audioSetSample( long sample, int stream ) { return file ? mpeg3_set_sample( file, sample, stream) == 1 : FALSE; }
     long audioGetSample( int stream ) { return file ? mpeg3_get_sample( file, stream ) : 0; }
 #ifdef OLD_MEDIAPLAYER_API
     bool audioReadMonoSamples( short *output, long samples, long& samplesRead, int stream );
     bool audioReadStereoSamples( short *output, long samples, long& samplesRead, int stream );
     bool audioReadSamples( short *output, int channel, long samples, int stream );
     bool audioReReadSamples( short *output, int channel, long samples, int stream );
 #else
     bool audioReadSamples( short *output, int channels, long samples, long& samplesRead, int stream );
 #endif
 
     // If decoder doesn't support video then return 0 here
     int videoStreams() { return file ? mpeg3_total_vstreams( file ) : 0; }
     int videoWidth( int stream ) { return file ? mpeg3_video_width( file, stream ) : 0; }
     int videoHeight( int stream ) { return file ? mpeg3_video_height( file, stream ) : 0; }
     double videoFrameRate( int stream ) { return file ? mpeg3_frame_rate( file, stream ) : 0.0; }
     int videoFrames( int stream )
 { return file ? mpeg3_video_frames( file, stream ) : 0; }
 /*
 {
     if ( file ) {
-        int frames = mpeg3_video_frames( file, stream );
-        if ( frames == 1 ) {
-            int res = mpeg3_seek_percentage( file, 0.99 );
-            printf("res: %i\n", res );
-            mpeg3video_seek( file->vtrack[stream]->video );
-            frames = mpeg3_get_frame( file, stream );
-            mpeg3_seek_percentage( file, 0.0 );
-        }
-        return frames;
+  int frames = mpeg3_video_frames( file, stream );
+  if ( frames == 1 ) {
+      int res = mpeg3_seek_percentage( file, 0.99 );
+      printf("res: %i\n", res );
+      mpeg3video_seek( file->vtrack[stream]->video );
+      frames = mpeg3_get_frame( file, stream );
+      mpeg3_seek_percentage( file, 0.0 );
+  }
+  return frames;
     }
     return 0;
 }
 */
     bool videoSetFrame( long frame, int stream ) { return file ? mpeg3_set_frame( file, frame, stream) == 1 : FALSE; }
     long videoGetFrame( int stream ) { return file ? mpeg3_get_frame( file, stream ) : 0; }
     bool videoReadFrame( unsigned char **output_rows, int in_x, int in_y, int in_w, int in_h, ColorFormat color_model, int stream );
     bool 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 );
     bool videoReadYUVFrame( char *y_output, char *u_output, char *v_output, int in_x, int in_y, int in_w, int in_h, int stream );
 
     // Profiling
     double getTime() { return file ? mpeg3_get_time( file ) : 0.0; }
 
     // Ignore if these aren't supported
     bool setSMP( int cpus ) { return file ? mpeg3_set_cpus( file, cpus ) == 1 : FALSE; }
     bool setMMX( bool useMMX ) { return file ? mpeg3_set_mmx( file, useMMX ) == 1 : FALSE; }
 
     // Capabilities
     bool supportsAudio() { return TRUE; }
     bool supportsVideo() { return TRUE; }
     bool supportsYUV() { return TRUE; }
     bool supportsMMX() { return TRUE; }
     bool supportsSMP() { return TRUE; }
     bool supportsStereo() { return TRUE; }
     bool supportsScaling() { return TRUE; }
 
     long getPlayTime() { return -1; }
 
 private:
     mpeg3_t *file;
     QString strInfo;
 
 };
 
 
 #endif
 
diff --git a/core/multimedia/opieplayer/libmpeg3/libmpeg3pluginimpl.cpp b/core/multimedia/opieplayer/libmpeg3/libmpeg3pluginimpl.cpp
index e7216af..bf3f372 100644
--- a/core/multimedia/opieplayer/libmpeg3/libmpeg3pluginimpl.cpp
+++ b/core/multimedia/opieplayer/libmpeg3/libmpeg3pluginimpl.cpp
@@ -1,70 +1,70 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #include "libmpeg3plugin.h"
 #include "libmpeg3pluginimpl.h"
 
 
 LibMpeg3PluginImpl::LibMpeg3PluginImpl()
     : libmpeg3plugin(0), ref(0)
 {
 }
 
 
 LibMpeg3PluginImpl::~LibMpeg3PluginImpl()
 {
     if ( libmpeg3plugin )
-        delete libmpeg3plugin;
+  delete libmpeg3plugin;
 }
 
 
 MediaPlayerDecoder *LibMpeg3PluginImpl::decoder()
 {
     if ( !libmpeg3plugin )
-        libmpeg3plugin = new LibMpeg3Plugin;
+  libmpeg3plugin = new LibMpeg3Plugin;
     return libmpeg3plugin;
 }
 
 
 MediaPlayerEncoder *LibMpeg3PluginImpl::encoder()
 {
     return NULL;
 }
 
 
 #ifndef QT_NO_COMPONENT
 
 
 QRESULT LibMpeg3PluginImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
-    if ( ( uuid == IID_QUnknown ) || ( uuid == IID_MediaPlayerPlugin ) )
-        *iface = this, (*iface)->addRef();
+    if ( ( uuid == IID_QUnknown )  || ( uuid == IID_MediaPlayerPlugin )  )
+  *iface = this, (*iface)->addRef();
     return QS_OK;
 }
 
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( LibMpeg3PluginImpl )
 }
 
 
 #endif
 
diff --git a/core/multimedia/opieplayer/libmpeg3/libmpeg3pluginimpl.h b/core/multimedia/opieplayer/libmpeg3/libmpeg3pluginimpl.h
index a2f5211..ef3743e 100644
--- a/core/multimedia/opieplayer/libmpeg3/libmpeg3pluginimpl.h
+++ b/core/multimedia/opieplayer/libmpeg3/libmpeg3pluginimpl.h
@@ -1,53 +1,53 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #ifndef LIBMPEG3_PLUGIN_IMPL_H 
 #define LIBMPEG3_PLUGIN_IMPL_H
 
-//#include <qpe/mediaplayerplugininterface.h>
-#include "../mediaplayerplugininterface.h"
+#include <qpe/mediaplayerplugininterface.h>
+//#include "../mediaplayerplugininterface.h"
 
 
 class LibMpeg3Plugin;
 
 
 class LibMpeg3PluginImpl : public MediaPlayerPluginInterface
 {
 public:
     LibMpeg3PluginImpl();
     virtual ~LibMpeg3PluginImpl();
 
 #ifndef QT_NO_COMPONENT
 
     QRESULT queryInterface( const QUuid&, QUnknownInterface** );
     Q_REFCOUNT
 
 #endif
 
     virtual MediaPlayerDecoder *decoder();
     virtual MediaPlayerEncoder *encoder();
 
 private:
     LibMpeg3Plugin *libmpeg3plugin;
     ulong ref;
 };
 
 
 #endif
 
diff --git a/core/multimedia/opieplayer/loopcontrol.cpp b/core/multimedia/opieplayer/loopcontrol.cpp
index 90a7cc6..cb8de8a 100644
--- a/core/multimedia/opieplayer/loopcontrol.cpp
+++ b/core/multimedia/opieplayer/loopcontrol.cpp
@@ -1,469 +1,475 @@
 /**********************************************************************
 ** 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 changes Fri 02-15-2002
 
 
 #include <qpe/qpeapplication.h>
 
 #ifdef Q_WS_QWS
 #include <qpe/qcopenvelope_qws.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <pthread.h>
 #include <errno.h>
 #include <unistd.h>
 #include "loopcontrol.h"
 #include "videowidget.h"
 #include "audiodevice.h"
-#include "mediaplayerplugininterface.h"
+#include <qpe/mediaplayerplugininterface.h>
 #include "mediaplayerstate.h"
 
 
 extern VideoWidget *videoUI; // now only needed to tell it to play a frame
 extern MediaPlayerState *mediaPlayerState;
 
 
 //#define DecodeLoopDebug(x)  qDebug x
 #define DecodeLoopDebug(x)
 
 
 static char     *audioBuffer = NULL;
 static AudioDevice  *audioDevice = NULL;
 static bool     disabledSuspendScreenSaver = FALSE;
 static bool     previousSuspendMode = FALSE;
 
 
 pthread_t audio_tid;
 pthread_attr_t  audio_attr;
 bool threadOkToGo = FALSE;
 
 
 class Mutex {
 public:
     Mutex() {
   pthread_mutexattr_t attr;
   pthread_mutexattr_init( &attr );
   pthread_mutex_init( &mutex, &attr );
   pthread_mutexattr_destroy( &attr );
     }
 
     ~Mutex() {
   pthread_mutex_destroy( &mutex );
     }
 
     void lock() {
   pthread_mutex_lock( &mutex );
     }
 
     void unlock() {
   pthread_mutex_unlock( &mutex );
     }
 private:
     pthread_mutex_t mutex;
 };
 
 
 void *startAudioThread( void *ptr ) {
     LoopControl *mpegView = (LoopControl *)ptr;
     while ( TRUE ) {
   if ( threadOkToGo && mpegView->moreAudio )
       mpegView->startAudio();
   else
       usleep( 10000 ); // Semi-buzy-wait till we are playing again
     }
     return 0;
 }
 
 
 Mutex *audioMutex;
 
 
 LoopControl::LoopControl( QObject *parent, const char *name )
     : QObject( parent, name ) {
     isMuted = FALSE;
     connect( qApp, SIGNAL( volumeChanged(bool) ), this, SLOT( setMute(bool) ) );
-
+//qDebug("starting loopcontrol");
     audioMutex = new Mutex;
 
     pthread_attr_init(&audio_attr);
 #define USE_REALTIME_AUDIO_THREAD
 #ifdef USE_REALTIME_AUDIO_THREAD
     // Attempt to set it to real-time round robin
     if ( pthread_attr_setschedpolicy( &audio_attr, SCHED_RR ) == 0 ) {
   sched_param params;
   params.sched_priority = 50;
   pthread_attr_setschedparam(&audio_attr,&params);
     } else {
   qDebug( "Error setting up a realtime thread, reverting to using a normal thread." );
   pthread_attr_destroy(&audio_attr);
   pthread_attr_init(&audio_attr);
     }
 #endif
+//qDebug("create audio thread");
     pthread_create(&audio_tid, &audio_attr, (void * (*)(void *))startAudioThread, this);
 }
 
 
 LoopControl::~LoopControl() {
     stop();
 }
 
 
 static long prev_frame = 0;
 static int currentSample = 0;
 
 
 void LoopControl::timerEvent( QTimerEvent *te ) {
 
     if ( te->timerId() == videoId )
   startVideo();
 
     if ( te->timerId() == sliderId ) {
   if ( hasAudioChannel && !hasVideoChannel && moreAudio ) {
       mediaPlayerState->updatePosition( audioSampleCounter );
   } else if ( hasVideoChannel && moreVideo ) {
       mediaPlayerState->updatePosition( current_frame );
   }
     }
 
     if ( !moreVideo && !moreAudio ) { 
         mediaPlayerState->setPlaying( FALSE );
         mediaPlayerState->setNext();
     }
 }
 
 
 void LoopControl::setPosition( long pos ) {
     audioMutex->lock();
 
     if ( hasVideoChannel && hasAudioChannel ) {
   playtime.restart();
   playtime = playtime.addMSecs( long((double)-pos * 1000.0 / framerate) );
   current_frame = pos + 1;
   mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
   prev_frame = current_frame - 1;
   currentSample = (int)( (double)current_frame * freq / framerate );
   mediaPlayerState->curDecoder()->audioSetSample( currentSample, stream );
   audioSampleCounter = currentSample - 1;
     } else if ( hasVideoChannel ) {
   playtime.restart();
   playtime = playtime.addMSecs( long((double)-pos * 1000.0 / framerate) );
   current_frame = pos + 1;
   mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
   prev_frame = current_frame - 1;
     } else if ( hasAudioChannel ) {
   playtime.restart();
   playtime = playtime.addMSecs( long((double)-pos * 1000.0 / freq) );
   currentSample = pos + 1;
   mediaPlayerState->curDecoder()->audioSetSample( currentSample, stream );
   audioSampleCounter = currentSample - 1;
     }
 
     audioMutex->unlock();
 }
 
 
 void LoopControl::startVideo() {
 
     if ( moreVideo ) {
 
         if ( mediaPlayerState->curDecoder() ) {
 
       if ( hasAudioChannel && !isMuted ) {
 
     current_frame = long( playtime.elapsed() * framerate / 1000 );
 
     if ( prev_frame != -1 && current_frame <= prev_frame )
         return;
 
       } else {
     // Don't skip
     current_frame++;
       }
 
       if ( prev_frame == -1 || current_frame > prev_frame ) {
     if ( current_frame > prev_frame + 1 ) {
         mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
     }
     moreVideo = videoUI->playVideo();
     prev_frame = current_frame;
       }
 
   } else {
 
       moreVideo = FALSE;
       killTimer( videoId );
 
   }
 
     }
 }
 
 
 void LoopControl::startAudio() {
     
+//qDebug("start audio");
     audioMutex->lock();
-
     if ( moreAudio ) {
 
   if ( !isMuted && mediaPlayerState->curDecoder() ) {
 
       currentSample = audioSampleCounter + 1;
 
       if ( currentSample != audioSampleCounter + 1 )
     qDebug("out of sync with decoder %i %i", currentSample, audioSampleCounter);
 
       long samplesRead = 0;
       bool readOk=mediaPlayerState->curDecoder()->audioReadSamples( (short*)audioBuffer, channels, 1024, samplesRead, stream );
       long sampleWeShouldBeAt = long( playtime.elapsed() ) * freq / 1000;
       long sampleWaitTime = currentSample - sampleWeShouldBeAt;
 
-        if ( ( sampleWaitTime > 2000 ) && ( sampleWaitTime < 20000 ) ) {
-      usleep( (long)((double)sampleWaitTime * 1000000.0 / freq) );
-        }
-      else if ( sampleWaitTime <= -5000 ) {
-     qDebug("need to catch up by: %li (%i,%li)", -sampleWaitTime, currentSample, sampleWeShouldBeAt );
-     //mediaPlayerState->curDecoder()->audioSetSample( sampleWeShouldBeAt, stream );
-     currentSample = sampleWeShouldBeAt;
-       }
+//         if ( ( sampleWaitTime > 2000 ) && ( sampleWaitTime < 20000 ) ) {
+//       usleep( (long)((double)sampleWaitTime * 1000000.0 / freq) );
+//         }
+//       else if ( sampleWaitTime <= -5000 ) {
+//      qDebug("need to catch up by: %li (%i,%li)", -sampleWaitTime, currentSample, sampleWeShouldBeAt );
+//      //mediaPlayerState->curDecoder()->audioSetSample( sampleWeShouldBeAt, stream );
+//      currentSample = sampleWeShouldBeAt;
+//        }
 
       audioDevice->write( audioBuffer, samplesRead * 2 * channels );
       audioSampleCounter = currentSample + samplesRead - 1;
 
       moreAudio = readOk && (audioSampleCounter <= total_audio_samples);
 
   } else {
 
       moreAudio = FALSE;
 
   }
 
     }
 
     audioMutex->unlock();
 }
 
 
 void LoopControl::killTimers() {
 
     audioMutex->lock();
 
     if ( hasVideoChannel ) 
   killTimer( videoId );
     killTimer( sliderId );
     threadOkToGo = FALSE;
 
     audioMutex->unlock();
 }
 
 
 void LoopControl::startTimers() {
 
     audioMutex->lock();
 
     moreVideo = FALSE;
     moreAudio = FALSE;
 
     if ( hasVideoChannel ) {
   moreVideo = TRUE;
   int mSecsBetweenFrames = (int)(100 / framerate); // 10% of the real value
   videoId = startTimer( mSecsBetweenFrames );
     }
 
     if ( hasAudioChannel ) {
   moreAudio = TRUE;
   threadOkToGo = TRUE;
     }
 
     sliderId = startTimer( 300 ); // update slider every 1/3 second
 
     audioMutex->unlock();
 }
 
 
 void LoopControl::setPaused( bool pause ) {
 
     if ( !mediaPlayerState->curDecoder() || !mediaPlayerState->curDecoder()->isOpen() )
   return;
 
     if ( pause ) {
   killTimers();
     } else {
   // Force an update of the position
   mediaPlayerState->setPosition( mediaPlayerState->position() + 1 );
   mediaPlayerState->setPosition( mediaPlayerState->position() - 1 );
   // Just like we never stopped
   startTimers();
     }
 }
 
 
 void LoopControl::stop( bool willPlayAgainShortly ) {
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     if ( !willPlayAgainShortly && disabledSuspendScreenSaver ) {
   disabledSuspendScreenSaver = FALSE; 
   // Re-enable the suspend mode
   QCopEnvelope("QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
     }
 #endif
 
     if ( mediaPlayerState->curDecoder() && mediaPlayerState->curDecoder()->isOpen() ) {
 
   killTimers();
 
   audioMutex->lock();
 
   mediaPlayerState->curDecoder()->close();
 
   if ( audioDevice ) {
       delete audioDevice;
       delete audioBuffer;
       audioDevice = 0;
       audioBuffer = 0;
   }
 
   audioMutex->unlock();
 
     }
 }
 
 
 bool LoopControl::init( const QString& filename ) {
     stop();
 
     audioMutex->lock();
 
     fileName = filename;
     stream = 0; // only play stream 0 for now
     current_frame = total_video_frames = total_audio_samples = 0;
     
     qDebug( "Using the %s decoder", mediaPlayerState->curDecoder()->pluginName() );
    
     // ### Hack to use libmpeg3plugin to get the number of audio samples if we are using the libmad plugin
     if ( mediaPlayerState->curDecoder()->pluginName() == QString("LibMadPlugin") ) {
   if ( mediaPlayerState->libMpeg3Decoder() && mediaPlayerState->libMpeg3Decoder()->open( filename ) ) {
       total_audio_samples = mediaPlayerState->libMpeg3Decoder()->audioSamples( 0 );
       mediaPlayerState->libMpeg3Decoder()->close();
   }
     }
     
     if ( !mediaPlayerState->curDecoder()|| !mediaPlayerState->curDecoder()->open( filename ) ) {
   audioMutex->unlock();
   return FALSE;
     }
 
     hasAudioChannel = mediaPlayerState->curDecoder()->audioStreams() > 0;
     hasVideoChannel = mediaPlayerState->curDecoder()->videoStreams() > 0;
 
     if ( hasAudioChannel ) {
   int astream = 0;
 
   channels = mediaPlayerState->curDecoder()->audioChannels( astream );
   qDebug( "LC- channels = %d", channels );
   
   if ( !total_audio_samples )
       total_audio_samples = mediaPlayerState->curDecoder()->audioSamples( astream );
 
 //  total_audio_samples += 1000;
 
   mediaPlayerState->setLength( total_audio_samples );
   
   freq = mediaPlayerState->curDecoder()->audioFrequency( astream );
   qDebug( "LC- frequency = %d", freq );
 
   audioSampleCounter = 0;
-
-   int bits_per_sample = mediaPlayerState->curDecoder()->audioBitsPerSample( astream);
+   int bits_per_sample;
+   if ( mediaPlayerState->curDecoder()->pluginName() == QString("LibWavPlugin") ) {
+       bits_per_sample =(int) mediaPlayerState->curDecoder()->getTime();
+       qDebug("using stupid hack");
+   } else {
+           bits_per_sample=0;
+   }
 
   audioDevice = new AudioDevice( freq, channels, bits_per_sample);
   audioBuffer = new char[ audioDevice->bufferSize() ];
   channels = audioDevice->channels();
 
   //### must check which frequency is actually used.
   static const int size = 1;
   short int buf[size];
   long samplesRead = 0;
   mediaPlayerState->curDecoder()->audioReadSamples( buf, channels, size, samplesRead, stream );
     }
 
     if ( hasVideoChannel ) {
   total_video_frames = mediaPlayerState->curDecoder()->videoFrames( stream );
 
   mediaPlayerState->setLength( total_video_frames );
 
   framerate = mediaPlayerState->curDecoder()->videoFrameRate( stream );
   DecodeLoopDebug(( "Frame rate %g total %ld", framerate, total_video_frames ));
 
   if ( framerate <= 1.0 ) {
       DecodeLoopDebug(( "Crazy frame rate, resetting to sensible" ));
       framerate = 25;
   }
 
   if ( total_video_frames == 1 ) {
       DecodeLoopDebug(( "Cannot seek to frame" ));
   }
 
     }
 
     current_frame = 0;
     prev_frame = -1;
 
     connect( mediaPlayerState, SIGNAL( positionChanged( long ) ), this, SLOT( setPosition( long ) ) );
     connect( mediaPlayerState, SIGNAL( pausedToggled( bool ) ), this, SLOT( setPaused( bool ) ) );
 
     audioMutex->unlock();
 
     return TRUE;
 }
 
 
 void LoopControl::play() {
-
+    qDebug("LC- play");
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     if ( !disabledSuspendScreenSaver || previousSuspendMode != hasVideoChannel ) {
   disabledSuspendScreenSaver = TRUE; 
   previousSuspendMode = hasVideoChannel;
         // Stop the screen from blanking and power saving state
   QCopEnvelope("QPE/System", "setScreenSaverMode(int)" ) 
       << ( hasVideoChannel ? QPEApplication::Disable : QPEApplication::DisableSuspend );
     }
 #endif
 
     playtime.start();
     startTimers();
 }
 
 
 void LoopControl::setMute( bool on ) {
     if ( on != isMuted ) {
   isMuted = on;
   if ( !on ) {
       // Force an update of the position
       mediaPlayerState->setPosition( mediaPlayerState->position() + 1 );
       mediaPlayerState->setPosition( mediaPlayerState->position() - 1 );
       // Resume playing audio
       moreAudio = TRUE;
   }
     }
 }
 
 
diff --git a/core/multimedia/opieplayer/main.cpp b/core/multimedia/opieplayer/main.cpp
index 720a1ca..4f43ff6 100644
--- a/core/multimedia/opieplayer/main.cpp
+++ b/core/multimedia/opieplayer/main.cpp
@@ -1,56 +1,56 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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 <qpe/qpeapplication.h>
 #include "mediaplayerstate.h"
 #include "playlistwidget.h"
 #include "audiowidget.h"
 #include "videowidget.h"
 #include "loopcontrol.h"
 #include "mediaplayer.h"
 
 MediaPlayerState *mediaPlayerState;
 PlayListWidget *playList;
 AudioWidget *audioUI;
 VideoWidget *videoUI;
 LoopControl *loopControl;
 
 
 int main(int argc, char **argv) {
     QPEApplication a(argc,argv);
 
     MediaPlayerState st( 0, "mediaPlayerState" );
     mediaPlayerState = &st;
     PlayListWidget pl( 0, "playList" );
     playList = &pl;
     AudioWidget aw( 0, "audioUI" );
     audioUI = &aw;
     VideoWidget vw( 0, "videoUI" );
     videoUI = &vw;
     LoopControl lc( 0, "loopControl" );
     loopControl = &lc;
     MediaPlayer mp( 0, "mediaPlayer" );
 
-    pl.setCaption( MediaPlayer::tr("Media Player") );
+    pl.setCaption( MediaPlayer::tr("OpiePlayer") );
     a.showMainDocumentWidget(&pl);
 
     return a.exec();
 }
 
 
diff --git a/core/multimedia/opieplayer/mediaplayer.cpp b/core/multimedia/opieplayer/mediaplayer.cpp
index ce42c2c..c971a3c 100644
--- a/core/multimedia/opieplayer/mediaplayer.cpp
+++ b/core/multimedia/opieplayer/mediaplayer.cpp
@@ -1,183 +1,178 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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 <qpe/qpeapplication.h>
 #include <qpe/qlibrary.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <qwidgetstack.h>
 #include <qfile.h>
 
 #include "mediaplayer.h"
 #include "playlistwidget.h"
 #include "audiowidget.h"
 #include "loopcontrol.h"
 #include "audiodevice.h"
 
 #include "mediaplayerstate.h"
 
 
 extern AudioWidget *audioUI;
 extern PlayListWidget *playList;
 extern LoopControl *loopControl;
 extern MediaPlayerState *mediaPlayerState;
 
 
 MediaPlayer::MediaPlayer( QObject *parent, const char *name )
     : QObject( parent, name ), volumeDirection( 0 ), currentFile( NULL ) {
 
     connect( mediaPlayerState, SIGNAL( playingToggled( bool ) ), this, SLOT( setPlaying( bool ) ) );
     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( next() ),     this, SLOT( next() ) );
+    connect( mediaPlayerState, SIGNAL( prev() ),     this, SLOT( prev() ) );
 
     connect( audioUI,  SIGNAL( moreClicked() ),         this, SLOT( startIncreasingVolume() ) );
     connect( audioUI,  SIGNAL( lessClicked() ),         this, SLOT( startDecreasingVolume() ) );
     connect( audioUI,  SIGNAL( moreReleased() ),        this, SLOT( stopChangingVolume() ) );
     connect( audioUI,  SIGNAL( lessReleased() ),        this, SLOT( stopChangingVolume() ) );
 }
 
 
 MediaPlayer::~MediaPlayer() {
 }
 
 
 void MediaPlayer::pauseCheck( bool b ) {
     // Only pause if playing
     if ( b && !mediaPlayerState->playing() )
-        mediaPlayerState->setPaused( FALSE );
+  mediaPlayerState->setPaused( FALSE );
 }
 
 
 void MediaPlayer::play() {
     mediaPlayerState->setPlaying( FALSE );
     mediaPlayerState->setPlaying( TRUE );
 }
 
 
 void MediaPlayer::setPlaying( bool play ) {
-
     if ( !play ) {
-        mediaPlayerState->setPaused( FALSE );
-        loopControl->stop( FALSE );
-        return;
+  mediaPlayerState->setPaused( FALSE );
+  loopControl->stop( FALSE );
+  return;
     }
 
     if ( mediaPlayerState->paused() ) {
-        mediaPlayerState->setPaused( FALSE );
-        return;
+  mediaPlayerState->setPaused( FALSE );
+  return;
     }
 
     const DocLnk *playListCurrent = playList->current();
-
     if ( playListCurrent != NULL ) {
-        loopControl->stop( TRUE );
-        currentFile = playListCurrent;
+  loopControl->stop( TRUE );
+  currentFile = playListCurrent;
     }
-
     if ( currentFile == NULL ) {
-        QMessageBox::critical( 0, tr( "No file"), tr( "Error: There is no file selected" ) );
-        mediaPlayerState->setPlaying( FALSE );
-        return;
+  QMessageBox::critical( 0, tr( "No file"), tr( "Error: There is no file selected" ) );
+  mediaPlayerState->setPlaying( FALSE );
+  return;
     }
-
     if ( !QFile::exists( currentFile->file() ) ) {
-        QMessageBox::critical( 0, tr( "File not found"), tr( "The following file was not found: <i>" ) + currentFile->file() + "</i>" );
-        mediaPlayerState->setPlaying( FALSE );
-        return;
+  QMessageBox::critical( 0, tr( "File not found"), tr( "The following file was not found: <i>" ) + currentFile->file() + "</i>" );
+  mediaPlayerState->setPlaying( FALSE );
+  return;
     }
 
     if ( !mediaPlayerState->newDecoder( currentFile->file() ) ) {
-        QMessageBox::critical( 0, tr( "No decoder found"), tr( "Sorry, no appropriate decoders found for this file: <i>" ) + currentFile->file() + "</i>" );
-        mediaPlayerState->setPlaying( FALSE );
-        return;
+  QMessageBox::critical( 0, tr( "No decoder found"), tr( "Sorry, no appropriate decoders found for this file: <i>" ) + currentFile->file() + "</i>" );
+  mediaPlayerState->setPlaying( FALSE );
+  return;
     }
 
     if ( !loopControl->init( currentFile->file() ) ) {
-        QMessageBox::critical( 0, tr( "Error opening file"), tr( "Sorry, an error occured trying to play the file: <i>" ) + currentFile->file() + "</i>" );
-        mediaPlayerState->setPlaying( FALSE );
-        return;
+  QMessageBox::critical( 0, tr( "Error opening file"), tr( "Sorry, an error occured trying to play the file: <i>" ) + currentFile->file() + "</i>" );
+  mediaPlayerState->setPlaying( FALSE );
+  return;
     }
-
     long seconds = loopControl->totalPlaytime();
     QString time; time.sprintf("%li:%02i", seconds/60, (int)seconds%60 );
     QString tickerText = tr( " File: " ) + currentFile->name() + tr(", Length: ") + time;
     QString fileInfo = mediaPlayerState->curDecoder()->fileInfo();
     if ( !fileInfo.isEmpty() )
-        tickerText += ", " + fileInfo;
+  tickerText += ", " + fileInfo;
     audioUI->setTickerText( tickerText + "." );
 
     loopControl->play();
 
     mediaPlayerState->setView( loopControl->hasVideo() ? 'v' : 'a' );
 }
 
 
 void MediaPlayer::prev() {
     if ( playList->prev() )
-        play();
+  play();
     else if ( mediaPlayerState->looping() ) {
         if ( playList->last() )
-            play();
+      play();
     } else 
-        mediaPlayerState->setList();
+  mediaPlayerState->setList();
 }
 
 
 void MediaPlayer::next() {
     if ( playList->next() ) 
-        play(); 
+  play(); 
     else if ( mediaPlayerState->looping() ) {
         if ( playList->first() )
-            play();
+      play();
     } else
-        mediaPlayerState->setList();
+  mediaPlayerState->setList();
 }
 
 
 void MediaPlayer::startDecreasingVolume() {
     volumeDirection = -1;
     startTimer( 100 );
     AudioDevice::decreaseVolume();
 }
 
 
 void MediaPlayer::startIncreasingVolume() {
     volumeDirection = +1;
     startTimer( 100 );
     AudioDevice::increaseVolume();
 }
 
 
 void MediaPlayer::stopChangingVolume() {
     killTimers();
 }
 
 
 void MediaPlayer::timerEvent( QTimerEvent * ) {
     if ( volumeDirection == +1 ) 
-        AudioDevice::increaseVolume();
+  AudioDevice::increaseVolume();
     else if ( volumeDirection == -1 ) 
         AudioDevice::decreaseVolume();
 }
 
diff --git a/core/multimedia/opieplayer/mediaplayer.h b/core/multimedia/opieplayer/mediaplayer.h
index 73f8124..d6e90cb 100644
--- a/core/multimedia/opieplayer/mediaplayer.h
+++ b/core/multimedia/opieplayer/mediaplayer.h
@@ -1,58 +1,58 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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.
 **
 **********************************************************************/
 #ifndef MEDIA_PLAYER_H
 #define MEDIA_PLAYER_H
 
 #include <qmainwindow.h>
 #include <qframe.h>
 #include <qpe/qlibrary.h>
 #include <qpe/mediaplayerplugininterface.h>
 
 
 class DocLnk;
 
 
 class MediaPlayer : public QObject {
     Q_OBJECT
 public:
     MediaPlayer( QObject *parent, const char *name );
     ~MediaPlayer();
 
 private slots:
     void setPlaying( bool );
     void pauseCheck( bool );
     void play();
     void next();
     void prev();
     void startIncreasingVolume();
     void startDecreasingVolume();
     void stopChangingVolume();
 
 protected:
     void timerEvent( QTimerEvent *e );
 
 private:
-            int                 volumeDirection;
-            const DocLnk*currentFile;
+    int     volumeDirection;
+    const DocLnk  *currentFile;
 };
 
 
 #endif // MEDIA_PLAYER_H
 
diff --git a/core/multimedia/opieplayer/mediaplayerplugininterface.h b/core/multimedia/opieplayer/mediaplayerplugininterface.h
index 339b2e4..97e4066 100644
--- a/core/multimedia/opieplayer/mediaplayerplugininterface.h
+++ b/core/multimedia/opieplayer/mediaplayerplugininterface.h
@@ -1,111 +1,124 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #ifndef MEDIA_PLAYER_PLUGIN_INTERFACE_H
 #define MEDIA_PLAYER_PLUGIN_INTERFACE_H
 
 #include <qpe/qcom.h>
 
 #ifndef QT_NO_COMPONENT
-// {c0093632-b44c-4cf7-a279-d82fe8a8890c}
+# ifndef IID_OpiePlayerPlugin
+// {F56F6CE0-1333-41FD-9B46-C0AF44D0B006}
+# define IID_OpiePlayerPlugin QUuid( 0xF56F6CE0, 0x1333, 0x41FD, 0x9B, 0x46, 0xC0, 0xAF, 0x44, 0xD0, 0xB0, 0x06);
+# endif
 # ifndef IID_MediaPlayerPlugin
+// {c0093632-b44c-4cf7-a279-d82fe8a8890c}
 #  define IID_MediaPlayerPlugin QUuid( 0xc0093632, 0xb44c, 0x4cf7, 0xa2, 0x79, 0xd8, 0x2f, 0xe8, 0xa8, 0x89, 0x0c )
 # endif
 #endif
 
 
 enum ColorFormat {
     RGB565,
     BGR565,
     RGBA8888,
     BGRA8888
 };
 
 
 class MediaPlayerDecoder {
 
 public:
     virtual ~MediaPlayerDecoder() { };
    
     // About Plugin 
     virtual const char *pluginName() = 0;
     virtual const char *pluginComment() = 0;
     virtual double pluginVersion() = 0;
 
     virtual bool isFileSupported( const QString& file ) = 0;
     virtual bool open( const QString& file ) = 0;
     virtual bool close() = 0;
     virtual bool isOpen() = 0;
     virtual const QString &fileInfo() = 0;
 
     // If decoder doesn't support audio then return 0 here
     virtual int audioStreams() = 0;
     virtual int audioChannels( int stream ) = 0;
     virtual int audioFrequency( int stream ) = 0;
     virtual int audioSamples( int stream ) = 0;
     virtual bool audioSetSample( long sample, int stream ) = 0;
     virtual long audioGetSample( int stream ) = 0;
     virtual bool audioReadSamples( short *samples, int channels, long samples, long& samplesRead, int stream ) = 0;
 
     // If decoder doesn't support video then return 0 here
     virtual int videoStreams() = 0;
     virtual int videoWidth( int stream ) = 0;
     virtual int videoHeight( int stream ) = 0;
     virtual double videoFrameRate( int stream ) = 0; // frames per second (this may change to frames/1000secs)
     virtual int videoFrames( int stream ) = 0;
     virtual bool videoSetFrame( long sample, int stream ) = 0;
     virtual long videoGetFrame( int stream ) = 0;
     virtual bool videoReadFrame( unsigned char **output_rows, int in_x, int in_y, int in_w, int in_h, ColorFormat color_model, int stream ) = 0;
     virtual bool 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 ) = 0;
     virtual bool videoReadYUVFrame( char *y_output, char *u_output, char *v_output, int in_x, int in_y, int in_w, int in_h, int stream ) = 0;
 
     // Profiling
     virtual double getTime() = 0;
 
     // Ignore if these aren't supported
     virtual bool setSMP( int cpus ) = 0;
     virtual bool setMMX( bool useMMX ) = 0;
 
     // Capabilities
     virtual bool supportsAudio() = 0;
     virtual bool supportsVideo() = 0;
     virtual bool supportsYUV() = 0;
     virtual bool supportsMMX() = 0;
     virtual bool supportsSMP() = 0;
     virtual bool supportsStereo() = 0;
     virtual bool supportsScaling() = 0;
 
     // File Properies
     virtual long getPlayTime() { return -1; }
+#ifdef IID_OpiePlayerPlugin
     virtual int audioBitsPerSample( int stream ) = 0;
+#endif    
 };
 
 
 class MediaPlayerEncoder;
 
 
 struct MediaPlayerPluginInterface : public QUnknownInterface
 {
     virtual MediaPlayerDecoder *decoder() = 0;
     virtual MediaPlayerEncoder *encoder() = 0;
 };
 
+#ifdef IID_OpiePlayerPlugin
+struct OpiePlayerPluginInterface : public QUnknownInterface
+{
+    virtual MediaPlayerDecoder *decoder() = 0;
+    virtual MediaPlayerEncoder *encoder() = 0;
+};
+#endif
 
 #endif
 
diff --git a/core/multimedia/opieplayer/mediaplayerstate.cpp b/core/multimedia/opieplayer/mediaplayerstate.cpp
index 13741f6..a960c49 100644
--- a/core/multimedia/opieplayer/mediaplayerstate.cpp
+++ b/core/multimedia/opieplayer/mediaplayerstate.cpp
@@ -1,190 +1,191 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #include <qpe/qpeapplication.h>
 #include <qpe/qlibrary.h>
 #include <qpe/config.h>
 #include <qvaluelist.h>
 #include <qobject.h>
 #include <qdir.h>
-#include "mediaplayerplugininterface.h"
+#include <qpe/mediaplayerplugininterface.h>
 #include "mediaplayerstate.h"
 
 
+
 #ifdef QT_NO_COMPONENT
 // Plugins which are compiled in when no plugin architecture available
 #include "libmad/libmadpluginimpl.h"
 #include "libmpeg3/libmpeg3pluginimpl.h"
 #include "wavplugin/wavpluginimpl.h"
 #endif
 
 
 //#define MediaPlayerDebug(x) qDebug x
 #define MediaPlayerDebug(x)
 
 
 MediaPlayerState::MediaPlayerState( QObject *parent, const char *name )
     : QObject( parent, name ), decoder( NULL ), libmpeg3decoder( NULL ) {
     Config cfg( "MediaPlayer" );
     readConfig( cfg );
     loadPlugins();
 }
 
 
 MediaPlayerState::~MediaPlayerState() {
     Config cfg( "MediaPlayer" );
     writeConfig( cfg );
 }
 
 
 void MediaPlayerState::readConfig( Config& cfg ) {
     cfg.setGroup("Options");
     isFullscreen = cfg.readBoolEntry( "FullScreen" );
     isScaled = cfg.readBoolEntry( "Scaling" );
     isLooping = cfg.readBoolEntry( "Looping" );
     isShuffled = cfg.readBoolEntry( "Shuffle" );
     usePlaylist = cfg.readBoolEntry( "UsePlayList" );
+    usePlaylist = TRUE;
     isPlaying = FALSE;
     isPaused = FALSE;
     curPosition = 0;
     curLength = 0;
     curView = 'l';
 }
 
 
 void MediaPlayerState::writeConfig( Config& cfg ) const {
     cfg.setGroup("Options");
     cfg.writeEntry("FullScreen", isFullscreen );
     cfg.writeEntry("Scaling", isScaled );
     cfg.writeEntry("Looping", isLooping );
     cfg.writeEntry("Shuffle", isShuffled );
     cfg.writeEntry("UsePlayList", usePlaylist );
 }
 
 
 struct MediaPlayerPlugin {
 #ifndef QT_NO_COMPONENT
     QLibrary *library;
 #endif
     MediaPlayerPluginInterface *iface;
     MediaPlayerDecoder *decoder;
     MediaPlayerEncoder *encoder;
 };
 
 
 static QValueList<MediaPlayerPlugin> pluginList;
 
 
 // Find the first decoder which supports this type of file
 MediaPlayerDecoder *MediaPlayerState::newDecoder( const QString& file ) {
     MediaPlayerDecoder *tmpDecoder = NULL;
     QValueList<MediaPlayerPlugin>::Iterator it;
     for ( it = pluginList.begin(); it != pluginList.end(); ++it ) {
   if ( (*it).decoder->isFileSupported( file ) ) {
       tmpDecoder = (*it).decoder;
       break;
   }
     }
     return decoder = tmpDecoder; 
 }
 
 
 MediaPlayerDecoder *MediaPlayerState::curDecoder() {
     return decoder;
 }
 
 
 // ### hack to get true sample count
 MediaPlayerDecoder *MediaPlayerState::libMpeg3Decoder() {
     return libmpeg3decoder;
 }
 
 // ### hack to get true sample count
 // MediaPlayerDecoder *MediaPlayerState::libWavDecoder() {
 //     return libwavdecoder;
 // }
 
 void MediaPlayerState::loadPlugins() {
-
+    qDebug("load plugins");
 #ifndef QT_NO_COMPONENT
     QValueList<MediaPlayerPlugin>::Iterator mit;
     for ( mit = pluginList.begin(); mit != pluginList.end(); ++mit ) {
   (*mit).iface->release();
   (*mit).library->unload();
   delete (*mit).library;
     }
     pluginList.clear();
 
     QString path = QPEApplication::qpeDir() + "/plugins/codecs";
     QDir dir( path, "lib*.so" );
     QStringList list = dir.entryList();
     QStringList::Iterator it;
     for ( it = list.begin(); it != list.end(); ++it ) {
   MediaPlayerPluginInterface *iface = 0;
   QLibrary *lib = new QLibrary( path + "/" + *it );
-
-  MediaPlayerDebug(( "querying: %s", QString( path + "/" + *it ).latin1() ));
+//   qDebug( "querying: %s", QString( path + "/" + *it ).latin1() );
 
   if ( lib->queryInterface( IID_MediaPlayerPlugin, (QUnknownInterface**)&iface ) == QS_OK ) {
 
-      MediaPlayerDebug(( "loading: %s", QString( path + "/" + *it ).latin1() ));
+//       qDebug( "loading: %s", QString( path + "/" + *it ).latin1() );
 
       MediaPlayerPlugin plugin;
       plugin.library = lib;
       plugin.iface = iface;
       plugin.decoder = plugin.iface->decoder();
       plugin.encoder = plugin.iface->encoder();
       pluginList.append( plugin );
 
       // ### hack to get true sample count
       if ( plugin.decoder->pluginName() == QString("LibMpeg3Plugin") )
     libmpeg3decoder = plugin.decoder;
 
   } else {
       delete lib;
   }
     }
 #else
     pluginList.clear();
     
     MediaPlayerPlugin plugin0;
     plugin0.iface = new LibMpeg3PluginImpl;
     plugin0.decoder = plugin0.iface->decoder();
     plugin0.encoder = plugin0.iface->encoder();
     pluginList.append( plugin0 );
 
     MediaPlayerPlugin plugin1;
     plugin1.iface = new LibMadPluginImpl;
     plugin1.decoder = plugin1.iface->decoder();
     plugin1.encoder = plugin1.iface->encoder();
     pluginList.append( plugin1 );
 
     MediaPlayerPlugin plugin2;
     plugin2.iface = new WavPluginImpl;
     plugin2.decoder = plugin2.iface->decoder();
     plugin2.encoder = plugin2.iface->encoder();
     pluginList.append( plugin2 );
 #endif
 
     if ( pluginList.count() ) 
   MediaPlayerDebug(( "%i decoders found", pluginList.count() ));
     else
   MediaPlayerDebug(( "No decoders found" ));
 }
 
diff --git a/core/multimedia/opieplayer/mediaplayerstate.h b/core/multimedia/opieplayer/mediaplayerstate.h
index e82c263..ad273f1 100644
--- a/core/multimedia/opieplayer/mediaplayerstate.h
+++ b/core/multimedia/opieplayer/mediaplayerstate.h
@@ -1,116 +1,119 @@
 /**********************************************************************
-** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
+** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
-** This file is part of the Qtopia Environment.
+** 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.
 **
 **********************************************************************/
 #ifndef MEDIA_PLAYER_STATE_H
 #define MEDIA_PLAYER_STATE_H
 
+
 #include <qobject.h>
 
 
 class MediaPlayerDecoder;
 class Config;
 
 
 class MediaPlayerState : public QObject {
 Q_OBJECT
 public:
     MediaPlayerState( QObject *parent, const char *name );
     ~MediaPlayerState();
 
-            bool fullscreen()    { return isFullscreen; }
-            bool scaled()        { return isScaled; }
-            bool looping()       { return isLooping; }
-            bool shuffled()      { return isShuffled; }
-            bool playlist()      { return usePlaylist; }
-            bool paused()        { return isPaused; }
-            bool playing()       { return isPlaying; }
-            long position()      { return curPosition; }
-            long length()        { return curLength; }
-            char view()                  { return curView; }
+    
+    bool fullscreen()    { return isFullscreen; }
+    bool scaled()    { return isScaled; }
+    bool looping()     { return isLooping; }
+    bool shuffled()    { return isShuffled; }
+    bool playlist()    { return usePlaylist; }
+    bool paused()    { return isPaused; }
+    bool playing()     { return isPlaying; }
+    long position()    { return curPosition; }
+    long length()    { return curLength; }
+    char view()      { return curView; }
 
     MediaPlayerDecoder *newDecoder( const QString& file );
     MediaPlayerDecoder *curDecoder();
     MediaPlayerDecoder *libMpeg3Decoder(); // ### Yucky hack needed to use libmpeg3plugin to get the
-                                           // number of audio samples if we are using the libmad plugin
+             // number of audio samples if we are using the libmad plugin
 public slots:
     void setFullscreen( bool b ) { if ( isFullscreen == b ) return; isFullscreen = b; emit fullscreenToggled(b); }
     void setScaled( bool b )     { if ( isScaled     == b ) return; isScaled = b;     emit scaledToggled(b); }
     void setLooping( bool b )    { if ( isLooping    == b ) return; isLooping = b;    emit loopingToggled(b); }
     void setShuffled( bool b )   { if ( isShuffled   == b ) return; isShuffled = b;   emit shuffledToggled(b); }
     void setPlaylist( bool b )   { if ( usePlaylist  == b ) return; usePlaylist = b;  emit playlistToggled(b); }
-            void setPaused( bool b ) { if ( isPaused     == b ) return; isPaused = b;     emit pausedToggled(b); }
-            void setPlaying( bool b ) { if ( isPlaying    == b ) return; isPlaying = b;    emit playingToggled(b); }
+    void setPaused( bool b )   { if ( isPaused     == b ) return; isPaused = b;     emit pausedToggled(b); }
+    void setPlaying( bool b )  { if ( isPlaying    == b ) return; isPlaying = b;    emit playingToggled(b); }
     void setPosition( long p )   { if ( curPosition  == p ) return; curPosition = p;  emit positionChanged(p); }
     void updatePosition( long p ){ if ( curPosition  == p ) return; curPosition = p;  emit positionUpdated(p); }
-            void setLength( long l ) { if ( curLength    == l ) return; curLength = l;    emit lengthChanged(l); }
-            void setView( char v ) { if ( curView      == v ) return; curView = v;      emit viewChanged(v); }
-
-            void setPrev()       { emit prev(); }
-            void setNext()       { emit next(); }
-            void setList()       { setPlaying( FALSE ); setView('l'); }
-            void setVideo()      { setView('v'); }
-            void setAudio()      { setView('a'); }
-
-            void toggleFullscreen() { setFullscreen( !isFullscreen ); }
-            void toggleScaled()          { setScaled( !isScaled); }
-            void toggleLooping() { setLooping( !isLooping); }
-            void toggleShuffled() { setShuffled( !isShuffled); }
-            void togglePlaylist() { setPlaylist( !usePlaylist); }
-            void togglePaused()          { setPaused( !isPaused); }
-            void togglePlaying() { setPlaying( !isPlaying); }
+    void setLength( long l )   { if ( curLength    == l ) return; curLength = l;    emit lengthChanged(l); }
+    void setView( char v )   { if ( curView      == v ) return; curView = v;      emit viewChanged(v); }
+
+    void setPrev()     { emit prev(); }
+    void setNext()     { emit next(); }
+    void setList()     { setPlaying( FALSE ); setView('l'); }
+    void setVideo()    { setView('v'); }
+    void setAudio()    { setView('a'); }
+
+    void toggleFullscreen()  { setFullscreen( !isFullscreen ); }
+    void toggleScaled()    { setScaled( !isScaled); }
+    void toggleLooping()   { setLooping( !isLooping); }
+    void toggleShuffled()  { setShuffled( !isShuffled); }
+    void togglePlaylist()  { setPlaylist( !usePlaylist); }
+    void togglePaused()    { setPaused( !isPaused); }
+    void togglePlaying()   { setPlaying( !isPlaying); }
 
 signals:
     void fullscreenToggled( bool );
     void scaledToggled( bool );
     void loopingToggled( bool );
     void shuffledToggled( bool );
     void playlistToggled( bool );
     void pausedToggled( bool );
     void playingToggled( bool );
     void positionChanged( long ); // When the slider is moved
     void positionUpdated( long ); // When the media file progresses
     void lengthChanged( long );
     void viewChanged( char );
 
     void prev();
     void next();
 
 private:
     bool isFullscreen;
     bool isScaled;
     bool isLooping;
     bool isShuffled;
     bool usePlaylist;
     bool isPaused;
     bool isPlaying;
     long curPosition;
     long curLength;
     char curView;
 
     MediaPlayerDecoder *decoder;
     MediaPlayerDecoder *libmpeg3decoder;
+//    MediaPlayerDecoder *libwavdecoder;
 
     void loadPlugins();
     void readConfig( Config& cfg );
     void writeConfig( Config& cfg ) const;
 };
 
 
 #endif // MEDIA_PLAYER_STATE_H
 
diff --git a/core/multimedia/opieplayer/mpegplayer.pro b/core/multimedia/opieplayer/mpegplayer.pro
index 41f2de0..5bea541 100644
--- a/core/multimedia/opieplayer/mpegplayer.pro
+++ b/core/multimedia/opieplayer/mpegplayer.pro
@@ -1,22 +1,25 @@
 TEMPLATE  = app
 CONFIG    = qt warn_on release
 #release
 DESTDIR   = $(OPIEDIR)/bin
 HEADERS   = loopcontrol.h mediaplayerplugininterface.h playlistselection.h mediaplayerstate.h \
-      videowidget.h audiowidget.h playlistwidget.h mediaplayer.h audiodevice.h
+      videowidget.h audiowidget.h playlistwidget.h mediaplayer.h audiodevice.h inputDialog.h
 SOURCES   = main.cpp \
       loopcontrol.cpp playlistselection.cpp mediaplayerstate.cpp \
-      videowidget.cpp audiowidget.cpp playlistwidget.cpp mediaplayer.cpp audiodevice.cpp
+      videowidget.cpp audiowidget.cpp playlistwidget.cpp mediaplayer.cpp audiodevice.cpp inputDialog.cpp
 TARGET    = mpegplayer
 INCLUDEPATH += $(OPIEDIR)/include
 DEPENDPATH  += $(OPIEDIR)/include
 LIBS            += -lqpe -lpthread
 
 # INTERFACES  = 
 # INCLUDEPATH += $(OPIEDIR)/include
 # CONFIG+=static
 # TMAKE_CXXFLAGS += -DQPIM_STANDALONE
 # LIBS    += libmpeg3/libmpeg3.a -lpthread
 # LIBS    += $(OPIEDIR)/plugins/codecs/liblibmadplugin.so
 
+INCLUDEPATH += $(OPIEDIR)/include
+DEPENDPATH  += $(OPIEDIR)/include
+
 TRANSLATIONS = ../i18n/de/mpegplayer.ts
diff --git a/core/multimedia/opieplayer/playlistselection.cpp b/core/multimedia/opieplayer/playlistselection.cpp
index 2c62e86..d70df51 100644
--- a/core/multimedia/opieplayer/playlistselection.cpp
+++ b/core/multimedia/opieplayer/playlistselection.cpp
@@ -1,181 +1,181 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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 <qpe/applnk.h>
 #include <qpe/resource.h>
 #include <qpainter.h>
 #include <qimage.h>
 #include <qheader.h>
 #include <qlistview.h>
 #include <qlist.h>
 #include <qpixmap.h>
 
 #include "playlistselection.h"
 
 #include <stdlib.h>
 
 class PlayListSelectionItem : public QListViewItem {
 public:
     PlayListSelectionItem( QListView *parent, const DocLnk *f ) : QListViewItem( parent ), fl( f ) {
   setText( 0, f->name() );
   setPixmap( 0, f->pixmap() );
     }
 
     ~PlayListSelectionItem() {
     };
 
     const DocLnk *file() const { return fl; }
 
 private:
     const DocLnk *fl;
 };
 
 
 PlayListSelection::PlayListSelection( QWidget *parent, const char *name )
     : QListView( parent, name )
 {
 // #ifdef USE_PLAYLIST_BACKGROUND
     setStaticBackground( TRUE );
 //    setBackgroundPixmap( Resource::loadPixmap( "mpegplayer/background" ) );
     setBackgroundPixmap( Resource::loadPixmap( "opielogo" ) );
 // #endif
-    addColumn("Title",236);
-    setAllColumnsShowFocus( TRUE );
-    addColumn( tr( "Playlist Selection" ) );
+//      addColumn("Title",236);
+//      setAllColumnsShowFocus( TRUE );
+      addColumn( tr( "Playlist Selection" ) );
     header()->hide();
     setSorting( -1, FALSE );
 }
 
 
 PlayListSelection::~PlayListSelection() {
 }
 
 
 // #ifdef USE_PLAYLIST_BACKGROUND
 void PlayListSelection::drawBackground( QPainter *p, const QRect &r ) {
     p->fillRect( r, QBrush( white ) );
 //    QImage logo = Resource::loadImage( "mpegplayer/background" );
     QImage logo = Resource::loadImage( "opielogo" );
     if ( !logo.isNull() )
   p->drawImage( (width() - logo.width()) / 2, (height() - logo.height()) / 2, logo );
 }
 // #endif
 
 
 void PlayListSelection::contentsMouseMoveEvent( QMouseEvent *event ) {
     if ( event->state() == QMouseEvent::LeftButton ) {
   QListViewItem *currentItem = selectedItem();
   QListViewItem *itemUnder = itemAt( QPoint( event->pos().x(), event->pos().y() - contentsY() ) );
   if ( currentItem && currentItem->itemAbove() == itemUnder )
       moveSelectedUp();
   else if ( currentItem && currentItem->itemBelow() == itemUnder )
       moveSelectedDown();
     }
 }
 
 
 const DocLnk *PlayListSelection::current() {
     PlayListSelectionItem *item = (PlayListSelectionItem *)selectedItem();
     if ( item )
   return item->file();
     return NULL;
 }
 
 
 void PlayListSelection::addToSelection( const DocLnk &lnk ) {
     PlayListSelectionItem *item = new PlayListSelectionItem( this, new DocLnk( lnk ) );
     QListViewItem *current = selectedItem();
     if ( current )
         item->moveItem( current );
     setSelected( item, TRUE );
     ensureItemVisible( selectedItem() );
 }
 
 
 void PlayListSelection::removeSelected() {
     QListViewItem *item = selectedItem();
     if ( item )
   delete item;
     setSelected( currentItem(), TRUE );
     ensureItemVisible( selectedItem() );
 }
 
 
 void PlayListSelection::moveSelectedUp() {
     QListViewItem *item = selectedItem();
     if ( item && item->itemAbove() )
   item->itemAbove()->moveItem( item );
     ensureItemVisible( selectedItem() );
 }
 
 
 void PlayListSelection::moveSelectedDown() {
     QListViewItem *item = selectedItem();
     if ( item && item->itemBelow() )
         item->moveItem( item->itemBelow() );
     ensureItemVisible( selectedItem() );
 }
 
 
 bool PlayListSelection::prev() {
     QListViewItem *item = selectedItem();
     if ( item && item->itemAbove() )
         setSelected( item->itemAbove(), TRUE );
     else
   return FALSE;
     ensureItemVisible( selectedItem() );
     return TRUE;
 }
 
 
 bool PlayListSelection::next() {
     QListViewItem *item = selectedItem();
     if ( item && item->itemBelow() )
         setSelected( item->itemBelow(), TRUE );
     else
   return FALSE;
     ensureItemVisible( selectedItem() );
     return TRUE;
 }
 
 
 bool PlayListSelection::first() {
     QListViewItem *item = firstChild();
     if ( item )
         setSelected( item, TRUE );
     else
   return FALSE;
     ensureItemVisible( selectedItem() );
     return TRUE;
 }
 
 
 bool PlayListSelection::last() {
     QListViewItem *prevItem = NULL;
     QListViewItem *item = firstChild();
     while ( ( item = item->nextSibling() ) )
   prevItem = item;
     if ( prevItem )
         setSelected( prevItem, TRUE );
     else
   return FALSE;
     ensureItemVisible( selectedItem() );
     return TRUE;
 }
 
diff --git a/core/multimedia/opieplayer/playlistwidget.cpp b/core/multimedia/opieplayer/playlistwidget.cpp
index 202f351..7862d8d 100644
--- a/core/multimedia/opieplayer/playlistwidget.cpp
+++ b/core/multimedia/opieplayer/playlistwidget.cpp
@@ -1,649 +1,762 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
+// code added by L. J. Potter Sat 03-02-2002 06:17:54
 
 #include <qpe/qpemenubar.h>
 #include <qpe/qpetoolbar.h>
 #include <qpe/fileselector.h>
 #include <qpe/qpeapplication.h>
 
 #include <qpe/applnk.h>
 #include <qpe/config.h>
 #include <qpe/global.h>
 #include <qpe/resource.h>
 #include <qaction.h>
 #include <qimage.h>
 #include <qfile.h>
 #include <qlayout.h>
 #include <qlabel.h>
 #include <qlist.h>
 #include <qlistbox.h>
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <qtoolbutton.h>
 #include <qtabwidget.h>
 #include <qlistview.h>
 #include <qpoint.h>
+#include <qlineedit.h>
+#include <qpushbutton.h>
+
 //#include <qtimer.h>
 
 #include "playlistselection.h"
 #include "playlistwidget.h"
 #include "mediaplayerstate.h"
 
+#include "fileBrowser.h"
+#include "inputDialog.h"
+
 #include <stdlib.h>
 
 #define BUTTONS_ON_TOOLBAR
 #define SIDE_BUTTONS
 #define CAN_SAVE_LOAD_PLAYLISTS
 
 extern MediaPlayerState *mediaPlayerState;
 
 // class myFileSelector {
 
 // };
 class PlayListWidgetPrivate {
 public:
     QToolButton *tbPlay, *tbFull, *tbLoop, *tbScale, *tbShuffle, *tbAddToList,  *tbRemoveFromList, *tbMoveUp, *tbMoveDown, *tbRemove;
     QFrame *playListFrame;
     FileSelector *files;
     PlayListSelection *selectedFiles;
     bool setDocumentUsed;
     DocLnk *current;
 };
 
 
 class ToolButton : public QToolButton {
 public:
     ToolButton( QWidget *parent, const char *name, const QString& icon, QObject *handler, const QString& slot, bool t = FALSE )
   : QToolButton( parent, name ) {
   setTextLabel( name );
   setPixmap( Resource::loadPixmap( icon ) );
   setAutoRaise( TRUE );
   setFocusPolicy( QWidget::NoFocus );
   setToggleButton( t );
   connect( this, t ? SIGNAL( toggled(bool) ) : SIGNAL( clicked() ), handler, slot );
   QPEMenuToolFocusManager::manager()->addWidget( this );
     }
 };
 
 
 class MenuItem : public QAction {
 public:
     MenuItem( QWidget *parent, const QString& text, QObject *handler, const QString& slot )
   : QAction( text, QString::null, 0, 0 ) {
   connect( this, SIGNAL( activated() ), handler, slot );
   addTo( parent );
     }
 };
 
 
 PlayListWidget::PlayListWidget( QWidget* parent, const char* name, WFlags fl )
     : QMainWindow( parent, name, fl ) {
 
     d = new PlayListWidgetPrivate;
     d->setDocumentUsed = FALSE;
     d->current = NULL;
 //    menuTimer = new QTimer( this ,"menu timer"),
 //     connect( menuTimer, SIGNAL( timeout() ), SLOT( addSelected() ) );
 
     setBackgroundMode( PaletteButton );
 
     setCaption( tr("OpiePlayer") );
     setIcon( Resource::loadPixmap( "MPEGPlayer" ) );
 
     setToolBarsMovable( FALSE );
 
     // Create Toolbar
     QPEToolBar *toolbar = new QPEToolBar( this );
     toolbar->setHorizontalStretchable( TRUE );
 
     // Create Menubar
     QPEMenuBar *menu = new QPEMenuBar( toolbar );
     menu->setMargin( 0 );
 
     QPEToolBar *bar = new QPEToolBar( this );
     bar->setLabel( tr( "Play Operations" ) );
-    d->tbAddToList =  new ToolButton( bar, tr( "Add to Playlist" ),"mpegplayer/add_to_playlist",this , SLOT(addSelected()) );
-    d->tbRemoveFromList = new ToolButton( bar, tr( "Remove from Playlist" ), "mpegplayer/remove_from_playlist", this , SLOT(removeSelected()) );
-    d->tbPlay    = new ToolButton( bar, tr( "Play" ),"mpegplayer/play", mediaPlayerState, SLOT( setPlaying(bool)), TRUE );
-    d->tbShuffle = new ToolButton( bar, tr( "Randomize" ), "mpegplayer/shuffle", mediaPlayerState, SLOT(setShuffled(bool)), TRUE );
-    d->tbLoop    = new ToolButton( bar, tr( "Loop" ),"mpegplayer/loop", mediaPlayerState, SLOT(setLooping(bool)), TRUE );
+//      d->tbPlayCurList =  new ToolButton( bar, tr( "play List" ), "mpegplayer/play_current_list",
+//                                        this , SLOT( addSelected()) );
+    tbDeletePlaylist = new QPushButton( Resource::loadIconSet("close"),"",bar,"close");
+    tbDeletePlaylist->setFlat(TRUE);
+    tbDeletePlaylist->setFixedSize(20,20);
+    connect(tbDeletePlaylist,(SIGNAL(released())),SLOT( deletePlaylist()));
+    
+    d->tbAddToList =  new ToolButton( bar, tr( "Add to Playlist" ), "mpegplayer/add_to_playlist",
+                                      this , SLOT(addSelected()) );
+    d->tbRemoveFromList = new ToolButton( bar, tr( "Remove from Playlist" ), "mpegplayer/remove_from_playlist",
+                                          this , SLOT(removeSelected()) );
+//    d->tbPlay    = new ToolButton( bar, tr( "Play" ), "mpegplayer/play", /*this */mediaPlayerState , SLOT(setPlaying(bool) /* btnPlay() */), TRUE );
+    d->tbPlay    = new ToolButton( bar, tr( "Play" ), "mpegplayer/play",
+                                   this , SLOT( btnPlay(bool) ), TRUE );
+    d->tbShuffle = new ToolButton( bar, tr( "Randomize" ),"mpegplayer/shuffle",
+                                   mediaPlayerState, SLOT(setShuffled(bool)), TRUE );
+    d->tbLoop    = new ToolButton( bar, tr( "Loop" ),"mpegplayer/loop",
+                                   mediaPlayerState, SLOT(setLooping(bool)), TRUE );
+    tbDeletePlaylist->hide();
 
     QPopupMenu *pmPlayList = new QPopupMenu( this );
     menu->insertItem( tr( "File" ), pmPlayList );
     new MenuItem( pmPlayList, tr( "Clear List" ),          this,             SLOT( clearList() ) );
     new MenuItem( pmPlayList, tr( "Add all audio files" ), this,             SLOT( addAllMusicToList() ) );
     new MenuItem( pmPlayList, tr( "Add all video files" ), this,             SLOT( addAllVideoToList() ) );
     new MenuItem( pmPlayList, tr( "Add all files" ),       this,             SLOT( addAllToList() ) );
     new MenuItem( pmPlayList, tr( "Save PlayList" ),       this,             SLOT( saveList() ) );
-    new MenuItem( pmPlayList, tr( "Load PlayList" ),       this,             SLOT( loadList() ) );
+      //   new MenuItem( pmPlayList, tr( "Load PlayList" ),       this,             SLOT( loadList() ) );
 
     QPopupMenu *pmView = new QPopupMenu( this );
     menu->insertItem( tr( "View" ), pmView );
 
     fullScreenButton = new QAction(tr("Full Screen"), Resource::loadPixmap("fullscreen"), QString::null, 0, this, 0);
     connect( fullScreenButton, SIGNAL(activated()), mediaPlayerState, SLOT(toggleFullscreen()) );
     fullScreenButton->addTo(pmView);
     scaleButton = new QAction(tr("Scale"), Resource::loadPixmap("mpegplayer/scale"), QString::null, 0, this, 0);
     connect( scaleButton, SIGNAL(activated()), mediaPlayerState, SLOT(toggleScaled()) );
     scaleButton->addTo(pmView);
 
     QVBox *vbox5 = new QVBox( this ); vbox5->setBackgroundMode( PaletteButton );
     QVBox *vbox4 = new QVBox( vbox5 ); vbox4->setBackgroundMode( PaletteButton );
 
     QHBox *hbox6 = new QHBox( vbox4 ); hbox6->setBackgroundMode( PaletteButton );
     
     tabWidget = new QTabWidget( hbox6, "tabWidget" ); 
     tabWidget->setTabShape(QTabWidget::Triangular);
-
+    
     QWidget *pTab;
     pTab = new QWidget( tabWidget, "pTab" );
     playlistView = new QListView( pTab, "Videoview" );
     playlistView->setMinimumSize(236,260);
     tabWidget->insertTab( pTab,"Playlist");
 
     // Add the playlist area
 
     QVBox *vbox3 = new QVBox( pTab ); vbox3->setBackgroundMode( PaletteButton );
     d->playListFrame = vbox3;
     d->playListFrame ->setMinimumSize(235,260);
 
     QHBox *hbox2 = new QHBox( vbox3 ); hbox2->setBackgroundMode( PaletteButton );
 
     d->selectedFiles = new PlayListSelection( hbox2);
     QVBox *vbox1 = new QVBox( hbox2 ); vbox1->setBackgroundMode( PaletteButton );
 
      QVBox *stretch1 = new QVBox( vbox1 ); stretch1->setBackgroundMode( PaletteButton ); // add stretch
      new ToolButton( vbox1, tr( "Move Up" ),   "mpegplayer/up",   d->selectedFiles, SLOT(moveSelectedUp()) );
      new ToolButton( vbox1, tr( "Remove" ),    "mpegplayer/cut",  d->selectedFiles, SLOT(removeSelected()) );
      new ToolButton( vbox1, tr( "Move Down" ), "mpegplayer/down", d->selectedFiles, SLOT(moveSelectedDown()) );
      QVBox *stretch2 = new QVBox( vbox1 ); stretch2->setBackgroundMode( PaletteButton ); // add stretch
 
     QWidget *aTab;
     aTab = new QWidget( tabWidget, "aTab" );
     audioView = new QListView( aTab, "Audioview" );
     audioView->setMinimumSize(233,260);
     audioView->addColumn( "Title",150);
     audioView->addColumn("Size", 45);
     audioView->addColumn("Media",35);
     audioView->setColumnAlignment(1, Qt::AlignRight);
     audioView->setColumnAlignment(2, Qt::AlignRight);
     tabWidget->insertTab(aTab,"Audio");
 //    audioView
      Global::findDocuments(&files, "audio/*");
      QListIterator<DocLnk> dit( files.children() );
      QString storage;
      for ( ; dit.current(); ++dit ) {
          QListViewItem * newItem;
          if(dit.current()->file().find("/mnt/cf") != -1 ) storage="CF";
          else if(dit.current()->file().find("/mnt/hda") != -1 ) storage="CF";
          else if(dit.current()->file().find("/mnt/card") != -1 ) storage="SD";
          else storage="RAM";
          if ( QFile( dit.current()->file()).exists() ) {
          newItem= /*(void)*/ new QListViewItem( audioView, dit.current()->name(), QString::number( QFile( dit.current()->file()).size() ), storage);
          newItem->setPixmap(0, Resource::loadPixmap( "mpegplayer/musicfile" ));
          }
      }
 // videowidget
      
     QWidget *vTab;
     vTab = new QWidget( tabWidget, "vTab" );
     videoView = new QListView( vTab, "Videoview" );
     videoView->setMinimumSize(233,260);
     
     videoView->addColumn("Title",150);
     videoView->addColumn("Size",45);
     videoView->addColumn("Media",35);
     videoView->setColumnAlignment(1, Qt::AlignRight);
     videoView->setColumnAlignment(2, Qt::AlignRight);
 
     tabWidget->insertTab( vTab,"Video");
 
     Global::findDocuments(&vFiles, "video/*");
     QListIterator<DocLnk> Vdit( vFiles.children() );
     for ( ; Vdit.current(); ++Vdit ) {
          if( Vdit.current()->file().find("/mnt/cf") != -1 ) storage="CF";
          else if( Vdit.current()->file().find("/mnt/hda") != -1 ) storage="CF";
          else if( Vdit.current()->file().find("/mnt/card") != -1 ) storage="SD";
          else storage="RAM";
         QListViewItem * newItem;
          if ( QFile( Vdit.current()->file()).exists() ) {
         newItem= /*(void)*/ new QListViewItem( videoView, Vdit.current()->name(), QString::number( QFile( Vdit.current()->file()).size() ), storage);
         newItem->setPixmap(0, Resource::loadPixmap( "mpegplayer/videofile" ));
          }
      }
-    // add the library area
-    QPEApplication::setStylusOperation( this, QPEApplication::RightOnHold );
 
-//      connect( audioView, SIGNAL( clicked( QListViewItem *) ), this, SLOT( playIt( QListViewItem *) ) );
-//      connect( videoView, SIGNAL( clicked( QListViewItem *) ), this, SLOT( playIt( QListViewItem *) ) );
+//playlists list
+    QWidget *LTab;
+    LTab = new QWidget( tabWidget, "LTab" );
+    playLists = new FileSelector( "playlist/plain", LTab, "fileselector" , FALSE, FALSE); //buggy
+    playLists->setMinimumSize(233,260);;
+    tabWidget->insertTab(LTab,"Lists");
+    connect( playLists, SIGNAL( fileSelected( const DocLnk &) ), this, SLOT( loadList( const DocLnk & ) ) );
+//      connect( playLists, SIGNAL( newSelected( const DocLnk &) ), this, SLOT( newFile( const DocLnk & ) ) );
 
-   connect( audioView, SIGNAL( clicked( QListViewItem *) ), this, SLOT( addToSelection( QListViewItem *) ) );
-   connect( videoView, SIGNAL( clicked( QListViewItem *) ), this, SLOT( addToSelection( QListViewItem *) ) );
 
-   connect( audioView, SIGNAL( rightButtonPressed( QListViewItem *, const QPoint&, int ) ),
-            this, SLOT( addToSelection( QListViewItem *, const QPoint&, int )) );
-   connect( videoView, SIGNAL( rightButtonPressed( QListViewItem *, const QPoint&, int ) ),
-            this, SLOT( addToSelection( QListViewItem *, const QPoint&, int )) );
+// add the library area
+   QPEApplication::setStylusOperation( this, QPEApplication::RightOnHold );
 
 
-   connect( tabWidget, SIGNAL (currentChanged(QWidget*)),this,SLOT(tabChanged(QWidget*)));
-  //   connect( d->files, SIGNAL( fileSelected( const DocLnk & ) ), this, SLOT( addToSelection( const DocLnk & ) ) );
-  //   connect( d->files, SIGNAL( fileSelected( const DocLnk & ) ), this, SLOT( addToSelection( const DocLnk & ) ) );
-    connect( mediaPlayerState, SIGNAL( playingToggled( bool ) ),    d->tbPlay,    SLOT( setOn( bool ) ) );
-    connect( mediaPlayerState, SIGNAL( loopingToggled( bool ) ),    d->tbLoop,    SLOT( setOn( bool ) ) );
-    connect( mediaPlayerState, SIGNAL( shuffledToggled( bool ) ),   d->tbShuffle, SLOT( setOn( bool ) ) );
+   connect( audioView, SIGNAL( rightButtonClicked( QListViewItem *, const QPoint &, int)),
+            this, SLOT( fauxPlay( QListViewItem *) ) );
+   connect( videoView, SIGNAL( rightButtonClicked( QListViewItem *, const QPoint &, int)),
+            this, SLOT( fauxPlay( QListViewItem *)) );
 
-//     connect( mediaPlayerState, SIGNAL( fullscreenToggled( bool ) ), fullScreenButton,    SLOT( setOn( bool ) ) );
-//      connect( mediaPlayerState, SIGNAL( scaledToggled( bool ) ),     scaleButton,   SLOT( setEnabled( bool ) ) );
-//      connect( mediaPlayerState, SIGNAL( fullscreenToggled( bool ) ), fullScreenButton,   SLOT( setEnabled( bool ) ) );
+//    connect( audioView, SIGNAL( clicked( QListViewItem *) ), this, SLOT( fauxPlay( QListViewItem *) ) );
+//    connect( videoView, SIGNAL( clicked( QListViewItem *) ), this, SLOT( fauxPlay( QListViewItem *) ) );
 
-    connect( mediaPlayerState, SIGNAL( playlistToggled( bool ) ),   this,         SLOT( setPlaylist( bool ) ) );
+   connect( audioView, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( addToSelection( QListViewItem *) ) );
+   connect( videoView, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( addToSelection( QListViewItem *) ) );
 
-   connect( d->selectedFiles, SIGNAL( clicked( QListViewItem *) ), this, SLOT( playIt( QListViewItem *) ) );
+   connect( tabWidget, SIGNAL (currentChanged(QWidget*)),this,SLOT(tabChanged(QWidget*)));
+   connect( mediaPlayerState, SIGNAL( playingToggled( bool ) ),    d->tbPlay,    SLOT( setOn( bool ) ) );
+   connect( mediaPlayerState, SIGNAL( loopingToggled( bool ) ),    d->tbLoop,    SLOT( setOn( bool ) ) );
+   connect( mediaPlayerState, SIGNAL( shuffledToggled( bool ) ),   d->tbShuffle, SLOT( setOn( bool ) ) );
+   connect( mediaPlayerState, SIGNAL( playlistToggled( bool ) ),   this,         SLOT( setPlaylist( bool ) ) );
+
+   connect( d->selectedFiles, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( playIt( QListViewItem *) ) );
 //   connect( d->selectedFiles, SIGNAL( fileSelected( const DocLnk & ) ), this, SLOT( addToSelection( const DocLnk & ) ) );
 
     setCentralWidget( vbox5 );
 
     Config cfg( "MediaPlayer" );
     readConfig( cfg );
 
     initializeStates();
 }
 
 
 PlayListWidget::~PlayListWidget() {
     Config cfg( "MediaPlayer" );
     writeConfig( cfg );
 
     if ( d->current )
   delete d->current;
     delete d;
 }
 
 
 void PlayListWidget::initializeStates() {
 
     d->tbPlay->setOn( mediaPlayerState->playing() );
     d->tbLoop->setOn( mediaPlayerState->looping() );
     d->tbShuffle->setOn( mediaPlayerState->shuffled() );
 //     d->tbFull->setOn( mediaPlayerState->fullscreen() );
 //     d->tbScale->setOn( mediaPlayerState->scaled() );
 //     d->tbScale->setEnabled( mediaPlayerState->fullscreen() );
 //    setPlaylist( mediaPlayerState->playlist() );
+        setPlaylist( true);
+        d->selectedFiles->first();
+
 }
 
 
 void PlayListWidget::readConfig( Config& cfg ) {
     cfg.setGroup("PlayList");
     
     int noOfFiles = cfg.readNumEntry("NumberOfFiles", 0 );
     
     for ( int i = 0; i < noOfFiles; i++ ) {
-  QString entryName;
-  entryName.sprintf( "File%i", i + 1 );
-  QString linkFile = cfg.readEntry( entryName );
-  DocLnk lnk( linkFile );
-  if ( lnk.isValid() )
+        QString entryName;
+        entryName.sprintf( "File%i", i + 1 );
+        QString linkFile = cfg.readEntry( entryName );
+        DocLnk lnk( linkFile );
+        if ( lnk.isValid() )
             d->selectedFiles->addToSelection( lnk );
-
     }
 }
 
 
 void PlayListWidget::writeConfig( Config& cfg ) const {
     cfg.setGroup("PlayList");
 
     int noOfFiles = 0;
 
     d->selectedFiles->first();
     do {
   const DocLnk *lnk = d->selectedFiles->current();
   if ( lnk ) {
       QString entryName;
       entryName.sprintf( "File%i", noOfFiles + 1 );
       cfg.writeEntry( entryName, lnk->linkFile() );
       // if this link does exist, add it so we have the file
       // next time...
       if ( !QFile::exists( lnk->linkFile() ) ) {
     // the way writing lnks doesn't really check for out
     // of disk space, but check it anyway.
     if ( !lnk->writeLink() ) {
         QMessageBox::critical( 0, tr("Out of space"),
              tr( "There was a problem saving "
                  "the playlist.\n"
                  "Your playlist "
                  "may be missing some entries\n"
                  "the next time you start it." )
              );
     }
       }      
-      noOfFiles++;
+       noOfFiles++;
   }
     } while ( d->selectedFiles->next() );
     
     cfg.writeEntry("NumberOfFiles", noOfFiles );
+
+   
 }
 
 
 void PlayListWidget::addToSelection( const DocLnk& lnk ) {
- d->setDocumentUsed = FALSE;
+    qDebug("add");
+    d->setDocumentUsed = FALSE;
     if ( mediaPlayerState->playlist() )
         d->selectedFiles->addToSelection( lnk );
     else
   mediaPlayerState->setPlaying( TRUE );
 }
 
 
-void PlayListWidget::addToSelection( QListViewItem *it ,const QPoint & p, int index) {
-    qDebug("add");
-//        d->selectedFiles->addToSelection( lnk );
- //    }
-//     else
-//   mediaPlayerState->setPlaying( TRUE );
-//
-}
-
-
 void PlayListWidget::clearList() {
     while ( first() )
   d->selectedFiles->removeSelected();
 }
 
 
 void PlayListWidget::addAllToList() {
     DocLnkSet files;
     Global::findDocuments(&files, "video/*;audio/*");
     QListIterator<DocLnk> dit( files.children() );
     for ( ; dit.current(); ++dit )
         d->selectedFiles->addToSelection( **dit );
 }
 
 
 void PlayListWidget::addAllMusicToList() {
     DocLnkSet files;
     Global::findDocuments(&files, "audio/*");
     QListIterator<DocLnk> dit( files.children() );
     for ( ; dit.current(); ++dit )
         d->selectedFiles->addToSelection( **dit );
 }
 
 
 void PlayListWidget::addAllVideoToList() {
     DocLnkSet files;
     Global::findDocuments(&files, "video/*");
     QListIterator<DocLnk> dit( files.children() );
     for ( ; dit.current(); ++dit )
         d->selectedFiles->addToSelection( **dit );
 }
 
 
 void PlayListWidget::setDocument(const QString& fileref) {
     if ( fileref.isNull() ) {
-  QMessageBox::critical( 0, tr( "Invalid File" ), tr( "There was a problem in getting the file." ) );
-  return;
+        QMessageBox::critical( 0, tr( "Invalid File" ), tr( "There was a problem in getting the file." ) );
+        return;
     }
     if ( mediaPlayerState->playlist() )
-  addToSelection( DocLnk( fileref ) );
+        addToSelection( DocLnk( fileref ) );
     else {
-  d->setDocumentUsed = TRUE;
-  if ( d->current )
-      delete d->current;
-  d->current = new DocLnk( fileref );
+        d->setDocumentUsed = TRUE;
+        if ( d->current )
+            delete d->current;
+        d->current = new DocLnk( fileref );
     }
     mediaPlayerState->setPlaying( FALSE );
     mediaPlayerState->setPlaying( TRUE );
 }
 
 
 void PlayListWidget::setActiveWindow() {
     // When we get raised we need to ensure that it switches views
     char origView = mediaPlayerState->view();
     mediaPlayerState->setView( 'l' ); // invalidate
     mediaPlayerState->setView( origView ); // now switch back
 }
 
 
 void PlayListWidget::useSelectedDocument() {
     d->setDocumentUsed = FALSE;
 }
 
 
 const DocLnk *PlayListWidget::current() {
-    if ( mediaPlayerState->playlist() )
-  return d->selectedFiles->current();
+
+//    qDebug("in Playlist  widget ::current");
+    if ( mediaPlayerState->playlist() ) {
+ return d->selectedFiles->current();
+    }
     else if ( d->setDocumentUsed && d->current ) {
-  return d->current;
-    } else
-  return d->files->selected();
+ return d->current;
+    } else {
+ return d->files->selected();
+    }
 }
 
 
 bool PlayListWidget::prev() {
     if ( mediaPlayerState->playlist() ) {
   if ( mediaPlayerState->shuffled() ) {
       const DocLnk *cur = current();
       int j = 1 + (int)(97.0 * rand() / (RAND_MAX + 1.0));
       for ( int i = 0; i < j; i++ ) {
     if ( !d->selectedFiles->next() )
         d->selectedFiles->first();
       }
       if ( cur == current() )
     if ( !d->selectedFiles->next() )
         d->selectedFiles->first();
       return TRUE;
   } else {
       if ( !d->selectedFiles->prev() ) {
     if ( mediaPlayerState->looping() ) {
         return d->selectedFiles->last();
     } else {
         return FALSE;
     }
       }
       return TRUE;
   }
     } else {
   return mediaPlayerState->looping();
     }
 }
 
 
 bool PlayListWidget::next() {
     if ( mediaPlayerState->playlist() ) {
   if ( mediaPlayerState->shuffled() ) {
       return prev();
   } else {
       if ( !d->selectedFiles->next() ) {
     if ( mediaPlayerState->looping() ) {
         return d->selectedFiles->first();
     } else {
         return FALSE;
     }
       }
       return TRUE;
   }
     } else {
   return mediaPlayerState->looping();
     }
 }
 
 
 bool PlayListWidget::first() {
     if ( mediaPlayerState->playlist() )
   return d->selectedFiles->first();
     else
   return mediaPlayerState->looping();
 }
 
 
 bool PlayListWidget::last() {
     if ( mediaPlayerState->playlist() )
   return d->selectedFiles->last();
     else
   return mediaPlayerState->looping();
 }
 
 
 void PlayListWidget::saveList() {
+
     QString filename;
-//  pseudo code
-//  filename = QLineEdit->getText();    
-    Config cfg( filename + ".playlist" );
-    writeConfig( cfg );
+    InputDialog *fileDlg;
+    fileDlg=new InputDialog(this,"Save Playlist",TRUE, 0);
+    fileDlg->exec();
+    if( fileDlg->result() == 1 ) {
+        filename = fileDlg->LineEdit1->text();//+".playlist";
+        qDebug("saving playlist "+filename+".playlist");
+
+//          DocLnk *lnk;
+//          lnk.setName( filename); //sets file name
+//  //        lnk.setComment(title);
+//          lnk.setFile( filename+".playlist"); //sets File property
+//          lnk.setType("player/plain");// hey is this a REGISTERED mime type?!?!? ;D
+//          lnk.setIcon("MPEGPlayer");
+//          if(!lnk.writeLink())
+//              qDebug("Writing doclink did not work");
+        
+        Config cfg( filename +".playlist");
+        writeConfig( cfg );
+    }
+    DocLnk lnk;
+    lnk.setName( filename); //sets file name
+//          lnk.setComment(title);
+    lnk.setFile(QPEApplication::qpeDir()+"Settings/"+filename+".playlist.conf"); //sets File property
+    lnk.setType("playlist/plain");// hey is this a REGISTERED mime type?!?!? ;D
+    lnk.setIcon("MPEGPlayer");
+    if(!lnk.writeLink())
+        qDebug("Writing doclink did not work");
+
+    if(fileDlg)
+        delete fileDlg;
 }
 
 
-void PlayListWidget::loadList() {
-    QString filename;
-//  pseudo code
-//  filename = FileSelector->openFile( "*.playlist" );
-    Config cfg( filename + ".playlist" );
-    readConfig( cfg );
+void PlayListWidget::loadList( const DocLnk & lnk) {
+
+    clearList();
+    Config cfg( lnk.file());
+    readConfig(cfg);
+    tabWidget->setCurrentPage(0);
+    setCaption("OpiePlayer: "+lnk.name());
 }
 
 
 void PlayListWidget::setPlaylist( bool shown ) {
     if ( shown ) 
   d->playListFrame->show();
     else
   d->playListFrame->hide();
 }
 
 
 void PlayListWidget::setView( char view ) {
     if ( view == 'l' )
   showMaximized();
     else
   hide();
 }
 
 void PlayListWidget::addSelected() {
-//    QMessageBox::message("Note","Bozo the clown thinks\nthere's something actually here");
-    int tabPage=tabWidget->currentPageIndex();
-      switch (tabPage) {
-        case 0: //playlist
+
+    switch (tabWidget->currentPageIndex()) {
+      case 0: //playlist
           break;
-        case 1: { //audio
-            addToSelection( audioView->selectedItem() );
-                }           
-            break;
-        case 2: { // video
-            addToSelection( videoView->selectedItem() );
-                }
-            break;
-      };
+      case 1: { //audio
+          addToSelection( audioView->selectedItem() );
+      }           
+          break;
+      case 2: { // video
+          addToSelection( videoView->selectedItem() );
+      }
+          break;
+    };
 }
 
 void PlayListWidget::removeSelected() {
     d->selectedFiles->removeSelected( );
 }
 
 
 void PlayListWidget::playIt( QListViewItem *it) {
 //   d->setDocumentUsed = FALSE;
-        mediaPlayerState->setPlaying(true);
+        mediaPlayerState->setPlaying(TRUE);
 }
 
 void PlayListWidget::addToSelection( QListViewItem *it) {
-   d->setDocumentUsed = FALSE;
+    d->setDocumentUsed = FALSE;
     
-   if(it) {
-    qDebug("add to selection");
-    int tabPage=tabWidget->currentPageIndex();
-    switch (tabPage) {
-      case 1: {
+    if(it) {
+//     qDebug("add to selection");
+        switch (tabWidget->currentPageIndex()) {
+          case 1: {
+//           qDebug("case 1");
+              QListIterator<DocLnk> dit( files.children() );
+              for ( ; dit.current(); ++dit ) {
+//               qDebug(dit.current()->name());
+                  if( dit.current()->name() == it->text(0)) {
+                      d->selectedFiles->addToSelection(  **dit );
+                  }
+              }
+          }
+              break;
+          case 2: {
+//           qDebug("case 2");
+              QListIterator<DocLnk> dit( vFiles.children() );
+              for ( ; dit.current(); ++dit ) {
+//               qDebug(dit.current()->name());
+                  if( dit.current()->name() == it->text(0)) {
+                      d->selectedFiles->addToSelection(  **dit );
+                  }
+              }
+          }
+              break;
+          case 0:
+              break;
+        };
+        tabWidget->setCurrentPage(0);
+//        mediaPlayerState->setPlaying( TRUE );
+    }
+}
+
+void PlayListWidget::tabChanged(QWidget *widg) {
+
+    switch ( tabWidget->currentPageIndex()) {
+      case 0:
+      {
+          if( !tbDeletePlaylist->isHidden())
+              tbDeletePlaylist->hide();
+          d->tbRemoveFromList->setEnabled(TRUE);
+          d->tbAddToList->setEnabled(FALSE);
+      }
+      break;
+      case 1:
+      {
+          if( !tbDeletePlaylist->isHidden())
+              tbDeletePlaylist->hide();
+          d->tbRemoveFromList->setEnabled(FALSE);
+          d->tbAddToList->setEnabled(TRUE);
+      }
+      break;
+      case 2:
+      {
+          if( !tbDeletePlaylist->isHidden())
+              tbDeletePlaylist->hide();
+          d->tbRemoveFromList->setEnabled(FALSE);
+          d->tbAddToList->setEnabled(TRUE);
+      }
+      break;
+      case 3:
+      {
+          if( tbDeletePlaylist->isHidden())
+              tbDeletePlaylist->show();
+          playLists->reread();
+      }
+      break;
+    };
+}
+
+/*
+  list is right clicked*/
+void PlayListWidget::fauxPlay(QListViewItem *it) {
+
+    switch (tabWidget->currentPageIndex()) {
+      case 0: //playlist
+          break;
+      case 1: { //audio
           QListIterator<DocLnk> dit( files.children() );
           for ( ; dit.current(); ++dit ) {
+//               qDebug(dit.current()->name());
               if( dit.current()->name() == it->text(0)) {
                   d->selectedFiles->addToSelection(  **dit );
               }
           }
-      }
+      }           
           break;
-      case 2: {
+      case 2: { // video
           QListIterator<DocLnk> dit( vFiles.children() );
           for ( ; dit.current(); ++dit ) {
-              qDebug(dit.current()->name());
+//               qDebug(dit.current()->name());
               if( dit.current()->name() == it->text(0)) {
                   d->selectedFiles->addToSelection(  **dit );
               }
           }
       }
           break;
-      case 0:
-        break;
     };
-    tabWidget->setCurrentPage(0);
-//        mediaPlayerState->setPlaying( TRUE );
-   }
+    mediaPlayerState->setPlaying( TRUE );
+//  tabWidget->setCurrentPage(0);
+    d->selectedFiles->removeSelected();
 }
 
-void PlayListWidget::tabChanged(QWidget *widg) {
-
-    int tabPage=tabWidget->currentPageIndex();
-      switch (tabPage) {
+/*
+  play button is pressed*/
+void PlayListWidget::btnPlay(bool b) { // this is fugly
+    switch ( tabWidget->currentPageIndex()) {
       case 0:
       {
-           d->tbRemoveFromList->setEnabled(TRUE);
-           d->tbAddToList->setEnabled(FALSE);
+          mediaPlayerState->setPlaying(b);
       }
-          break;
-        case 1:
-        {
-           d->tbRemoveFromList->setEnabled(FALSE);
-          d->tbAddToList->setEnabled(TRUE);
-        }
-            break;
-        case 2:
-        {
-          d->tbRemoveFromList->setEnabled(FALSE);
-          d->tbAddToList->setEnabled(TRUE);
-        }
-            break;
-      };
-}
-
-// void PlayListWidget::cancelMenuTimer() {
-//     if( menuTimer->isActive() )
-//     menuTimer->stop();
-// }
-
-// void PlayListWidget::showFileMenu() {
-
-// }
-
-// void PlayListWidget::contentsMousePressEvent( QMouseEvent * e )
-// {
-// //    QListView::contentsMousePressEvent( e );
-//     menuTimer->start( 750, TRUE );
-// }
+      break;
+      case 1:
+      {
+          addToSelection( audioView->selectedItem() );
+          mediaPlayerState->setPlaying(b);
+          d->selectedFiles->removeSelected( );
+          tabWidget->setCurrentPage(1);
+      }
+      break;
+      case 2:
+      {
+          addToSelection( videoView->selectedItem() );
+          mediaPlayerState->setPlaying(b);
+          d->selectedFiles->removeSelected( );
+          tabWidget->setCurrentPage(2);
+      }
+      break;
+    };
 
+}
 
-// void PlayListWidget::contentsMouseReleaseEvent( QMouseEvent * e )
-// {
-// //    QListView::contentsMouseReleaseEvent( e );
-//     menuTimer->stop();
-// }
-// // void PlayListWidget::setFullScreen() {
-//  mediaPlayerState->toggleFullscreen( );
-// }
+void PlayListWidget::deletePlaylist() {
+    switch( QMessageBox::information( this, (tr("Remove Playlist?")),
+                                      (tr("You really want to delete\nthis playlist?")),
+                                      (tr("Yes")), (tr("No")), 0 )){
+        case 0: // Yes clicked,
+            QFile().remove(playLists->selected()->file());
+            QFile().remove(playLists->selected()->linkFile());
+            playLists->reread();
+            break;
+        case 1: // Cancel
+            break;
+    };
 
-// void PlayListWidget::setScaled() {
-//  mediaPlayerState->toggleScaled();
-// }
+}
diff --git a/core/multimedia/opieplayer/playlistwidget.h b/core/multimedia/opieplayer/playlistwidget.h
index 5b05f11..46272a0 100644
--- a/core/multimedia/opieplayer/playlistwidget.h
+++ b/core/multimedia/opieplayer/playlistwidget.h
@@ -1,96 +1,102 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #ifndef PLAY_LIST_WIDGET_H
 #define PLAY_LIST_WIDGET_H
 
 #include <qmainwindow.h>
 #include <qpe/applnk.h>
 #include <qtabwidget.h>
+#include <fileselector.h>
+#include <qpushbutton.h>
+
 /* #include <qtimer.h> */
 
 
 class PlayListWidgetPrivate;
 class Config;
 class QListViewItem;
 class QListView;
 class QPoint;
 class QAction;
 class QLabel;
 
 class PlayListWidget : public QMainWindow {
     Q_OBJECT
 public:
     PlayListWidget( QWidget* parent=0, const char* name=0, WFlags fl=0 );
     ~PlayListWidget();
     QTabWidget * tabWidget;
   QAction *fullScreenButton, *scaleButton;
      DocLnkSet files;
      DocLnkSet vFiles;
      QListView *audioView, *videoView, *playlistView;
      QLabel *libString; 
     // retrieve the current playlist entry (media file link)
     const DocLnk *current();
     void useSelectedDocument();
 /*     QTimer    * menuTimer; */
-
+    FileSelector*  playLists;
+    QPushButton *tbDeletePlaylist;
 public slots:
     void setDocument( const QString& fileref );
     void addToSelection( const DocLnk& ); // Add a media file to the playlist
     void addToSelection( QListViewItem* ); // Add a media file to the playlist
-    void addToSelection( QListViewItem*, const QPoint&,int ); // Add a media file to the playlist
     void setActiveWindow(); // need to handle this to show the right view
     void setPlaylist( bool ); // Show/Hide the playlist
     void setView( char );
     void clearList(); 
     void addAllToList(); 
     void addAllMusicToList(); 
     void addAllVideoToList(); 
     void saveList();  // Save the playlist
-    void loadList();  // Load a playlist
+    void loadList( const DocLnk &);  // Load a playlist
     void playIt( QListViewItem *);
+    void fauxPlay(QListViewItem *);
+    void btnPlay(bool);
+    void deletePlaylist();
     bool first();
     bool last();
     bool next();
     bool prev();
     void addSelected();
     void removeSelected();
     void tabChanged(QWidget*);
 /*     void setFullScreen(); */
 /*     void setScaled(); */
 protected:
 /*     void contentsMousePressEvent( QMouseEvent * e ); */
 /*     void contentsMouseReleaseEvent( QMouseEvent * e ); */
 
 private:
     void initializeStates();
     void readConfig( Config& cfg );
     void writeConfig( Config& cfg ) const;
     PlayListWidgetPrivate *d; // Private implementation data
 
 protected slots:
 /*     void cancelMenuTimer(); */
 /*     void showFileMenu(); */
 
 
 };
 
 
 #endif // PLAY_LIST_WIDGET_H
 
diff --git a/core/multimedia/opieplayer/videowidget.cpp b/core/multimedia/opieplayer/videowidget.cpp
index 1f128a4..be838c4 100644
--- a/core/multimedia/opieplayer/videowidget.cpp
+++ b/core/multimedia/opieplayer/videowidget.cpp
@@ -1,277 +1,277 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #include <qpe/resource.h>
-#include "mediaplayerplugininterface.h"
+#include <qpe/mediaplayerplugininterface.h>
 #include <qwidget.h>
 #include <qpainter.h>
 #include <qpixmap.h>
 #include <qslider.h>
 #include <qdrawutil.h>
 #include "videowidget.h"
 #include "mediaplayerstate.h"
 
 
 #ifdef Q_WS_QWS
 # define USE_DIRECT_PAINTER
 # include <qdirectpainter_qws.h>
 # include <qgfxraster_qws.h>
 #endif
 
 
 extern MediaPlayerState *mediaPlayerState;
 
 
 static const int xo = 2; // movable x offset
 static const int yo = 0; // movable y offset
 
 
 struct MediaButton {
     int  xPos, yPos;
     bool isToggle, isHeld, isDown;
     int  controlType;
 };
 
 
 // Layout information for the videoButtons (and if it is a toggle button or not)
 MediaButton videoButtons[] = {
     { 5+0*32+xo, 200+yo, FALSE, FALSE, FALSE, 4 }, // previous
     { 5+1*32+xo, 200+yo, FALSE, FALSE, FALSE, 1 }, // stop
     { 5+2*32+xo, 200+yo,  TRUE, FALSE, FALSE, 0 }, // play
     { 5+3*32+xo, 200+yo,  TRUE, FALSE, FALSE, 2 }, // pause
     { 5+4*32+xo, 200+yo, FALSE, FALSE, FALSE, 3 }, // next
     { 5+5*32+xo, 200+yo, FALSE, FALSE, FALSE, 8 }, // playlist
     { 5+6*32+xo, 200+yo,  TRUE, FALSE, FALSE, 9 }  // fullscreen
 };
 
 
 static const int numButtons = (sizeof(videoButtons)/sizeof(MediaButton));
 
 
 VideoWidget::VideoWidget(QWidget* parent, const char* name, WFlags f) :
     QWidget( parent, name, f ), scaledWidth( 0 ), scaledHeight( 0 ) {
     setCaption( tr("OpiePlayer") );
     setBackgroundPixmap( Resource::loadPixmap( "mpegplayer/metalFinish" ) );
     pixmaps[0] = new QPixmap( Resource::loadPixmap( "mpegplayer/mediaButton0a" ) );
     pixmaps[1] = new QPixmap( Resource::loadPixmap( "mpegplayer/mediaButton0b" ) );
     pixmaps[2] = new QPixmap( Resource::loadPixmap( "mpegplayer/mediaControls0" ) );
     currentFrame = new QImage( 220 + 2, 160, (QPixmap::defaultDepth() == 16) ? 16 : 32 );
 
     slider = new QSlider( Qt::Horizontal, this );
     slider->setMinValue( 0 );
     slider->setMaxValue( 1 );
     slider->setBackgroundPixmap( Resource::loadPixmap( "mpegplayer/metalFinish" ) );
     slider->setFocusPolicy( QWidget::NoFocus );
     slider->setGeometry( QRect( 7, 250, 220, 20 ) );
 
     connect( slider,         SIGNAL( sliderPressed() ),      this, SLOT( sliderPressed() ) );
     connect( slider,         SIGNAL( sliderReleased() ),     this, SLOT( sliderReleased() ) );
 
     connect( mediaPlayerState, SIGNAL( lengthChanged(long) ),  this, SLOT( setLength(long) ) );
     connect( mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
     connect( mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
     connect( mediaPlayerState, SIGNAL( viewChanged(char) ),    this, SLOT( setView(char) ) );
     connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( setPaused(bool) ) );
     connect( mediaPlayerState, SIGNAL( playingToggled(bool) ), this, SLOT( setPlaying(bool) ) );
 
     // Intialise state
     setLength( mediaPlayerState->length() );
     setPosition( mediaPlayerState->position() );
     setFullscreen( mediaPlayerState->fullscreen() );
     setPaused( mediaPlayerState->paused() );
     setPlaying( mediaPlayerState->playing() );
 }
 
 
 VideoWidget::~VideoWidget() {
     for ( int i = 0; i < 3; i++ )
   delete pixmaps[i];
     delete currentFrame;
 }
 
 
 static bool videoSliderBeingMoved = FALSE;
 
 
 void VideoWidget::sliderPressed() {
     videoSliderBeingMoved = TRUE;
 }
 
 
 void VideoWidget::sliderReleased() {
     videoSliderBeingMoved = FALSE;
     if ( slider->width() == 0 )
   return;
     long val = long((double)slider->value() * mediaPlayerState->length() / slider->width());
     mediaPlayerState->setPosition( val );
 }
 
 
 void VideoWidget::setPosition( long i ) {
     updateSlider( i, mediaPlayerState->length() );
 }
 
 
 void VideoWidget::setLength( long max ) {
     updateSlider( mediaPlayerState->position(), max );
 }
 
 
 void VideoWidget::setView( char view ) {
     if ( view == 'v' ) {
   makeVisible();
     } else {
   // Effectively blank the view next time we show it so it looks nicer
   scaledWidth = 0;
   scaledHeight = 0;
   hide();
     }
 }
 
 
 void VideoWidget::updateSlider( long i, long max ) {
     // Will flicker too much if we don't do this
     if ( max == 0 )
   return;
     int width = slider->width();
     int val = int((double)i * width / max);
     if ( !mediaPlayerState->fullscreen() && !videoSliderBeingMoved ) {
   if ( slider->value() != val )
       slider->setValue( val );
   if ( slider->maxValue() != width )
       slider->setMaxValue( width );
     }
 }
 
 
 void VideoWidget::setToggleButton( int i, bool down ) {
     if ( down != videoButtons[i].isDown )
   toggleButton( i );
 }
 
 
 void VideoWidget::toggleButton( int i ) {
     videoButtons[i].isDown = !videoButtons[i].isDown;
     QPainter p(this);
     paintButton ( &p, i );
 }
 
 
 void VideoWidget::paintButton( QPainter *p, int i ) {
     int x = videoButtons[i].xPos;
     int y = videoButtons[i].yPos;
     int offset = 10 + videoButtons[i].isDown;
     p->drawPixmap( x, y, *pixmaps[videoButtons[i].isDown] );
     p->drawPixmap( x + 1 + offset, y + offset, *pixmaps[2], 9 * videoButtons[i].controlType, 0, 9, 9 );
 }
 
 
 void VideoWidget::mouseMoveEvent( QMouseEvent *event ) {
     for ( int i = 0; i < numButtons; i++ ) {
   int x = videoButtons[i].xPos;
   int y = videoButtons[i].yPos;
   if ( event->state() == QMouseEvent::LeftButton ) {
       // The test to see if the mouse click is inside the circular button or not
       // (compared with the radius squared to avoid a square-root of our distance)
       int radius = 16;
       QPoint center = QPoint( x + radius, y + radius );
       QPoint dXY = center - event->pos();
       int dist = dXY.x() * dXY.x() + dXY.y() * dXY.y();
       bool isOnButton = dist <= (radius * radius);
       if ( isOnButton != videoButtons[i].isHeld ) {
     videoButtons[i].isHeld = isOnButton;
     toggleButton(i);
       }
   } else {
       if ( videoButtons[i].isHeld ) {
     videoButtons[i].isHeld = FALSE;
     if ( !videoButtons[i].isToggle ) 
         setToggleButton( i, FALSE );
     switch (i) {
         case VideoPlay:       mediaPlayerState->setPlaying(videoButtons[i].isDown); return;
         case VideoStop:       mediaPlayerState->setPlaying(FALSE); return;
         case VideoPause:      mediaPlayerState->setPaused(videoButtons[i].isDown); return;
         case VideoNext:       mediaPlayerState->setNext(); return;
         case VideoPrevious:   mediaPlayerState->setPrev(); return;
         case VideoPlayList:   mediaPlayerState->setList(); return;
         case VideoFullscreen: mediaPlayerState->setFullscreen( TRUE ); makeVisible(); return;
     }
       }
   }
     }
 }
 
 
 void VideoWidget::mousePressEvent( QMouseEvent *event ) {
     mouseMoveEvent( event );
 }
 
 
 void VideoWidget::mouseReleaseEvent( QMouseEvent *event ) {
     if ( mediaPlayerState->fullscreen() ) {
   mediaPlayerState->setFullscreen( FALSE );
   makeVisible();
     } else { 
   mouseMoveEvent( event );
     }
 }
 
 
 void VideoWidget::makeVisible() {
     if ( mediaPlayerState->fullscreen() ) {
   setBackgroundMode( QWidget::NoBackground );
   showFullScreen();
   resize( qApp->desktop()->size() );
   slider->hide();
     } else {
   setBackgroundPixmap( Resource::loadPixmap( "mpegplayer/metalFinish" ) );
   showNormal();
   showMaximized();
   slider->show();
     }
 }
 
 
 void VideoWidget::paintEvent( QPaintEvent * ) {
     QPainter p( this );
 
     if ( mediaPlayerState->fullscreen() ) {
   // Clear the background 
   p.setBrush( QBrush( Qt::black ) );
   p.drawRect( rect() );
 
   // Draw the current frame
   //p.drawImage( ); // If using directpainter we won't have a copy except whats on the screen
     } else {
   // draw border
   qDrawShadePanel( &p, 4, 15, 230, 170, colorGroup(), TRUE, 5, NULL );
 
   // Clear the movie screen first
   p.setBrush( QBrush( Qt::black ) );
   p.drawRect( 9, 20, 220, 160 );
 
   // draw current frame (centrally positioned from scaling to maintain aspect ratio)
   p.drawImage( 9 + (220 - scaledWidth) / 2, 20 + (160 - scaledHeight) / 2, *currentFrame, 0, 0, scaledWidth, scaledHeight );
 
   // draw the buttons
   for ( int i = 0; i < numButtons; i++ )
       paintButton( &p, i );
 
   // draw the slider
   slider->repaint( TRUE );
diff --git a/core/multimedia/opieplayer/wavplugin/wavplugin.cpp b/core/multimedia/opieplayer/wavplugin/wavplugin.cpp
index 7ac63c0..4a0da16 100644
--- a/core/multimedia/opieplayer/wavplugin/wavplugin.cpp
+++ b/core/multimedia/opieplayer/wavplugin/wavplugin.cpp
@@ -1,340 +1,342 @@
 /**********************************************************************
 ** 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 changes Fri 02-15-2002
 
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <unistd.h>
 #include <qfile.h>
 #include "wavplugin.h"
 
 //#define debugMsg(a)     qDebug(a)
 #define debugMsg(a)
 
 
 struct RiffChunk {
     char id[4];
     Q_UINT32 size;
     char data[4];
 };
 
 
 struct ChunkData {
     Q_INT16 formatTag;
     Q_INT16 channels;
     Q_INT32 samplesPerSec;
     Q_INT32 avgBytesPerSec;
     Q_INT16 blockAlign;
     Q_INT16 wBitsPerSample;
 };
 
 
 const int sound_buffer_size = 512; // 4096; // you got to be kidding right?
 
 
 class WavPluginData {
 public:
     QFile *input;
 
     int wavedata_remaining;
     ChunkData chunkdata;
     RiffChunk chunk;
     uchar data[sound_buffer_size+32]; // +32 to handle badly aligned input data
     int out,max;
     int samples_due;
     int samples;
 
     WavPluginData() {
   max = out = sound_buffer_size;
   wavedata_remaining = 0;
   samples_due = 0;
   samples = -1;
     }
 
-    // expands out samples to the frequency of 44kHz
+    // expands out samples to the frequency of 44kHz //not any more
     bool add( short *output, long count, long& done, bool stereo )
     {
   done = 0;
     qApp->processEvents();
 
   if ( input == 0 ) {
       qDebug("no input");
       return FALSE;
   }
 
         while ( count ) {
             int l,r;
             if ( getSample(l, r) == FALSE ) {
                 qDebug("didn't get sample");
                 return FALSE;
             }
               samples_due += chunkdata.samplesPerSec;
+              printf("samples due %d\r", samples_due);
+              fflush(stdout);
              while ( count && (samples_due > chunkdata.samplesPerSec) ) {
                 *output++ = l;
                 if ( stereo )
                     *output++ = r;
                 samples_due -= chunkdata.samplesPerSec;
                 count--;
                 done++;
             }
         }
         return TRUE;
     }
 
     bool initialise() {
   if ( input == 0 )
       return FALSE;
 
   wavedata_remaining = -1;
 
   while ( wavedata_remaining == -1 ) {
       // Keep reading chunks...
       const int n = sizeof(chunk) - sizeof(chunk.data);
       int t = input->readBlock( (char*)&chunk, n );
       if ( t != n ) {
     if ( t == -1 )
         return FALSE;
     return TRUE;
       }
       if ( qstrncmp(chunk.id,"data",4) == 0 ) {
     samples = wavedata_remaining = chunk.size;
       } else if ( qstrncmp(chunk.id,"RIFF",4) == 0 ) {
     char d[4];
     if ( input->readBlock(d,4) != 4 ) {
         return FALSE;
     }
     if ( qstrncmp(d,"WAVE",4) != 0 ) {
         // skip
         if ( chunk.size > 1000000000 || !input->at(input->at()+chunk.size-4) ) {
       return FALSE;
         }
     }
       } else if ( qstrncmp(chunk.id,"fmt ",4) == 0 ) {
     if ( input->readBlock((char*)&chunkdata,sizeof(chunkdata)) != sizeof(chunkdata) ) {
         return FALSE;
     }
 #define WAVE_FORMAT_PCM 1
     if ( chunkdata.formatTag != WAVE_FORMAT_PCM ) {
         qDebug("WAV file: UNSUPPORTED FORMAT %d",chunkdata.formatTag);
         return FALSE;
     }
       } else {
     // ignored chunk
     if ( chunk.size > 1000000000 || !input->at(input->at()+chunk.size) ) {
         return FALSE;
     }
       }
   } // while
   qDebug("bits %d", chunkdata.wBitsPerSample);
   return TRUE;
     }
 
 
     // gets a sample from the file
     bool getSample(int& l, int& r)
     {
   l = r = 0;
 
   if ( input == 0 )
       return FALSE;
 
   if ( (wavedata_remaining < 0) || !max )
       return FALSE;
 
   if ( out >= max ) {
       max = input->readBlock( (char*)data, (uint)QMIN(sound_buffer_size,wavedata_remaining) );
 
       wavedata_remaining -= max;
 
       out = 0;
       if ( max <= 0 ) {
     max = 0;
     return TRUE;
       }
   }
   if ( chunkdata.wBitsPerSample == 8 ) {
       l = (data[out++] - 128) * 128;
   } else {
       l = ((short*)data)[out/2];
       out += 2;
   }
   if ( chunkdata.channels == 1 ) {
       r = l;
   } else {
       if ( chunkdata.wBitsPerSample == 8 ) {
     r = (data[out++] - 128) * 128;
       } else {
     r = ((short*)data)[out/2];
     out += 2;
       }
   }
   return TRUE;
     } // getSample
 
 };
 
 
 WavPlugin::WavPlugin() {
     d = new WavPluginData;
     d->input = 0;
 }
 
 
 WavPlugin::~WavPlugin() {
     close();
     delete d;
 }
 
 
 bool WavPlugin::isFileSupported( const QString& path ) {
 //    qDebug( "WavPlugin::isFileSupported" );
 
     char *ext = strrchr( path.latin1(), '.' );
 
     // Test file extension
     if ( ext ) {
   if ( strncasecmp(ext, ".raw", 4) == 0 )
       return TRUE;
   if ( strncasecmp(ext, ".wav", 4) == 0 )
       return TRUE;
   if ( strncasecmp(ext, ".wave", 4) == 0 )
       return TRUE;
     }
 
     return FALSE;
 }
 
 
 bool WavPlugin::open( const QString& path ) {
 //    qDebug( "WavPlugin::open" );
 
     d->max = d->out = sound_buffer_size;
     d->wavedata_remaining = 0;
     d->samples_due = 0;
 
     d->input = new QFile( path );
     if ( d->input->open(IO_ReadOnly) == FALSE ) {
   qDebug("couldn't open file");
   delete d->input;
   d->input = 0;
   return FALSE;
     }
 
     d->initialise();
 
     return TRUE;
 }
 
 
 bool WavPlugin::close() {
 //    qDebug( "WavPlugin::close" );
 
     d->input->close();
     delete d->input;
     d->input = 0;
     return TRUE;
 }
 
 
 bool WavPlugin::isOpen() {
 //    qDebug( "WavPlugin::isOpen" );
     return ( d->input != 0 );
 }
 
 
 int WavPlugin::audioStreams() {
 //    qDebug( "WavPlugin::audioStreams" );
     return 1;
 }
 
 
 int WavPlugin::audioChannels( int ) {
 //    qDebug( "WavPlugin::audioChannels" );
     return d->chunkdata.channels;// 2; // ### Always scale audio to stereo samples
 }
 
 
 int WavPlugin::audioFrequency( int ) {
 //    qDebug( "WavPlugin::audioFrequency %d", d->chunkdata.samplesPerSec );
     return  d->chunkdata.samplesPerSec; //44100; // ### Always scale to frequency of 44100
 }
 
 
 int WavPlugin::audioSamples( int ) {
 //    qDebug( "WavPlugin::audioSamples" );
     return d->samples / d->chunkdata.channels/2; // ### Scaled samples will be made stereo,
         // Therefore if source is mono we will double the number of samples
 }
 
 
 bool WavPlugin::audioSetSample( long, int ) {
 //    qDebug( "WavPlugin::audioSetSample" );
     return FALSE;
 }
 
 
 long WavPlugin::audioGetSample( int ) {
 //    qDebug( "WavPlugin::audioGetSample" );
     return 0;
 }
 
 /*
 bool WavPlugin::audioReadSamples( short *, int, long, int ) {
     debugMsg( "WavPlugin::audioReadSamples" );
     return FALSE;
 }
 
 
 bool WavPlugin::audioReReadSamples( short *, int, long, int ) {
     debugMsg( "WavPlugin::audioReReadSamples" );
     return FALSE;
 }
 
 
 bool WavPlugin::audioReadMonoSamples( short *output, long samples, long& samplesMade, int ) {
     debugMsg( "WavPlugin::audioReadMonoSamples" );
     return !d->add( output, samples, samplesMade, FALSE );
 }
 
 
 bool WavPlugin::audioReadStereoSamples( short *output, long samples, long& samplesMade, int ) {
     debugMsg( "WavPlugin::audioReadStereoSamples" );
     return !d->add( output, samples, samplesMade, TRUE );
 }
 */
 
 bool WavPlugin::audioReadSamples( short *output, int channels, long samples, long& samplesMade, int ) {
 //    qDebug( "WavPlugin::audioReadSamples" );
     return d->add( output, samples, samplesMade, channels != 1 );
 }
 
 double WavPlugin::getTime() {
-//    qDebug( "WavPlugin::getTime" );
-    return 0.0;
+//    qDebug( "WavPlugin::getTime" ); //this is a stupid hack here!!
+  return d->chunkdata.wBitsPerSample; /*0.0*/;
 }
 
-int WavPlugin::audioBitsPerSample( int ) {
-//    qDebug( "WavPlugin::audioFormat %d", d->chunkdata.wBitsPerSample );
-    return d->chunkdata.wBitsPerSample; // 
-}
+// int WavPlugin::audioBitsPerSample( int ) {
+// //    qDebug( "WavPlugin::audioFormat %d", d->chunkdata.wBitsPerSample );
+//     return d->chunkdata.wBitsPerSample; // 
+// }
 
 
diff --git a/core/multimedia/opieplayer/wavplugin/wavplugin.h b/core/multimedia/opieplayer/wavplugin/wavplugin.h
index 6ae6e06..1c8ba14 100644
--- a/core/multimedia/opieplayer/wavplugin/wavplugin.h
+++ b/core/multimedia/opieplayer/wavplugin/wavplugin.h
@@ -1,106 +1,107 @@
 /**********************************************************************
 ** 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 changes Fri 02-15-2002
 
 #ifndef WAV_PLUGIN_H 
 #define WAV_PLUGIN_H
 
 #include <qstring.h>
 #include <qapplication.h>
-#include "../mediaplayerplugininterface.h"
+/* #include "../mediaplayerplugininterface.h" */
+#include <qpe/mediaplayerplugininterface.h>
 
 
 // #define OLD_MEDIAPLAYER_API
 
 
 class WavPluginData;
 
 
 class WavPlugin : public MediaPlayerDecoder {
 
 public:
     WavPlugin();
     ~WavPlugin();
 
     const char *pluginName() { return "WavPlugin"; }
     const char *pluginComment() { return "This is a simple plugin for playing wav files"; }
     double pluginVersion() { return 1.0; }
 
     bool isFileSupported( const QString& );
     bool open( const QString& );
     bool close();
     bool isOpen();
     const QString &fileInfo() { return strInfo = ""; }
 
     // If decoder doesn't support audio then return 0 here
     int audioStreams();
     int audioChannels( int stream ); 
     int audioFrequency( int stream );
-    int audioBitsPerSample( int stream );
+/*     int audioBitsPerSample( int stream ); */
     int audioSamples( int stream );
     bool audioSetSample( long sample, int stream );
     long audioGetSample( int stream );
 #ifdef OLD_MEDIAPLAYER_API
     bool audioReadMonoSamples( short *output, long samples, long& samplesRead, int stream );
     bool audioReadStereoSamples( short *output, long samples, long& samplesRead, int stream );
     bool audioReadSamples( short *output, int channel, long samples, int stream );
     bool audioReReadSamples( short *output, int channel, long samples, int stream );
 #else
     bool audioReadSamples( short *output, int channels, long samples, long& samplesRead, int stream );
 #endif
 
     // If decoder doesn't support video then return 0 here
     int videoStreams() { return 0; }
     int videoWidth( int ) { return 0; }
     int videoHeight( int ) { return 0; }
     double videoFrameRate( int ) { return 0.0; }
     int videoFrames( int ) { return 0; }
     bool videoSetFrame( long, int ) { return FALSE; }
     long videoGetFrame( int ) { return 0; }
     bool videoReadFrame( unsigned char **, int, int, int, int, ColorFormat, int ) { return FALSE; }
     bool videoReadScaledFrame( unsigned char **, int, int, int, int, int, int, ColorFormat, int ) { return FALSE; }
     bool videoReadYUVFrame( char *, char *, char *, int, int, int, int, int ) { return FALSE; }
 
     // Profiling
     double getTime();
 
     // Ignore if these aren't supported
     bool setSMP( int ) { return FALSE; }
     bool setMMX( bool ) { return FALSE; }
 
     // Capabilities
     bool supportsAudio() { return TRUE; }
     bool supportsVideo() { return FALSE; }
     bool supportsYUV() { return FALSE; }
     bool supportsMMX() { return TRUE; }
     bool supportsSMP() { return FALSE; }
     bool supportsStereo() { return TRUE; }
     bool supportsScaling() { return FALSE; }
 
     long getPlayTime() { return -1; }
 
 private:
     WavPluginData *d;
     QString strInfo;
 
 };
 
 
 #endif
diff --git a/core/multimedia/opieplayer/wavplugin/wavpluginimpl.cpp b/core/multimedia/opieplayer/wavplugin/wavpluginimpl.cpp
index 2923180..c232d7b 100644
--- a/core/multimedia/opieplayer/wavplugin/wavpluginimpl.cpp
+++ b/core/multimedia/opieplayer/wavplugin/wavpluginimpl.cpp
@@ -1,69 +1,69 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #include "wavplugin.h"
 #include "wavpluginimpl.h"
 
 WavPluginImpl::WavPluginImpl()
     : libmadplugin(0), ref(0)
 {
 }
 
 
 WavPluginImpl::~WavPluginImpl()
 {
     if ( libmadplugin )
-        delete libmadplugin;
+  delete libmadplugin;
 }
 
 
 MediaPlayerDecoder *WavPluginImpl::decoder()
 {
     if ( !libmadplugin )
-        libmadplugin = new WavPlugin;
+  libmadplugin = new WavPlugin;
     return libmadplugin;
 }
 
 
 MediaPlayerEncoder *WavPluginImpl::encoder()
 {
     return NULL;
 }
 
 
 #ifndef QT_NO_COMPONENT
 
 
 QRESULT WavPluginImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
-    if ( ( uuid == IID_QUnknown ) || ( uuid == IID_MediaPlayerPlugin ) )
-        *iface = this, (*iface)->addRef();
+    if ( ( uuid == IID_QUnknown ) || ( uuid == IID_MediaPlayerPlugin )  )
+  *iface = this, (*iface)->addRef();
     return QS_OK;
 }
 
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( WavPluginImpl )
 }
 
 
 #endif
 
diff --git a/core/multimedia/opieplayer/wavplugin/wavpluginimpl.h b/core/multimedia/opieplayer/wavplugin/wavpluginimpl.h
index 10f9305..fb1fa73 100644
--- a/core/multimedia/opieplayer/wavplugin/wavpluginimpl.h
+++ b/core/multimedia/opieplayer/wavplugin/wavpluginimpl.h
@@ -1,52 +1,53 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 #ifndef WAV_PLUGIN_IMPL_H 
 #define WAV_PLUGIN_IMPL_H
 
-#include "../mediaplayerplugininterface.h"
+
+/* #include "../mediaplayerplugininterface.h" */
 
 
 class WavPlugin;
 
 
 class WavPluginImpl : public MediaPlayerPluginInterface
 {
 public:
     WavPluginImpl();
     virtual ~WavPluginImpl();
 
 #ifndef QT_NO_COMPONENT
 
     QRESULT queryInterface( const QUuid&, QUnknownInterface** );
     Q_REFCOUNT
 
 #endif
 
     virtual MediaPlayerDecoder *decoder();
     virtual MediaPlayerEncoder *encoder();
 
 private:
     WavPlugin *libmadplugin;
     ulong ref;
 };
 
 
 #endif