fixes for goofy crap going on

6 files changed, 120 insertions, 110 deletions

diff --git a/core/multimedia/opieplayer/audiodevice.cpp b/core/multimedia/opieplayer/audiodevice.cpp
index 3262e38..4c5f12d 100644
--- a/core/multimedia/opieplayer/audiodevice.cpp
+++ b/core/multimedia/opieplayer/audiodevice.cpp
@@ -1,378 +1,378 @@
 /**********************************************************************
 ** 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
-
+// #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(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
+//#endif
 
 
 class AudioDevicePrivate {
 public:
     int handle;
     unsigned int frequency;
     unsigned int channels;
     unsigned int bytesPerSample;
     unsigned int bufferSize;
-#ifndef Q_OS_WIN32
+//#ifndef Q_OS_WIN32
     bool can_GETOSPACE;
     char* unwrittenBuffer;
     unsigned int unwritten;
-#endif
+//#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
+// #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
+//#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
+// #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
+//#endif
 //    qDebug( "setting volume to: 0x%x", volume ); 
 #if ( defined Q_WS_QWS || defined(_WS_QWS_) ) && !defined(QT_NO_COP)
     // Send notification that the volume has changed
     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << muted; 
 #endif
 }
 
 
 
 
 AudioDevice::AudioDevice( unsigned int f, unsigned int chs, unsigned int bps ) {
   qDebug("creating new audio device");
     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << TRUE; 
   d = new AudioDevicePrivate;
     d->frequency = f;
     d->channels = chs;
     d->bytesPerSample = bps;
     qDebug("%d",bps);
     int format=0;
     if( bps == 8)  format  = AFMT_U8;
     else if( bps <= 0) format = AFMT_S16_LE;
     else format = AFMT_S16_LE;
     qDebug("AD- freq %d, channels %d, b/sample %d, bitrate %d",f,chs,bps,format);
     connect( qApp, SIGNAL( volumeChanged(bool) ), this, SLOT( volumeChanged(bool) ) );
 
     int fragments = 0x10000 * 8 + sound_fragment_shift;
     int capabilities = 0;
 
     
 #ifdef KEEP_DEVICE_OPEN
     if ( AudioDevicePrivate::dspFd == 0 ) {
 #endif
     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" );
     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << FALSE; 
     
 }
     
 
 AudioDevice::~AudioDevice() {
     qDebug("destryo audiodevice");
     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << TRUE; 
     
-#ifdef Q_OS_WIN32
-    waveOutClose( (HWAVEOUT)d->handle );
-#else
+// #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
+//#endif
+    QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << FALSE;
     
 }
 
 
 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
+// #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
+//#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
+// #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
+//#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
+// #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
+//#endif
 }
 
diff --git a/core/multimedia/opieplayer/audiowidget.cpp b/core/multimedia/opieplayer/audiowidget.cpp
index ac8c935..54e7ceb 100644
--- a/core/multimedia/opieplayer/audiowidget.cpp
+++ b/core/multimedia/opieplayer/audiowidget.cpp
@@ -98,107 +98,107 @@ AudioWidget::AudioWidget(QWidget* parent, const char* name, WFlags f) :
     slider->setFocusPolicy( QWidget::NoFocus );
     slider->setGeometry( QRect( 7, 262, 220, 20 ) );
       //  layout->addMultiCellWidget( slider, 4, 4, 0, 2 );
 
     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( viewChanged(char) ),    this, SLOT( setView(char) ) );
     connect( mediaPlayerState, SIGNAL( loopingToggled(bool) ), this, SLOT( setLooping(bool) ) );
     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() );
     setLooping( mediaPlayerState->fullscreen() );
     setPaused( mediaPlayerState->paused() );
     setPlaying( mediaPlayerState->playing() );
         
 }
 
 
 AudioWidget::~AudioWidget() {
     mediaPlayerState->isStreaming = FALSE;
     for ( int i = 0; i < 4; i++ )
   delete pixmaps[i];
 }
 
 
 static bool audioSliderBeingMoved = FALSE;
 
 
 void AudioWidget::sliderPressed() {
     audioSliderBeingMoved = TRUE;
 }
 
 
 void AudioWidget::sliderReleased() {
     audioSliderBeingMoved = FALSE;
     if ( slider->width() == 0 )
   return;
     long val = long((double)slider->value() * mediaPlayerState->length() / slider->width());
     mediaPlayerState->setPosition( val );
 }
 
 
 void AudioWidget::setPosition( long i ) {
+//    qDebug("set position %d",i);
     updateSlider( i, mediaPlayerState->length() );
 }
 
 
 void AudioWidget::setLength( long max ) {
     updateSlider( mediaPlayerState->position(), max );
 }
 
 
 void AudioWidget::setView( char view ) {
-
     if (mediaPlayerState->isStreaming) {
         if( !slider->isHidden()) slider->hide();
         disconnect( mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
         disconnect( mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
     } else {
 // this stops the slider from being moved, thus
           // does not stop stream when it reaches the end
  slider->show();
         connect( mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
         connect( mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
     }
 
     if ( view == 'a' ) {
         startTimer( 150 );
 //        show();
         showMaximized();
     } else {
         killTimers();
         hide();
     }
 }
 
 
 void AudioWidget::updateSlider( long i, long max ) {
     if ( max == 0 )
   return;
     // Will flicker too much if we don't do this
     // Scale to something reasonable
     int width = slider->width();
     int val = int((double)i * width / max);
     if ( !audioSliderBeingMoved ) {
   if ( slider->value() != val )
       slider->setValue( val );
   if ( slider->maxValue() != width )
       slider->setMaxValue( width );
     }
 }
 
 
 void AudioWidget::setToggleButton( int i, bool down ) {
     if ( down != audioButtons[i].isDown )
   toggleButton( i );
 }
 
 
 void AudioWidget::toggleButton( int i ) {
     audioButtons[i].isDown = !audioButtons[i].isDown;
     QPainter p(this);
diff --git a/core/multimedia/opieplayer/loopcontrol.cpp b/core/multimedia/opieplayer/loopcontrol.cpp
index 3171c4b..70e4a78 100644
--- a/core/multimedia/opieplayer/loopcontrol.cpp
+++ b/core/multimedia/opieplayer/loopcontrol.cpp
@@ -108,188 +108,187 @@ LoopControl::LoopControl( QObject *parent, const char *name )
 #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();
-
+//    qDebug("Loop control %d", pos);
     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;
 
 // this causes drop outs not sure why its even here
-          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 );
 
       if(  mediaPlayerState->isStreaming == FALSE)
       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;
@@ -300,104 +299,105 @@ void LoopControl::startTimers() {
 
     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();
-
     }
+    audioSampleCounter=0;
+    current_frame=0;
+    total_audio_samples=0; 
 }
 
 
 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;
 
     if ( mediaPlayerState->curDecoder()->pluginName() == QString("LibMpeg3Plugin") )
         channels = 2; //dont akx me why, but it needs this hack
     else
         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;
    if ( mediaPlayerState->curDecoder()->pluginName() == QString("LibWavPlugin") ) {
        bits_per_sample =(int) mediaPlayerState->curDecoder()->getTime();
@@ -405,77 +405,79 @@ bool LoopControl::init( const QString& filename ) {
    } 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");
+    mediaPlayerState->setPosition( 0); //uglyhack
+    
 #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/mediaplayer.cpp b/core/multimedia/opieplayer/mediaplayer.cpp
index b9e438b..64fdc01 100644
--- a/core/multimedia/opieplayer/mediaplayer.cpp
+++ b/core/multimedia/opieplayer/mediaplayer.cpp
@@ -17,96 +17,97 @@
 ** 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 ) {
 
 //    QPEApplication::grabKeyboard();
     connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
 
     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( 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 );
 }
 
 
 void MediaPlayer::play() {
     mediaPlayerState->setPlaying( FALSE );
     mediaPlayerState->setPlaying( TRUE );
 }
 
 
 void MediaPlayer::setPlaying( bool play ) {
     if ( !play ) {
   mediaPlayerState->setPaused( FALSE );
   loopControl->stop( FALSE );
   return;
     }
 
     if ( mediaPlayerState->paused() ) {
   mediaPlayerState->setPaused( FALSE );
   return;
     }
 
     const DocLnk *playListCurrent = playList->current();
     if ( playListCurrent != NULL ) {
   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;
     }
 
     if ( ((currentFile->file()).left(4) != "http") && !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;
     }
 
     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 );
diff --git a/core/multimedia/opieplayer/mediaplayerstate.cpp b/core/multimedia/opieplayer/mediaplayerstate.cpp
index 3ac9ac4..cf166d6 100644
--- a/core/multimedia/opieplayer/mediaplayerstate.cpp
+++ b/core/multimedia/opieplayer/mediaplayerstate.cpp
diff --git a/core/multimedia/opieplayer/playlistwidget.cpp b/core/multimedia/opieplayer/playlistwidget.cpp
index 200ec16..35208e4 100644
--- a/core/multimedia/opieplayer/playlistwidget.cpp
+++ b/core/multimedia/opieplayer/playlistwidget.cpp
@@ -112,248 +112,252 @@ public:
 };
 
 
 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;
     fromSetDocument = FALSE;
     insanityBool=FALSE;
     audioScan = FALSE;
     videoScan = FALSE;
 //    menuTimer = new QTimer( this ,"menu timer"),
 //     connect( menuTimer, SIGNAL( timeout() ), SLOT( addSelected() ) );
 
     setBackgroundMode( PaletteButton );
 
     setCaption( tr("OpiePlayer") );
     setIcon( Resource::loadPixmap( "opieplayer/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->tbPlayCurList =  new ToolButton( bar, tr( "play List" ), "opieplayer/play_current_list",
 //                                        this , SLOT( addSelected()) );
     tbDeletePlaylist = new QPushButton( Resource::loadIconSet("trash"),"",bar,"close");
     tbDeletePlaylist->setFlat(TRUE);
     tbDeletePlaylist->setFixedSize(20,20);
-    connect(tbDeletePlaylist,(SIGNAL(released())),SLOT( deletePlaylist()));
     
     d->tbAddToList =  new ToolButton( bar, tr( "Add to Playlist" ), "opieplayer/add_to_playlist",
                                       this , SLOT(addSelected()) );
     d->tbRemoveFromList = new ToolButton( bar, tr( "Remove from Playlist" ), "opieplayer/remove_from_playlist",
                                           this , SLOT(removeSelected()) );
 //    d->tbPlay    = new ToolButton( bar, tr( "Play" ), "opieplayer/play", /*this */mediaPlayerState , SLOT(setPlaying(bool) /* btnPlay() */), TRUE );
     d->tbPlay    = new ToolButton( bar, tr( "Play" ), "opieplayer/play",
                                    this , SLOT( btnPlay(bool) ), TRUE );
     d->tbShuffle = new ToolButton( bar, tr( "Randomize" ),"opieplayer/shuffle",
                                    mediaPlayerState, SLOT(setShuffled(bool)), TRUE );
     d->tbLoop    = new ToolButton( bar, tr( "Loop" ),"opieplayer/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() ) );
 //     pmPlayList->insertSeparator(-1);
     new MenuItem( pmPlayList, tr( "Save PlayList" ), this, SLOT( saveList() ) );
     pmPlayList->insertSeparator(-1);
     new MenuItem( pmPlayList, tr( "Open File or URL" ), this,SLOT( openFile() ) );
     pmPlayList->insertSeparator(-1);
     new MenuItem( pmPlayList, tr( "Rescan for Audio Files" ), this,SLOT( scanForAudio() ) );
     new MenuItem( pmPlayList, tr( "Rescan for Video Files" ), this,SLOT( scanForVideo() ) );
 
     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("opieplayer/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, "playlistview" );
 //    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 );
 
     QPEApplication::setStylusOperation( d->selectedFiles->viewport(),QPEApplication::RightOnHold);
 
-    connect( d->selectedFiles, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
-                   this,SLOT( playlistViewPressed(int, QListViewItem *, const QPoint&, int)) );
 
           
      QVBox *stretch1 = new QVBox( vbox1 ); stretch1->setBackgroundMode( PaletteButton ); // add stretch
      new ToolButton( vbox1, tr( "Move Up" ),   "opieplayer/up",   d->selectedFiles, SLOT(moveSelectedUp()) );
      new ToolButton( vbox1, tr( "Remove" ),    "opieplayer/cut",  d->selectedFiles, SLOT(removeSelected()) );
      new ToolButton( vbox1, tr( "Move Down" ), "opieplayer/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( tr("Title"),140);
     audioView->addColumn(tr("Size"), -1);
     audioView->addColumn(tr("Media"),-1);
     audioView->setColumnAlignment(1, Qt::AlignRight);
     audioView->setColumnAlignment(2, Qt::AlignRight);
     audioView->setAllColumnsShowFocus(TRUE);
 
     audioView->setMultiSelection( TRUE );
     audioView->setSelectionMode( QListView::Extended);
     
     tabWidget->insertTab(aTab,tr("Audio"));
 
     QPEApplication::setStylusOperation( audioView->viewport(),QPEApplication::RightOnHold);
-    connect( audioView, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
-             this,SLOT( viewPressed(int, QListViewItem *, const QPoint&, int)) );
-    
-    connect( audioView, SIGNAL( returnPressed( QListViewItem *)),
-             this,SLOT( playIt( QListViewItem *)) );
 
 //    audioView
 //     populateAudioView();
 // videowidget
      
     QWidget *vTab;
     vTab = new QWidget( tabWidget, "vTab" );
     videoView = new QListView( vTab, "Videoview" );
     videoView->setMinimumSize(233,260);
     
     videoView->addColumn(tr("Title"),140);
     videoView->addColumn(tr("Size"),-1);
     videoView->addColumn(tr("Media"),-1);
     videoView->setColumnAlignment(1, Qt::AlignRight);
     videoView->setColumnAlignment(2, Qt::AlignRight);
     videoView->setAllColumnsShowFocus(TRUE);
     videoView->setMultiSelection( TRUE );
     videoView->setSelectionMode( QListView::Extended);
 
     QPEApplication::setStylusOperation( videoView->viewport(),QPEApplication::RightOnHold);
 
-    connect( videoView, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
-             this,SLOT( viewPressed(int, QListViewItem *, const QPoint&, int)) );
-    connect( videoView, SIGNAL( returnPressed( QListViewItem *)),
-             this,SLOT( playIt( QListViewItem *)) );
-
     tabWidget->insertTab( vTab,tr("Video"));
 //  populateVideoView();
 
 //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,tr("Lists"));
 
-    connect( playLists, SIGNAL( fileSelected( const DocLnk &) ), this, SLOT( loadList( const DocLnk & ) ) );
 //      connect( playLists, SIGNAL( newSelected( const DocLnk &) ), this, SLOT( newFile( const DocLnk & ) ) );
 
 // add the library area
 
 //     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( audioView, SIGNAL( clicked( QListViewItem *) ), this, SLOT( fauxPlay( QListViewItem *) ) );
 //    connect( videoView, SIGNAL( clicked( QListViewItem *) ), this, SLOT( fauxPlay( QListViewItem *) ) );
 
+    connect(tbDeletePlaylist,(SIGNAL(released())),SLOT( deletePlaylist()));
+    connect( fullScreenButton, SIGNAL(activated()), mediaPlayerState, SLOT(toggleFullscreen()) );
+    connect( scaleButton, SIGNAL(activated()), mediaPlayerState, SLOT(toggleScaled()) );
+    connect( d->selectedFiles, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
+                   this,SLOT( playlistViewPressed(int, QListViewItem *, const QPoint&, int)) );
+
+    connect( audioView, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
+             this,SLOT( viewPressed(int, QListViewItem *, const QPoint&, int)) );
+    
+    connect( audioView, SIGNAL( returnPressed( QListViewItem *)),
+             this,SLOT( playIt( QListViewItem *)) );
    connect( audioView, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( addToSelection( QListViewItem *) ) );
+
+    connect( videoView, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
+             this,SLOT( viewPressed(int, QListViewItem *, const QPoint&, int)) );
+    connect( videoView, SIGNAL( returnPressed( QListViewItem *)),
+             this,SLOT( playIt( QListViewItem *)) );
    connect( videoView, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( addToSelection( QListViewItem *) ) );
 
+    connect( playLists, SIGNAL( fileSelected( const DocLnk &) ), this, SLOT( loadList( const DocLnk & ) ) );
+
+
    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( "OpiePlayer" );
     readConfig( cfg );
     QString currentPlaylist = cfg.readEntry("CurrentPlaylist","");
 //    qDebug("currentList is "+currentPlaylist);
     loadList(DocLnk( currentPlaylist));
     setCaption(tr("OpiePlayer: ")+ currentPlaylist );
     
     initializeStates();
 }
 
 
 PlayListWidget::~PlayListWidget() {
     Config cfg( "OpiePlayer" );
     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 ) {
@@ -707,179 +711,182 @@ void PlayListWidget::addSelected() {
                         }
                     }
                     audioView->setSelected( it.current(),FALSE);
                 }
             }
             tabWidget->setCurrentPage(0);
         }           
         break;
         case 2: { // video
             QListViewItemIterator it(  videoView  );
               // iterate through all items of the listview
             for ( ; it.current(); ++it ) {
                 if ( it.current()->isSelected() ) {
                     QListIterator<DocLnk> dit( vFiles.children() );
                     for ( ; dit.current(); ++dit ) {
                         if( dit.current()->name() == it.current()->text(0) ) {
                             d->selectedFiles->addToSelection(  **dit );
                         }
                     }
 
                     videoView->setSelected( it.current(),FALSE);
                 }
             }
 //             for ( int i = 0; i < noOfFiles; i++ ) {
 //                 QString entryName;
 //                 entryName.sprintf( "File%i", i + 1 );
 //                 QString linkFile = cfg.readEntry( entryName );
 //                   if( DocLnk( linkFile).name() == videoView->selectedItem()->text(0) ) {
 //                       int result= QMessageBox::warning(this,tr("OpiePlayer"),
 //                                   tr("This is all ready in your playlist.\nContinue?"),
 //                                   tr("Yes"),tr("No"),0,0,1);
 //                       if (result !=0)
 //                           return;
 //                   }
 //             }
 //             addToSelection( videoView->selectedItem() );
             tabWidget->setCurrentPage(0);
         }
         break;
       };
 }
 
 void PlayListWidget::removeSelected() {
     d->selectedFiles->removeSelected( );
 }
 
 void PlayListWidget::playIt( QListViewItem *it) {
 //   d->setDocumentUsed = FALSE;
+//  mediaPlayerState->curPosition =0;
+ qDebug("playIt");
         mediaPlayerState->setPlaying(FALSE);
         mediaPlayerState->setPlaying(TRUE);
         d->selectedFiles->unSelect();
 }
 
 void PlayListWidget::addToSelection( QListViewItem *it) {
     d->setDocumentUsed = FALSE;
     
     if(it) {
         switch (tabWidget->currentPageIndex()) {
           case 1: {
               QListIterator<DocLnk> dit( files.children() );
               for ( ; dit.current(); ++dit ) {
                   if( dit.current()->name() == it->text(0)) {
                       d->selectedFiles->addToSelection(  **dit );
                   }
               }
           }
               break;
           case 2: {
               QListIterator<DocLnk> dit( vFiles.children() );
               for ( ; dit.current(); ++dit ) {
                   if( dit.current()->name() == it->text(0)) {
                       d->selectedFiles->addToSelection(  **dit );
                   }
               }
           }
               break;
           case 0:
               break;
         };
         tabWidget->setCurrentPage(0);
     }
 }
 
 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:
       {
           audioView->clear();
           populateAudioView();
 
           if( !tbDeletePlaylist->isHidden())
               tbDeletePlaylist->hide();
           d->tbRemoveFromList->setEnabled(FALSE);
           d->tbAddToList->setEnabled(TRUE);
       }
       break;
       case 2:
       {
           videoView->clear();
           populateVideoView();
           if( !tbDeletePlaylist->isHidden())
               tbDeletePlaylist->hide();
           d->tbRemoveFromList->setEnabled(FALSE);
           d->tbAddToList->setEnabled(TRUE);
       }
       break;
       case 3:
       {
           if( tbDeletePlaylist->isHidden())
               tbDeletePlaylist->show();
           playLists->reread();
       }
       break;
     };
 }
 
 void PlayListWidget::btnPlay(bool b) {
 
 //    mediaPlayerState->setPlaying(b);
     switch ( tabWidget->currentPageIndex()) {
       case 0:
       {
+
           mediaPlayerState->setPlaying(b);
       }
       break;
       case 1:
       {
           addToSelection( audioView->currentItem() );
           mediaPlayerState->setPlaying(b);
           d->selectedFiles->removeSelected( );
           tabWidget->setCurrentPage(1);
           d->selectedFiles->unSelect();
           insanityBool=FALSE;         
 //          audioView->clearSelection();
       }
       break;
       case 2:
       {
           addToSelection( videoView->currentItem() );
           mediaPlayerState->setPlaying(b);
           qApp->processEvents();
           d->selectedFiles->removeSelected( );
           tabWidget->setCurrentPage(2);
           d->selectedFiles->unSelect();
           insanityBool=FALSE;
 //          videoView->clearSelection();
       }
       break;
     };
 }
 
 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::viewPressed( int mouse, QListViewItem *item, const QPoint& point, int i)
 {
     switch (mouse) {
       case 1:
           break;