more gui updates

5 files changed, 42 insertions, 15 deletions

diff --git a/noncore/multimedia/opieplayer2/audiowidget.cpp b/noncore/multimedia/opieplayer2/audiowidget.cpp
index 125fd72..303e56e 100644
--- a/noncore/multimedia/opieplayer2/audiowidget.cpp
+++ b/noncore/multimedia/opieplayer2/audiowidget.cpp
@@ -1,356 +1,356 @@
 
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 
 #include <qwidget.h>
 #include <qpixmap.h>
 #include <qbutton.h>
 #include <qpainter.h>
 #include <qframe.h>
 #include <qlayout.h>
 
 #include "audiowidget.h"
 #include "mediaplayerstate.h"
 
 extern MediaPlayerState *mediaPlayerState;
 
 static const int xo = -2; // movable x offset
 static const int yo = 22; // movable y offset
 
 
 Ticker::Ticker( QWidget* parent=0 ) : QFrame( parent ) {
         setFrameStyle( WinPanel | Sunken );
         setText( "No Song" );
 }
 
 Ticker::~Ticker() {
 }
 
 void Ticker::setText( const QString& text ) {
     pos = 0; // reset it everytime the text is changed
     scrollText = text;
     pixelLen = fontMetrics().width( scrollText );
     killTimers();
     if ( pixelLen > width() ) {
         startTimer( 50 );
     }
     update();
 }
 
 
 void Ticker::timerEvent( QTimerEvent * ) {
     pos = ( pos + 1 > pixelLen ) ? 0 : pos + 1;
     repaint( FALSE );
 }
 
 void Ticker::drawContents( QPainter *p ) {
     QPixmap pm( width(), height() );
     pm.fill( colorGroup().base() );
     QPainter pmp( &pm );
     for ( int i = 0; i - pos < width() && (i < 1 || pixelLen > width()); i += pixelLen ) {
         pmp.drawText( i - pos, 0, INT_MAX, height(), AlignVCenter, scrollText );
     }
     p->drawPixmap( 0, 0, pm );
 }
 
 
 struct MediaButton {
     int  xPos, yPos;
     int  color;
     bool isToggle, isBig, isHeld, isDown;
 };
 
 
 // Layout information for the audioButtons (and if it is a toggle button or not)
 MediaButton audioButtons[] = {
     { 3*30-15+xo, 3*30-13+yo, 0,  TRUE,  TRUE, FALSE, FALSE }, // play
     {    1*30+xo,    5*30+yo, 2, FALSE, FALSE, FALSE, FALSE }, // stop
     {    5*30+xo,    5*30+yo, 2,  TRUE, FALSE, FALSE, FALSE }, // pause
     {  6*30-5+xo,    3*30+yo, 1, FALSE, FALSE, FALSE, FALSE }, // next
     {  0*30+5+xo,    3*30+yo, 1, FALSE, FALSE, FALSE, FALSE }, // previous
     {    3*30+xo,  0*30+5+yo, 3, FALSE, FALSE, FALSE, FALSE }, // volume up
     {    3*30+xo,  6*30-5+yo, 3, FALSE, FALSE, FALSE, FALSE }, // volume down
     {    5*30+xo,    1*30+yo, 0,  TRUE, FALSE, FALSE, FALSE }, // repeat/loop
     {    1*30+xo,    1*30+yo, 0, FALSE, FALSE, FALSE, FALSE }  // playlist
 };
 
 static const int numButtons = (sizeof(audioButtons)/sizeof(MediaButton));
 
 
 AudioWidget::AudioWidget(QWidget* parent, const char* name, WFlags f) :
     QWidget( parent, name, f ) {
     setCaption( tr("OpiePlayer - Audio") );
     Config cfg("OpiePlayer");
     cfg.setGroup("AudioWidget");
 
     QString backgroundPix, buttonsAllPix, buttonsBigPix, controlsPix, animatedPix;
     backgroundPix=cfg.readEntry( " backgroundPix", "opieplayer/metalFinish");
     buttonsAllPix=cfg.readEntry( "buttonsAllPix","opieplayer/mediaButtonsAll");
     buttonsBigPix=cfg.readEntry( "buttonsBigPix","opieplayer/mediaButtonsBig");
     controlsPix=cfg.readEntry( "controlsPix","opieplayer/mediaControls");
 
     setBackgroundPixmap( Resource::loadPixmap( backgroundPix) );
     pixmaps[0] = new QPixmap( Resource::loadPixmap( buttonsAllPix ) );
     pixmaps[1] = new QPixmap( Resource::loadPixmap( buttonsBigPix ) );
     pixmaps[2] = new QPixmap( Resource::loadPixmap( controlsPix ) );
 
     songInfo = new Ticker( this );
     songInfo->setFocusPolicy( QWidget::NoFocus );
     songInfo->setGeometry( QRect( 7, 3, 220, 20 ) );
 
     slider = new QSlider( Qt::Horizontal, this );
     slider->setFixedWidth( 220 );
     slider->setFixedHeight( 20 );
     slider->setMinValue( 0 );
     slider->setMaxValue( 1 );
     slider->setBackgroundPixmap( Resource::loadPixmap( backgroundPix ) );
     slider->setFocusPolicy( QWidget::NoFocus );
     slider->setGeometry( QRect( 7, 262, 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( 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;
+    mediaPlayerState->setIsStreaming( FALSE );
     for ( int i = 0; i < 3; 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 (mediaPlayerState->streaming() ) {
         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 );
         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);
     paintButton ( &p, i );
 }
 
 
 void AudioWidget::paintButton( QPainter *p, int i ) {
     int x = audioButtons[i].xPos;
     int y = audioButtons[i].yPos;
     int offset = 22 + 14 * audioButtons[i].isBig + audioButtons[i].isDown;
     int buttonSize = 64 + audioButtons[i].isBig * (90 - 64);
     p->drawPixmap( x, y, *pixmaps[audioButtons[i].isBig], buttonSize * (audioButtons[i].isDown + 2 * audioButtons[i].color), 0, buttonSize, buttonSize );
     p->drawPixmap( x + offset, y + offset, *pixmaps[2], 18 * i, 0, 18, 18 );
 }
 
 
 void AudioWidget::timerEvent( QTimerEvent * ) {
     static int frame = 0;
     if ( !mediaPlayerState->paused() && audioButtons[ AudioPlay ].isDown ) {
         frame = frame >= 7 ? 0 : frame + 1;
     }
 }
 
 
 void AudioWidget::mouseMoveEvent( QMouseEvent *event ) {
     for ( int i = 0; i < numButtons; i++ ) {
         int size = audioButtons[i].isBig;
         int x = audioButtons[i].xPos;
         int y = audioButtons[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 = 32 + 13 * size;
             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 && !audioButtons[i].isHeld ) {
                 audioButtons[i].isHeld = TRUE;
                 toggleButton(i);
                 qDebug("button toggled1  %d",i);
                 switch (i) {
                   case AudioVolumeUp:   emit moreClicked(); return;
                   case AudioVolumeDown: emit lessClicked(); return;
                 }
             } else if ( !isOnButton && audioButtons[i].isHeld ) {
                 audioButtons[i].isHeld = FALSE;
                 toggleButton(i);
                 qDebug("button toggled2  %d",i);
             }
         } else {
             if ( audioButtons[i].isHeld ) {
                 audioButtons[i].isHeld = FALSE;
                 if ( !audioButtons[i].isToggle )
                     setToggleButton( i, FALSE );
                 qDebug("button toggled3  %d",i);
                 switch (i) {
                   case AudioPlay:       mediaPlayerState->setPlaying(audioButtons[i].isDown); return;
                   case AudioStop:       mediaPlayerState->setPlaying(FALSE); return;
                   case AudioPause:      mediaPlayerState->setPaused(audioButtons[i].isDown); return;
                   case AudioNext:       mediaPlayerState->setNext(); return;
                   case AudioPrevious:   mediaPlayerState->setPrev(); return;
                   case AudioLoop:       mediaPlayerState->setLooping(audioButtons[i].isDown); return;
                   case AudioVolumeUp:   emit moreReleased(); return;
                   case AudioVolumeDown: emit lessReleased(); return;
                   case AudioPlayList:   mediaPlayerState->setList();  return;
                 }
             }
         }
     }
 }
 
 
 void AudioWidget::mousePressEvent( QMouseEvent *event ) {
     mouseMoveEvent( event );
 }
 
 
 void AudioWidget::mouseReleaseEvent( QMouseEvent *event ) {
     mouseMoveEvent( event );
 }
 
 
 void AudioWidget::showEvent( QShowEvent* ) {
     QMouseEvent event( QEvent::MouseMove, QPoint( 0, 0 ), 0, 0 );
     mouseMoveEvent( &event );
 }
 
 
 void AudioWidget::closeEvent( QCloseEvent* ) {
     mediaPlayerState->setList();
 }
 
 
 void AudioWidget::paintEvent( QPaintEvent * ) {
     QPainter p( this );
     for ( int i = 0; i < numButtons; i++ )
   paintButton( &p, i );
 }
 
 void AudioWidget::keyReleaseEvent( QKeyEvent *e)
 {
     switch ( e->key() ) {
 ////////////////////////////// Zaurus keys
       case Key_Home:
           break;
       case Key_F9: //activity
            hide();
 //           qDebug("Audio F9");
           break;
       case Key_F10: //contacts
           break;
       case Key_F11: //menu
           break;
       case Key_F12: //home
           break;
       case Key_F13: //mail
           break;
       case Key_Space: {
           if(mediaPlayerState->playing()) {
 //                toggleButton(1);
               mediaPlayerState->setPlaying(FALSE);
 //                toggleButton(1);
           } else {
 //                toggleButton(0);
               mediaPlayerState->setPlaying(TRUE);
 //                toggleButton(0);
           }
       }
           break;
       case Key_Down:
             toggleButton(6);
           emit lessClicked();
           emit lessReleased();
           toggleButton(6);
           break;
       case Key_Up:
            toggleButton(5);
            emit moreClicked();
            emit moreReleased();
            toggleButton(5);
            break;
       case Key_Right:
diff --git a/noncore/multimedia/opieplayer2/mediaplayer.cpp b/noncore/multimedia/opieplayer2/mediaplayer.cpp
index 0ab0124..38ba08f 100644
--- a/noncore/multimedia/opieplayer2/mediaplayer.cpp
+++ b/noncore/multimedia/opieplayer2/mediaplayer.cpp
@@ -1,172 +1,165 @@
 #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 "mediaplayerstate.h"
 
 
 
 extern AudioWidget *audioUI;
 extern PlayListWidget *playList;
 extern MediaPlayerState *mediaPlayerState;
 
 
 MediaPlayer::MediaPlayer( QObject *parent, const char *name )
     : QObject( parent, name ), volumeDirection( 0 ), currentFile( NULL ) {
 
 
     xineControl = new XineControl();
 //    QPEApplication::grabKeyboard(); // EVIL
     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 );
         return;
     }
 
     if ( mediaPlayerState->paused() ) {
         mediaPlayerState->setPaused( FALSE );
         return;
     }
 
     const DocLnk *playListCurrent = playList->current();
     if ( playListCurrent != NULL ) {
         currentFile = playListCurrent;
     }
 
     audioUI->setTickerText( currentFile->file( ) );
 
     xineControl->play( currentFile->file() );
-
-    // alles nicht nötig, xine kümmert sich drum, man muss nur den return andio oder video gui geben
-
-    // Ob auch video 'v' : 'a'
-    //  mediaPlayerState->setView( 'v' );
-
-    // abspielen starten.
 }
 
 
 void MediaPlayer::prev() {
     if ( playList->prev() ) {
         play();
     } else if ( mediaPlayerState->looping() ) {
         if ( playList->last() ) {
             play();
         }
     } else {
         mediaPlayerState->setList();
     }
 }
 
 
 void MediaPlayer::next() {
     if ( playList->next() ) {
         play();
     } else if ( mediaPlayerState->looping() ) {
         if ( playList->first() ) {
             play();
         }
     } else {
         mediaPlayerState->setList();
     }
 }
 
 
 void MediaPlayer::startDecreasingVolume() {
     volumeDirection = -1;
     startTimer( 100 );
     // da kommt demnächst osound denk ich mal
     //  AudioDevice::decreaseVolume();
 }
 
 
 void MediaPlayer::startIncreasingVolume() {
     volumeDirection = +1;
     startTimer( 100 );
     //  AudioDevice::increaseVolume();
 }
 
 
 void MediaPlayer::stopChangingVolume() {
     killTimers();
 }
 
 
 void MediaPlayer::timerEvent( QTimerEvent * ) {
     //    if ( volumeDirection == +1 )
     //  AudioDevice::increaseVolume();
     //    else if ( volumeDirection == -1 )
         //       AudioDevice::decreaseVolume();
 }
 
 void MediaPlayer::keyReleaseEvent( QKeyEvent *e) {
     switch ( e->key() ) {
 ////////////////////////////// Zaurus keys
       case Key_Home:
           break;
       case Key_F9: //activity
           break;
       case Key_F10: //contacts
           break;
       case Key_F11: //menu
           break;
       case Key_F12: //home
           qDebug("Blank here");
           break;
       case Key_F13: //mail
           break;
     }
 }
 
 void MediaPlayer::doBlank() {
 
 }
 
 void MediaPlayer::doUnblank() {
 
 }
 
 void MediaPlayer::cleanUp() {
 //     QPEApplication::grabKeyboard();
 //     QPEApplication::ungrabKeyboard();
 
 }
diff --git a/noncore/multimedia/opieplayer2/mediaplayerstate.cpp b/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
index 3090b08..778cd1e 100644
--- a/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
+++ b/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
@@ -1,243 +1,268 @@
 #include <qpe/qpeapplication.h>
 #include <qpe/qlibrary.h>
 #include <qpe/config.h>
 #include <qvaluelist.h>
 #include <qobject.h>
 #include <qdir.h>
 #include "mediaplayerstate.h"
 
 
 
 //#define MediaPlayerDebug(x) qDebug x
 #define MediaPlayerDebug(x)
 
 
 MediaPlayerState::MediaPlayerState( QObject *parent, const char *name )
         : QObject( parent, name ) {
     Config cfg( "OpiePlayer" );
     readConfig( cfg );
 
 }
 
 
 MediaPlayerState::~MediaPlayerState() {
     Config cfg( "OpiePlayer" );
     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 );
 }
 
 
 
 
 // public stuff
+
+
+bool MediaPlayerState::streaming() {
+    return isStreaming;
+}
+
 bool MediaPlayerState::fullscreen() {
     return isFullscreen;
 }
 
 bool MediaPlayerState::scaled() {
     return isScaled;
 }
 
 bool MediaPlayerState::looping() {
     return isLooping;
 }
 
 bool MediaPlayerState::shuffled() {
     return isShuffled;
 }
 
 
 bool MediaPlayerState:: playlist() {
     return usePlaylist;
 }
 
 bool MediaPlayerState::paused() {
     return isPaused;
 }
 
 bool MediaPlayerState::playing() {
     return isPlaying;
 }
 
+bool MediaPlayerState::stop() {
+    return isStoped;
+}
+
 long MediaPlayerState::position() {
     return curPosition;
 }
 
 long MediaPlayerState::length() {
     return curLength;
 }
 
 char MediaPlayerState::view() {
     return curView;
 }
 
 // slots
+void MediaPlayerState::setIsStreaming( bool b ) {
+    if ( isStreaming == b ) {
+        return;
+    }
+    isStreaming = b;
+}
+
+
 void MediaPlayerState::setFullscreen( bool b ) {
     if ( isFullscreen == b ) {
         return;
     }
     isFullscreen = b;
     emit fullscreenToggled(b);
 }
 
 
 void MediaPlayerState::setScaled( bool b ) {
     if ( isScaled == b ) {
         return;
     }
     isScaled = b;
     emit scaledToggled(b);
 }
 
 void MediaPlayerState::setLooping( bool b ) {
     if ( isLooping    == b ) {
         return;
     }
     isLooping = b;
     emit loopingToggled(b);
 }
 
 void MediaPlayerState::setShuffled( bool b ) {
     if ( isShuffled   == b ) {
         return;
     }
     isShuffled = b;
     emit shuffledToggled(b);
 }
 
 void MediaPlayerState::setPlaylist( bool b ) {
     if ( usePlaylist  == b ) {
         return;
     }
     usePlaylist = b;
     emit playlistToggled(b);
 }
 
 void MediaPlayerState::setPaused( bool b ) {
     if ( isPaused  == b ) {
         return;
     }
     isPaused = b;
     emit pausedToggled(b);
 }
 
 void MediaPlayerState::setPlaying( bool b ) {
     if ( isPlaying  == b ) {
         return;
     }
     isPlaying = b;
+    isStoped = !b;
     emit playingToggled(b);
 }
 
+void MediaPlayerState::setStop( bool b ) {
+    if ( isStoped  == b ) {
+        return;
+    }
+    isStoped = b;
+    emit stopToggled(b);
+}
+
 void MediaPlayerState::setPosition( long p ) {
     if ( curPosition == p ) {
         return;
     }
     curPosition = p;
     emit positionChanged(p);
 }
 
 void MediaPlayerState::updatePosition( long p ){
     if ( curPosition  == p ) {
         return;
     }
     curPosition = p;
     emit positionUpdated(p);
 }
 
 void MediaPlayerState::setLength( long l ) {
     if ( curLength  == l ) {
         return;
     }
     curLength = l;
     emit lengthChanged(l);
 }
 
 void MediaPlayerState::setView( char v ) {
     if ( curView  == v ) {
         return;
     }
     curView = v;
     emit viewChanged(v);
 }
 
 void MediaPlayerState::setPrev(){
     emit prev();
 }
 
 void MediaPlayerState::setNext() {
     emit next();
 }
 
 void MediaPlayerState::setList() {
     setPlaying( FALSE );
     setView('l');
 }
 
 void MediaPlayerState::setVideo() {
     setView('v');
 }
 
 void MediaPlayerState::setAudio() {
     setView('a');
 }
 
-
-
 void MediaPlayerState::toggleFullscreen() {
     setFullscreen( !isFullscreen );
 }
 
 void MediaPlayerState::toggleScaled() {
     setScaled( !isScaled);
 }
 
 void MediaPlayerState::toggleLooping() {
     setLooping( !isLooping);
 }
 
 void MediaPlayerState::toggleShuffled() {
     setShuffled( !isShuffled);
 }
 
 void MediaPlayerState::togglePlaylist() {
     setPlaylist( !usePlaylist);
 }
 
 void MediaPlayerState::togglePaused() {
     setPaused( !isPaused);
 }
 
 void MediaPlayerState::togglePlaying() {
     setPlaying( !isPlaying);
 }
 
 
 
 
diff --git a/noncore/multimedia/opieplayer2/mediaplayerstate.h b/noncore/multimedia/opieplayer2/mediaplayerstate.h
index dbbb0f2..20e3552 100644
--- a/noncore/multimedia/opieplayer2/mediaplayerstate.h
+++ b/noncore/multimedia/opieplayer2/mediaplayerstate.h
@@ -1,94 +1,100 @@
 
 #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 isStreaming;
+    bool streaming();
     bool fullscreen();
     bool scaled();
     bool looping();
     bool shuffled();
     bool playlist();
     bool paused();
     bool playing();
+    bool stop();
     long position();
     long length();
     char view();
 
 public slots:
+    void setIsStreaming( bool b );
     void setFullscreen( bool b );
     void setScaled( bool b );
     void setLooping( bool b );
     void setShuffled( bool b );
     void setPlaylist( bool b );
     void setPaused( bool b );
     void setPlaying( bool b );
+    void setStop( bool b );
     void setPosition( long p );
     void updatePosition( long p );
     void setLength( long l );
     void setView( char v );
 
     void setPrev();
     void setNext();
     void setList();
     void setVideo();
     void setAudio();
 
     void toggleFullscreen();
     void toggleScaled();
     void toggleLooping();
     void toggleShuffled();
     void togglePlaylist();
     void togglePaused();
     void togglePlaying();
 
 signals:
     void fullscreenToggled( bool );
     void scaledToggled( bool );
     void loopingToggled( bool );
     void shuffledToggled( bool );
     void playlistToggled( bool );
     void pausedToggled( bool );
     void playingToggled( bool );
+    void stopToggled( 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 isStreaming;
     bool isFullscreen;
     bool isScaled;
     bool isLooping;
     bool isShuffled;
     bool usePlaylist;
     bool isPaused;
     bool isPlaying;
+    bool isStoped;
     long curPosition;
     long curLength;
     char curView;
 
     void readConfig( Config& cfg );
     void writeConfig( Config& cfg ) const;
 
 
 };
 
 
 #endif // MEDIA_PLAYER_STATE_H
 
diff --git a/noncore/multimedia/opieplayer2/xinecontrol.cpp b/noncore/multimedia/opieplayer2/xinecontrol.cpp
index cda9be2..5b674f8 100644
--- a/noncore/multimedia/opieplayer2/xinecontrol.cpp
+++ b/noncore/multimedia/opieplayer2/xinecontrol.cpp
@@ -1,59 +1,62 @@
 
 #include "xinecontrol.h"
 #include "mediaplayerstate.h"
 
 extern MediaPlayerState *mediaPlayerState;
 
 XineControl::XineControl( QObject *parent, const char *name )
     : QObject( parent, name ) {
     libXine = new XINE::Lib();
 
     connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( pause(bool) ) );
     connect( this, SIGNAL( positionChanged( int position ) ),  mediaPlayerState, SLOT( updatePosition( long p ) ) );
     connect( mediaPlayerState, SIGNAL( playingToggled( bool ) ), this, SLOT( stop( bool ) ) );
 
 }
 
 XineControl::~XineControl() {
     delete libXine;
 }
 
 void XineControl::play( const QString& fileName ) {
     libXine->play( fileName );
     mediaPlayerState->setPlaying( true );
     // default to audio view until we know how to handle video
     mediaPlayerState->setView('a');
     // determines of slider is shown
-    mediaPlayerState->isStreaming = false;
+    // mediaPlayerState->setIsStreaming( false );
     // hier dann schaun welcher view
 }
 
 void XineControl::stop( bool isSet ) {
-    if ( isSet) {
+    if ( !isSet) {
         libXine->stop();
+        mediaPlayerState->setNext();
+        //mediaPlayerState->setPlaying( false );
+    } else {
+        // play again
     }
-    // mediaPlayerState->setPlaying( false );
 }
 
 void XineControl::pause( bool isSet) {
 
     libXine->pause();
 }
 
 int XineControl::currentTime() {
     // todo: jede sekunde überprüfen
     m_currentTime =  libXine->currentTime();
     return m_currentTime;
 }
 
 void  XineControl::length() {
     m_length = libXine->length();
     mediaPlayerState->setLength( m_length );
 }
 
 int XineControl::position() {
     m_position = (m_currentTime/m_length*100);
     mediaPlayerState->setPosition( m_position  );
     return m_position;
     emit positionChanged( m_position );
 }