fixes

12 files changed, 45 insertions, 29 deletions

diff --git a/noncore/multimedia/opieplayer2/audiowidget.cpp b/noncore/multimedia/opieplayer2/audiowidget.cpp
index 40e20e1..a718826 100644
--- a/noncore/multimedia/opieplayer2/audiowidget.cpp
+++ b/noncore/multimedia/opieplayer2/audiowidget.cpp
@@ -1,590 +1,592 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #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 <stdlib.h>
 #include <stdio.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;
     scroll( -1, 0, contentsRect() );
     repaint( FALSE );
 }
 
 void Ticker::drawContents( QPainter *p ) {
     for ( int i = 0; i - pos < width() && (i < 1 || pixelLen > width()); i += pixelLen ) {
         p->drawText( i - pos, 0, INT_MAX, height(), AlignVCenter, scrollText );
     }
     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 {
     bool isToggle, isHeld, isDown;
 };
 
 //Layout information for the audioButtons (and if it is a toggle button or not)
 MediaButton audioButtons[] = {
    { TRUE,  FALSE, FALSE }, // play
    { FALSE, FALSE, FALSE }, // stop
    { FALSE, FALSE, FALSE }, // next
    { FALSE, FALSE, FALSE }, // previous
    { FALSE, FALSE, FALSE }, // volume up
    { FALSE, FALSE, FALSE }, // volume down
    { TRUE,  FALSE, FALSE }, // repeat/loop
    { FALSE, FALSE, FALSE }, // playlist
    { FALSE, FALSE, FALSE }, // forward
    { FALSE, FALSE, FALSE }  // back
 };
 
 const char *skin_mask_file_names[10] = {
    "play", "stop", "next", "prev", "up",
    "down", "loop", "playlist", "forward", "back"
 };
 
 
 static void changeTextColor( QWidget *w ) {
    QPalette p = w->palette();
    p.setBrush( QColorGroup::Background, QColor( 167, 212, 167 ) );
    p.setBrush( QColorGroup::Base, QColor( 167, 212, 167 ) );
    w->setPalette( p );
 }
 
 static const int numButtons = (sizeof(audioButtons)/sizeof(MediaButton));
 
 
 AudioWidget::AudioWidget(QWidget* parent, const char* name, WFlags f) :
 
     QWidget( parent, name, f ), songInfo( this ), slider( Qt::Horizontal, this ),  time( this ) {
 
     setCaption( tr("OpiePlayer") );
 
     Config cfg("OpiePlayer");
     cfg.setGroup("Options");
     skin = cfg.readEntry("Skin","default");
     //skin = "scaleTest";
     // color of background, frame, degree of transparency
 
     QString skinPath = "opieplayer2/skins/" + skin;
     pixBg = new QPixmap( Resource::loadPixmap( QString("%1/background").arg(skinPath) ) );
     imgUp = new QImage( Resource::loadImage( QString("%1/skin_up").arg(skinPath) ) );
     imgDn = new QImage( Resource::loadImage( QString("%1/skin_down").arg(skinPath) ) );
 
     imgButtonMask = new QImage( imgUp->width(), imgUp->height(), 8, 255 );
     imgButtonMask->fill( 0 );
 
     for ( int i = 0; i < 10; i++ ) {
         QString filename = QString( QPEApplication::qpeDir()  + "/pics/" + skinPath + "/skin_mask_" + skin_mask_file_names[i] + ".png" );
         masks[i] = new QBitmap( filename );
 
         if ( !masks[i]->isNull() ) {
             QImage imgMask = masks[i]->convertToImage();
             uchar **dest = imgButtonMask->jumpTable();
             for ( int y = 0; y < imgUp->height(); y++ ) {
                 uchar *line = dest[y];
                 for ( int x = 0; x < imgUp->width(); x++ )
                     if ( !qRed( imgMask.pixel( x, y ) ) )
                         line[x] = i + 1;
             }
         }
 
     }
 
     for ( int i = 0; i < 10; i++ ) {
-        buttonPixUp[i] = NULL;
-        buttonPixDown[i] = NULL;
+        buttonPixUp[i] = 0l;
+        buttonPixDown[i] = 0l;
     }
 
     setBackgroundPixmap( *pixBg );
 
     songInfo.setFocusPolicy( QWidget::NoFocus );
     changeTextColor( &songInfo );
 
     slider.setFixedHeight( 20 );
     slider.setMinValue( 0 );
     slider.setMaxValue( 1 );
     slider.setFocusPolicy( QWidget::NoFocus );
     slider.setBackgroundPixmap( *pixBg );
 
     time.setFocusPolicy( QWidget::NoFocus );
     time.setAlignment( Qt::AlignCenter );
     time.setFrame(FALSE);
     changeTextColor( &time );
 
     resizeEvent( NULL );
 
     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) ) );
 
     connect( this,  SIGNAL( forwardClicked() ), this, SLOT( skipFor() ) );
     connect( this,  SIGNAL( backClicked() ),  this, SLOT( skipBack() ) );
     connect( this,  SIGNAL( forwardReleased() ), this, SLOT( stopSkip() ) );
     connect( this,  SIGNAL( backReleased() ), this, SLOT( stopSkip() ) );
 
 
 
     // Intialise state
     setLength( mediaPlayerState->length() );
     setPosition( mediaPlayerState->position() );
     setLooping( mediaPlayerState->fullscreen() );
     //    setPaused( mediaPlayerState->paused() );
     setPlaying( mediaPlayerState->playing() );
 
 }
 
 AudioWidget::~AudioWidget() {
 
     for ( int i = 0; i < 10; i++ ) {
         delete buttonPixUp[i];
         delete buttonPixDown[i];
     }
     delete pixBg;
     delete imgUp;
     delete imgDn;
     delete imgButtonMask;
     for ( int i = 0; i < 10; i++ ) {
         delete masks[i];
     }
 }
 
+namespace {
+
 QPixmap *combineImageWithBackground( QImage img, QPixmap bg, QPoint offset ) {
     QPixmap pix( img.width(), img.height() );
     QPainter p( &pix );
     p.drawTiledPixmap( pix.rect(), bg, offset );
     p.drawImage( 0, 0, img );
     return new QPixmap( pix );
 }
 
 
 QPixmap *maskPixToMask( QPixmap pix, QBitmap mask ) {
     QPixmap *pixmap = new QPixmap( pix );
     pixmap->setMask( mask );
     return pixmap;
 }
 
-
+};
 
 void AudioWidget::resizeEvent( QResizeEvent * ) {
     int h = height();
     int w = width();
 
     songInfo.setGeometry( QRect( 2, 10, w - 4, 20 ) );
     slider.setFixedWidth( w - 110 );
     slider.setGeometry( QRect( 15, h - 30, w - 90, 20 ) );
     slider.setBackgroundOrigin( QWidget::ParentOrigin );
     time.setGeometry( QRect( w - 85, h - 30, 70, 20 ) );
 
     xoff = ( w - imgUp->width() ) / 2;
     yoff = (( h - imgUp->height() ) / 2) - 10;
     QPoint p( xoff, yoff );
 
     QPixmap *pixUp = combineImageWithBackground( *imgUp, *pixBg, p );
     QPixmap *pixDn = combineImageWithBackground( *imgDn, *pixBg, p );
 
     for ( int i = 0; i < 10; i++ ) {
         if ( !masks[i]->isNull() ) {
             delete buttonPixUp[i];
             delete buttonPixDown[i];
             buttonPixUp[i] = maskPixToMask( *pixUp, *masks[i] );
             buttonPixDown[i] = maskPixToMask( *pixDn, *masks[i] );
         }
     }
 
     delete pixUp;
     delete pixDn;
 }
 
 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 ) {
 
     // this isnt working for some reason
 
     if ( mediaPlayerState->streaming() ) {
         qDebug("<<<<<<<<<<<<<<file is 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();
     }
     qApp->processEvents();
 }
 
 
 static QString timeAsString( long length ) {
     int minutes = length / 60;
     int seconds = length % 60;
     return QString("%1:%2%3").arg( minutes ).arg( seconds / 10 ).arg( seconds % 10 );
 }
 
 void AudioWidget::updateSlider( long i, long max ) {
 
     time.setText( timeAsString( i ) + " / " + timeAsString( max ) );
 //    qDebug( timeAsString( i ) + " / " + timeAsString( 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 ) {
     qDebug("setToggleButton %d", i);
     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 ) {
     if ( audioButtons[i].isDown ) {
         p->drawPixmap( xoff, yoff, *buttonPixDown[i] );
     } else {
         p->drawPixmap( xoff, yoff, *buttonPixUp[i] );
     }
 }
 
 
 void AudioWidget::skipFor() {
     skipDirection = +1;
     startTimer( 50 );
     mediaPlayerState->setPosition(  mediaPlayerState->position() + 2 );
 }
 
 void AudioWidget::skipBack() {
     skipDirection = -1;
     startTimer( 50 );
     mediaPlayerState->setPosition(  mediaPlayerState->position() - 2 );
 }
 
 
 
 void AudioWidget::stopSkip() {
     killTimers();
 }
 
 
 void AudioWidget::timerEvent( QTimerEvent * ) {
     if ( skipDirection == +1 ) {
         mediaPlayerState->setPosition(  mediaPlayerState->position() + 2 );
     }  else if ( skipDirection == -1 ) {
         mediaPlayerState->setPosition(  mediaPlayerState->position() - 2 );
     }
 }
 
 
 void AudioWidget::mouseMoveEvent( QMouseEvent *event ) {
     for ( int i = 0; i < numButtons; i++ ) {
         if ( event->state() == QMouseEvent::LeftButton ) {
             // The test to see if the mouse click is inside the button or not
             int x = event->pos().x() - xoff;
             int y = event->pos().y() - yoff;
 
             bool isOnButton = ( x > 0 && y > 0 && x < imgButtonMask->width()
                                 && y < imgButtonMask->height()
                                 && imgButtonMask->pixelIndex( x, y ) == i + 1 );
 
             if ( isOnButton && !audioButtons[i].isHeld ) {
                 audioButtons[i].isHeld = TRUE;
                 toggleButton(i);
                 switch (i) {
                 case AudioVolumeUp:
                     emit moreClicked();
                     return;
                 case AudioVolumeDown:
                     emit lessClicked();
                     return;
                 case AudioForward:
                     emit forwardClicked();
                     return;
                 case AudioBack:
                     emit backClicked();
                     return;
                 }
             } else if ( !isOnButton && audioButtons[i].isHeld ) {
                 audioButtons[i].isHeld = FALSE;
                 toggleButton(i);
             }
         } else {
             if ( audioButtons[i].isHeld ) {
                 audioButtons[i].isHeld = FALSE;
                 if ( !audioButtons[i].isToggle ) {
                     setToggleButton( i, FALSE );
                 }
                 switch (i) {
                 case AudioPlay:
                     if( mediaPlayerState->isPaused ) {
 //                          setToggleButton( i, FALSE );
                         mediaPlayerState->setPaused( FALSE );
                         return;
                     } else if( !mediaPlayerState->isPaused ) {
 //                            setToggleButton( i, TRUE );
                         mediaPlayerState->setPaused( TRUE );
                         return;
                     } else {
                         //  setToggleButton( i, TRUE );
                         // mediaPlayerState->setPlaying( videoButtons[i].isDown );
                     }
                 case AudioStop:       mediaPlayerState->setPlaying(FALSE); 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;
                 case AudioForward:    emit forwardReleased(); return;
                 case AudioBack:       emit backReleased(); 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 * pe) {
     if ( !pe->erased() ) {
           // Combine with background and double buffer
         QPixmap pix( pe->rect().size() );
         QPainter p( &pix );
         p.translate( -pe->rect().topLeft().x(), -pe->rect().topLeft().y() );
         p.drawTiledPixmap( pe->rect(), *pixBg, pe->rect().topLeft() );
         for ( int i = 0; i < numButtons; i++ )
             paintButton( &p, i );
         QPainter p2( this );
         p2.drawPixmap( pe->rect().topLeft(), pix );
     } else {
         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
               mediaPlayerState->toggleBlank();
           break;
       case Key_F12: //home
           break;
       case Key_F13: //mail
              mediaPlayerState->toggleBlank();
           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:
           //            toggleButton(3);
           mediaPlayerState->setNext();
           //            toggleButton(3);
           break;
       case Key_Left:
           //            toggleButton(4);
           mediaPlayerState->setPrev();
           //            toggleButton(4);
           break;
       case Key_Escape: {
 #if defined(QT_QWS_IPAQ)
           if( mediaPlayerState->isPaused ) {
               setToggleButton( i, FALSE );
               mediaPlayerState->setPaused( FALSE );
           } else if( !mediaPlayerState->isPaused ) {
               setToggleButton( i, TRUE );
               mediaPlayerState->setPaused( TRUE );
           }
 #endif
       }
           break;
 
     };
 }
diff --git a/noncore/multimedia/opieplayer2/audiowidget.h b/noncore/multimedia/opieplayer2/audiowidget.h
index 626004a..c544882 100644
--- a/noncore/multimedia/opieplayer2/audiowidget.h
+++ b/noncore/multimedia/opieplayer2/audiowidget.h
@@ -1,147 +1,150 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef AUDIO_WIDGET_H
 #define AUDIO_WIDGET_H
 
 #include <qwidget.h>
 #include <qpainter.h>
 #include <qdrawutil.h>
 #include <qpixmap.h>
 #include <qstring.h>
 #include <qslider.h>
 #include <qframe.h>
 #include <qlineedit.h>
 
 
 class QPixmap;
 
+namespace {
+
 enum AudioButtons {
     AudioPlay=0,
     AudioStop,
     AudioNext,
     AudioPrevious,
     AudioVolumeUp,
     AudioVolumeDown,
     AudioLoop,
     AudioPlayList,
     AudioForward,
     AudioBack
 };
-
+};
 
 class Ticker : public QFrame {
     Q_OBJECT
 
 public:
     Ticker( QWidget* parent=0 );
     ~Ticker();
     void setText( const QString& text ) ;
 
 protected:
     void timerEvent( QTimerEvent * );
     void drawContents( QPainter *p );
 private:
     QString scrollText;
     int pos, pixelLen;
 };
 
 
 class AudioWidget : public QWidget {
     Q_OBJECT
 public:
     AudioWidget( QWidget* parent=0, const char* name=0, WFlags f=0 );
     ~AudioWidget();
     void setTickerText( const QString &text ) { songInfo.setText( text ); }
 public slots:
     void updateSlider( long, long );
     void sliderPressed( );
     void sliderReleased( );
 //    void setPaused( bool b)  { setToggleButton( AudioPause, b ); }
     void setLooping( bool b) { setToggleButton( AudioLoop, b ); }
     void setPlaying( bool b) { setToggleButton( AudioPlay, b ); }
     void setPosition( long );
     void setLength( long );
     void setView( char );
 
 signals:
     void moreClicked();
     void lessClicked();
     void moreReleased();
     void lessReleased();
     void forwardClicked();
     void backClicked();
     void forwardReleased();
     void backReleased();
     void sliderMoved(long);
 
 protected:
     void doBlank();
     void doUnblank();
     void paintEvent( QPaintEvent *pe );
     void showEvent( QShowEvent *se );
     void resizeEvent( QResizeEvent *re );
     void mouseMoveEvent( QMouseEvent *event );
     void mousePressEvent( QMouseEvent *event );
     void mouseReleaseEvent( QMouseEvent *event );
     void timerEvent( QTimerEvent *event );
     void closeEvent( QCloseEvent *event );
     void keyReleaseEvent( QKeyEvent *e);
 private slots:
     void skipFor();
     void skipBack();
     void stopSkip();
 private:
     void toggleButton( int );
     void setToggleButton( int, bool );
     void paintButton( QPainter *p, int i );
     int skipDirection;
     QString skin;
     QPixmap *pixBg;
     QImage  *imgUp;
     QImage  *imgDn;
     QImage  *imgButtonMask;
     QBitmap *masks[10];
     QPixmap *buttonPixUp[10];
     QPixmap *buttonPixDown[10];
 
     QPixmap *pixmaps[4];
     Ticker  songInfo;
     QSlider slider;
     QLineEdit time;
     int xoff, yoff;
+    bool isStreaming : 1;
 };
 
 
 #endif // AUDIO_WIDGET_H
 
diff --git a/noncore/multimedia/opieplayer2/inputDialog.cpp b/noncore/multimedia/opieplayer2/inputDialog.cpp
index c13ea63..9edb1d3 100644
--- a/noncore/multimedia/opieplayer2/inputDialog.cpp
+++ b/noncore/multimedia/opieplayer2/inputDialog.cpp
@@ -1,57 +1,61 @@
 #include "inputDialog.h"
 
 #include <qpe/resource.h>
 
 #include <opie/ofiledialog.h>
 
 #include <qlineedit.h>
 #include <qlayout.h>
 #include <qvariant.h>
 #include <qpushbutton.h>
 #include <qwhatsthis.h>
 
 InputDialog::InputDialog( QWidget* parent,  const char* name, bool modal, WFlags fl )
     : QDialog( parent, name, modal, fl ) {
     if ( !name ) {
         setName( "InputDialog" );
     }
     resize( 234, 115);
     setMaximumSize( QSize( 240, 40));
     setCaption( tr( name ) );
 
     QPushButton *browserButton;
     browserButton = new QPushButton( Resource::loadIconSet("fileopen"),"",this,"BrowseButton");
     browserButton->setGeometry( QRect( 205, 10, 22, 22));
     connect( browserButton, SIGNAL(released()),this,SLOT(browse()));
     LineEdit1 = new QLineEdit( this, "LineEdit1" );
     LineEdit1->setGeometry( QRect( 4, 10, 190, 22 ) );
 }
-
+/*
+ * return the current text(input)
+ */
+QString InputDialog::text() const {
+   return LineEdit1->text(); 
+}
 /*
  *  Destroys the object and frees any allocated resources
  */
 InputDialog::~InputDialog() {
-    inputText= LineEdit1->text();
 }
 
 void InputDialog::browse() {
 
     MimeTypes types;
     QStringList audio, video, all;
     audio << "audio/*";
     audio << "playlist/plain";
     audio << "audio/x-mpegurl";
 
     video << "video/*";
     video << "playlist/plain";
 
     all += audio;
     all += video;
     types.insert("All Media Files", all );
     types.insert("Audio",  audio );
     types.insert("Video", video );
 
     QString str = OFileDialog::getOpenFileName( 1,"/","", types, 0 );
     LineEdit1->setText(str);
 }
 
diff --git a/noncore/multimedia/opieplayer2/inputDialog.h b/noncore/multimedia/opieplayer2/inputDialog.h
index d4f5e12..0f36ea4 100644
--- a/noncore/multimedia/opieplayer2/inputDialog.h
+++ b/noncore/multimedia/opieplayer2/inputDialog.h
@@ -1,22 +1,25 @@
 
 #ifndef INPUTDIALOG_H
 #define INPUTDIALOG_H
 
 #include <qvariant.h>
 #include <qdialog.h>
 
 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;
+    QString text()const;
+    
+private:
     QLineEdit* LineEdit1;
+    
 protected slots:
     void browse();
 };
 
 #endif // INPUTDIALOG_H
diff --git a/noncore/multimedia/opieplayer2/mediaplayer.cpp b/noncore/multimedia/opieplayer2/mediaplayer.cpp
index 18caaad..0f8242b 100644
--- a/noncore/multimedia/opieplayer2/mediaplayer.cpp
+++ b/noncore/multimedia/opieplayer2/mediaplayer.cpp
@@ -1,295 +1,295 @@
 #include <qpe/qpeapplication.h>
 #include <qpe/qlibrary.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 #include <qpe/qcopenvelope_qws.h>
 
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <qwidgetstack.h>
 #include <qfile.h>
 
 #include "mediaplayer.h"
 #include "playlistwidget.h"
 #include "audiowidget.h"
 #include "videowidget.h"
 #include "volumecontrol.h"
 
 #include "mediaplayerstate.h"
 
 // for setBacklight()
 #include <linux/fb.h>
 #include <sys/file.h>
 #include <sys/ioctl.h>
 
 
 extern AudioWidget *audioUI;
 extern VideoWidget *videoUI;
 extern PlayListWidget *playList;
 extern MediaPlayerState *mediaPlayerState;
 
 
 #define FBIOBLANK             0x4611
 
 MediaPlayer::MediaPlayer( QObject *parent, const char *name )
     : QObject( parent, name ), volumeDirection( 0 ), currentFile( NULL ) {
 
     qApp->processEvents();
     //    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( mediaPlayerState, SIGNAL( blankToggled( bool ) ), this, SLOT ( blank( bool ) ) );
 
     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() ) );
 
     connect( videoUI,  SIGNAL( moreClicked() ), this, SLOT( startIncreasingVolume() ) );
     connect( videoUI,  SIGNAL( lessClicked() ),  this, SLOT( startDecreasingVolume() ) );
     connect( videoUI,  SIGNAL( moreReleased() ), this, SLOT( stopChangingVolume() ) );
     connect( videoUI,  SIGNAL( lessReleased() ), this, SLOT( stopChangingVolume() ) );
 
     volControl = new VolumeControl;
     xineControl = new XineControl();
 }
 
 MediaPlayer::~MediaPlayer() {
     delete xineControl;
     delete volControl;
 }
 
 void MediaPlayer::pauseCheck( bool b ) {
      if ( b && !mediaPlayerState->playing() ) {
          mediaPlayerState->setPaused( FALSE );
      }
 }
 
 void MediaPlayer::play() {
         mediaPlayerState->setPlaying( FALSE );
         mediaPlayerState->setPlaying( TRUE );
 }
 
 void MediaPlayer::setPlaying( bool play ) {
     if ( !play ) {
         return;
     }
 
      if ( mediaPlayerState->paused() ) {
          mediaPlayerState->setPaused( FALSE );
          return;
      }
 
     const DocLnk *playListCurrent = playList->current();
     if ( playListCurrent != NULL ) {
         currentFile = playListCurrent;
     }
 
     xineControl->play( currentFile->file() );
 
     long seconds =  mediaPlayerState->length();//
     QString time; time.sprintf("%li:%02i", seconds/60, (int)seconds%60 );
     qDebug(time);
 
     QString tickerText;
     if( currentFile->file().left(4) == "http" )
      tickerText= tr( " File: " ) + currentFile->name();
     else
     tickerText = tr( " File: " ) + currentFile->name() + tr(", Length: ") + time;
 
     audioUI->setTickerText( currentFile->file( ) );
 
 }
 
 
 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 );
     volControl->decVol(2);
 }
 
 
 void MediaPlayer::startIncreasingVolume() {
     volumeDirection = +1;
     startTimer( 100 );
     volControl->incVol(2);
 }
 
 
 bool drawnOnScreenDisplay = FALSE;
 unsigned int onScreenDisplayVolume = 0;
 const int yoff = 110;
 
 void MediaPlayer::stopChangingVolume() {
     killTimers();
     // Get rid of the on-screen display stuff
     drawnOnScreenDisplay = FALSE;
     onScreenDisplayVolume = 0;
     int w=0;
     int h=0;
     if( !xineControl->hasVideo()) {
         w = audioUI->width();
         h = audioUI->height();
         audioUI->repaint( (w - 200) / 2, h - yoff, 200 + 9, 70, FALSE );
     } else {
         w = videoUI->width();
         h = videoUI->height();
         videoUI->repaint( (w - 200) / 2, h - yoff, 200 + 9, 70, FALSE );
     }
 }
 
 
 void MediaPlayer::timerEvent( QTimerEvent * ) {
     if ( volumeDirection == +1 ) {
         volControl->incVol(2);
     }  else if ( volumeDirection == -1 ) {
         volControl->decVol(2);
     }
 
 
       // TODO FIXME
-    unsigned int v;
-    v = volControl->getVolume();
+    unsigned int v= 0;
+    v = volControl->volume();
     v = v / 10;
 
     if ( drawnOnScreenDisplay && onScreenDisplayVolume == v ) {
         return;
     }
 
     int w=0; int h=0;
     if( !xineControl->hasVideo()) {
         w = audioUI->width();
         h = audioUI->height();
 
         if ( drawnOnScreenDisplay ) {
             if ( onScreenDisplayVolume > v ) {
                 audioUI->repaint( (w - 200) / 2 + v * 20 + 0, h - yoff + 40, (onScreenDisplayVolume - v) * 20 + 9, 30, FALSE );
             }
         }
         drawnOnScreenDisplay = TRUE;
         onScreenDisplayVolume = v;
         QPainter p( audioUI );
         p.setPen( QColor( 0x10, 0xD0, 0x10 ) );
         p.setBrush( QColor( 0x10, 0xD0, 0x10 ) );
 
         QFont f;
         f.setPixelSize( 20 );
         f.setBold( TRUE );
         p.setFont( f );
         p.drawText( (w - 200) / 2, h - yoff + 20, tr("Volume") );
 
         for ( unsigned int i = 0; i < 10; i++ ) {
             if ( v > i ) {
                 p.drawRect( (w - 200) / 2 + i * 20 + 0, h - yoff + 40, 9, 30 );
             } else {
                 p.drawRect( (w - 200) / 2 + i * 20 + 3, h - yoff + 50, 3, 10 );
             }
         }
     } else {
         w = videoUI->width();
         h = videoUI->height();
 
         if ( drawnOnScreenDisplay ) {
             if ( onScreenDisplayVolume > v ) {
                 videoUI->repaint( (w - 200) / 2 + v * 20 + 0, h - yoff + 40, (onScreenDisplayVolume - v) * 20 + 9, 30, FALSE );
             }
         }
         drawnOnScreenDisplay = TRUE;
         onScreenDisplayVolume = v;
         QPainter p( videoUI );
         p.setPen( QColor( 0x10, 0xD0, 0x10 ) );
         p.setBrush( QColor( 0x10, 0xD0, 0x10 ) );
 
         QFont f;
         f.setPixelSize( 20 );
         f.setBold( TRUE );
         p.setFont( f );
         p.drawText( (w - 200) / 2, h - yoff + 20, tr("Volume") );
 
         for ( unsigned int i = 0; i < 10; i++ ) {
             if ( v > i ) {
                 p.drawRect( (w - 200) / 2 + i * 20 + 0, h - yoff + 40, 9, 30 );
             } else {
                 p.drawRect( (w - 200) / 2 + i * 20 + 3, h - yoff + 50, 3, 10 );
             }
         }
     }
 }
 
 
 void MediaPlayer::blank( bool b ) {
     fd=open("/dev/fb0",O_RDWR);
     if (fd != -1) {
         if ( b ) {
             qDebug("do blanking");
             ioctl( fd, FBIOBLANK, 3 );
             isBlanked = TRUE;
         } else {
             qDebug("do unblanking");
             ioctl( fd, FBIOBLANK, 0);
             isBlanked = FALSE;
         }
         close( fd );
     } else {
         qDebug("<< /dev/fb0 could not be opend  >>");
     }
 }
 
 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");
 //          mediaPlayerState->toggleBlank();
           break;
       case Key_F13: //mail
           qDebug("Blank here");
           //  mediaPlayerState->toggleBlank();
           break;
     }
 }
 
 void MediaPlayer::cleanUp() {
 //     QPEApplication::grabKeyboard();
 //     QPEApplication::ungrabKeyboard();
 }
diff --git a/noncore/multimedia/opieplayer2/mediaplayerstate.cpp b/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
index 8366ab4..eaedaa5 100644
--- a/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
+++ b/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
@@ -1,282 +1,282 @@
 #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 );
-
+    isStreaming = false;
 }
 
 
 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;
     isStreaming = 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::setBlanked( bool b ) {
     if ( isBlanked == b ) {
         return;
     }
     isBlanked = b;
     emit blankToggled(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 ) {
           isPaused = FALSE;
           emit pausedToggled(FALSE);
           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);
 }
 
 void MediaPlayerState::toggleBlank() {
     setBlanked( !isBlanked);
 }
 
 
 
diff --git a/noncore/multimedia/opieplayer2/playlistwidget.cpp b/noncore/multimedia/opieplayer2/playlistwidget.cpp
index 10f1792..251c2e5 100644
--- a/noncore/multimedia/opieplayer2/playlistwidget.cpp
+++ b/noncore/multimedia/opieplayer2/playlistwidget.cpp
@@ -80,1174 +80,1174 @@ 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;
 
   setBackgroundMode( PaletteButton );
 
   setCaption( tr("OpiePlayer") );
   setIcon( Resource::loadPixmap( "opieplayer2/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" ) );
 
   tbDeletePlaylist = new QPushButton( Resource::loadIconSet("trash"),"",bar,"close");
   tbDeletePlaylist->setFlat(TRUE);
   tbDeletePlaylist->setFixedSize(20,20);
 
   d->tbAddToList =  new ToolButton( bar, tr( "Add to Playlist" ), "opieplayer2/add_to_playlist",
                                     this , SLOT(addSelected()) );
   d->tbRemoveFromList = new ToolButton( bar, tr( "Remove from Playlist" ), "opieplayer2/remove_from_playlist",
                                         this , SLOT(removeSelected()) );
   d->tbPlay    = new ToolButton( bar, tr( "Play" ), "opieplayer2/play",
                                  this , SLOT( btnPlay(bool) ), TRUE );
   d->tbShuffle = new ToolButton( bar, tr( "Randomize" ),"opieplayer2/shuffle",
                                  mediaPlayerState, SLOT(setShuffled(bool)), TRUE );
   d->tbLoop    = new ToolButton( bar, tr( "Loop" ),"opieplayer2/loop",
                                  mediaPlayerState, SLOT(setLooping(bool)), TRUE );
   tbDeletePlaylist->hide();
 
   QPopupMenu *pmPlayList = new QPopupMenu( this );
   menu->insertItem( tr( "File" ), pmPlayList );
   (void)new MenuItem( pmPlayList, tr( "Clear List" ), this, SLOT( clearList() ) );
   (void)new MenuItem( pmPlayList, tr( "Add all audio files" ), this, SLOT( addAllMusicToList() ) );
   (void)new MenuItem( pmPlayList, tr( "Add all video files" ), this, SLOT( addAllVideoToList() ) );
   (void)new MenuItem( pmPlayList, tr( "Add all files" ), this, SLOT( addAllToList() ) );
   pmPlayList->insertSeparator(-1);
   (void)new MenuItem( pmPlayList, tr( "Save PlayList" ), this, SLOT( saveList() ) );
   (void)new MenuItem( pmPlayList, tr( "Export playlist to m3u" ), this, SLOT(writem3u() ) );
   pmPlayList->insertSeparator(-1);
   (void)new MenuItem( pmPlayList, tr( "Open File or URL" ), this,SLOT( openFile() ) );
   pmPlayList->insertSeparator(-1);
   (void)new MenuItem( pmPlayList, tr( "Rescan for Audio Files" ), this,SLOT( scanForAudio() ) );
   (void)new MenuItem( pmPlayList, tr( "Rescan for Video Files" ), this,SLOT( scanForVideo() ) );
 
   pmView = new QPopupMenu( this );
   menu->insertItem( tr( "View" ), pmView );
   pmView->isCheckable();
 
   pmView->insertItem(  Resource::loadPixmap("fullscreen") , tr( "Full Screen"), mediaPlayerState, SLOT( toggleFullscreen() ) );
 
   Config cfg( "OpiePlayer" );
   bool b= cfg.readBoolEntry("FullScreen", 0);
   mediaPlayerState->setFullscreen(  b );
   pmView->setItemChecked( -16, b );
 
   //    pmView->insertItem(  Resource::loadPixmap("opieplayer/scale") , tr( "Scale"), mediaPlayerState, SLOT(toggleScaled() ) );
 
   pmView->insertSeparator(-1);
 
   skinsMenu = new QPopupMenu( this );
   pmView->insertItem( tr( "Skins" ), skinsMenu );
   skinsMenu->isCheckable();
   populateSkinsMenu();
 
   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" );
   tabWidget->insertTab( pTab,"Playlist");
 
 
   QGridLayout *Playout = new QGridLayout( pTab );
   Playout->setSpacing( 2);
   Playout->setMargin( 2);
 
   // Add the playlist area
 
   QVBox *vbox3 = new QVBox( pTab ); vbox3->setBackgroundMode( PaletteButton );
   d->playListFrame = vbox3;
 
   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);
 
   QVBox *stretch1 = new QVBox( vbox1 ); stretch1->setBackgroundMode( PaletteButton ); // add stretch
   (void)new ToolButton( vbox1, tr( "Move Up" ),   "opieplayer2/up",   d->selectedFiles, SLOT(moveSelectedUp()) );
   (void)new ToolButton( vbox1, tr( "Remove" ),    "opieplayer2/cut",  d->selectedFiles, SLOT(removeSelected()) );
   (void)new ToolButton( vbox1, tr( "Move Down" ), "opieplayer2/down", d->selectedFiles, SLOT(moveSelectedDown()) );
   QVBox *stretch2 = new QVBox( vbox1 ); stretch2->setBackgroundMode( PaletteButton ); // add stretch
 
 
   Playout->addMultiCellWidget( vbox3, 0, 0, 0, 1 );
 
   QWidget *aTab;
   aTab = new QWidget( tabWidget, "aTab" );
 
   QGridLayout *Alayout = new QGridLayout( aTab );
   Alayout->setSpacing( 2);
   Alayout->setMargin( 2);
 
   audioView = new QListView( aTab, "Audioview" );
   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->setSorting(0,TRUE);
 
   audioView->setMultiSelection( TRUE );
   audioView->setSelectionMode( QListView::Extended);
 
   Alayout->addMultiCellWidget( audioView, 0, 0, 0, 1 );
 
   tabWidget->insertTab(aTab,tr("Audio"));
 
   QPEApplication::setStylusOperation( audioView->viewport(),QPEApplication::RightOnHold);
 
   QWidget *vTab;
   vTab = new QWidget( tabWidget, "vTab" );
 
   QGridLayout *Vlayout = new QGridLayout( vTab );
   Vlayout->setSpacing( 2);
   Vlayout->setMargin( 2);
 
   videoView = new QListView( vTab, "Videoview" );
 
   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->setSorting(0,TRUE);
 
   videoView->setMultiSelection( TRUE );
   videoView->setSelectionMode( QListView::Extended);
 
   Vlayout->addMultiCellWidget( videoView, 0, 0, 0, 1 );
 
   QPEApplication::setStylusOperation( videoView->viewport(),QPEApplication::RightOnHold);
 
   tabWidget->insertTab( vTab,tr("Video"));
 
   //playlists list
   QWidget *LTab;
   LTab = new QWidget( tabWidget, "LTab" );
   QGridLayout *Llayout = new QGridLayout( LTab );
   Llayout->setSpacing( 2);
   Llayout->setMargin( 2);
 
   playLists = new FileSelector( "playlist/plain", LTab, "fileselector" , FALSE, FALSE); //buggy
   Llayout->addMultiCellWidget( playLists, 0, 0, 0, 1 );
 
   tabWidget->insertTab(LTab,tr("Lists"));
 
   connect(tbDeletePlaylist,(SIGNAL(released())),SLOT( deletePlaylist()));
 
   connect( pmView, SIGNAL( activated(int)), this, SLOT( pmViewActivated(int) ) );
 
   connect( skinsMenu, SIGNAL( activated(int)), this, SLOT(skinsMenuActivated(int) ) );
 
   //    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 *) ) );
 
   setCentralWidget( vbox5 );
 
   readConfig( cfg );
   QString currentPlaylist = cfg.readEntry("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() );
   setPlaylist( true);
 }
 
 
 void PlayListWidget::readConfig( Config& cfg ) {
   cfg.setGroup("PlayList");
   QString currentString = cfg.readEntry("current", "" );
   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 );
     if(QFileInfo( linkFile).exists() ) {
       DocLnk lnk( linkFile );
       if ( QFileInfo( lnk.file()).exists() || linkFile.find("http",0,TRUE) != -1) {
         d->selectedFiles->addToSelection( lnk );
       }
     }
   }
   d->selectedFiles->setSelectedItem( currentString);
 }
 
 
 void PlayListWidget::writeConfig( Config& cfg ) const {
 
   d->selectedFiles->writeCurrent( cfg);
   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++;
     }
   }
   while ( d->selectedFiles->next() );
   cfg.writeEntry("NumberOfFiles", noOfFiles );
 }
 
 
 void PlayListWidget::addToSelection( const DocLnk& lnk ) {
   d->setDocumentUsed = FALSE;
   if ( mediaPlayerState->playlist() ) {
     if(QFileInfo(lnk.file()).exists() || lnk.file().left(4) == "http" )
       d->selectedFiles->addToSelection( lnk );
   }
   else
     mediaPlayerState->setPlaying( TRUE );
 }
 
 
 void PlayListWidget::clearList() {
   while ( first() ) {
     d->selectedFiles->removeSelected();
   }
 }
 
 
 void PlayListWidget::addAllToList() {
   DocLnkSet filesAll;
   Global::findDocuments(&filesAll, "video/*;audio/*");
   QListIterator<DocLnk> Adit( filesAll.children() );
   for ( ; Adit.current(); ++Adit ) {
     if(QFileInfo(Adit.current()->file()).exists()) {
       d->selectedFiles->addToSelection( **Adit );
     }
   }
 }
 
 
 void PlayListWidget::addAllMusicToList() {
   QListIterator<DocLnk> dit( files.children() );
   for ( ; dit.current(); ++dit ) {
     if(QFileInfo(dit.current()->file()).exists()) {
       d->selectedFiles->addToSelection( **dit );
     }
   }
 }
 
 
 void PlayListWidget::addAllVideoToList() {
   QListIterator<DocLnk> dit( vFiles.children() );
   for ( ; dit.current(); ++dit )
     if(QFileInfo( dit.current()->file()).exists())
       d->selectedFiles->addToSelection( **dit );
 }
 
 
 void PlayListWidget::setDocument(const QString& fileref) {
   qDebug(fileref);
   fromSetDocument = TRUE;
   if ( fileref.isNull() ) {
     QMessageBox::critical( 0, tr( "Invalid File" ), tr( "There was a problem in getting the file." ) );
     return;
   }
 
   if(fileref.find("m3u",0,TRUE) != -1) { //is m3u
     readm3u( fileref);
   } else if(fileref.find("pls",0,TRUE) != -1) { //is pls
     readPls( fileref);
   } else if(fileref.find("playlist",0,TRUE) != -1) {//is playlist
     clearList();
     loadList(DocLnk(fileref));
     d->selectedFiles->first();
   } else {
     clearList();
     addToSelection( DocLnk( fileref ) );
     d->setDocumentUsed = TRUE;
     mediaPlayerState->setPlaying( FALSE );
     qApp->processEvents();
     mediaPlayerState->setPlaying( TRUE );
     qApp->processEvents();
     setCaption(tr("OpiePlayer"));
   }
 }
 
 
 void PlayListWidget::setActiveWindow() {
   qDebug("SETTING active window");
   // 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() { // this is fugly
 
   switch (tabWidget->currentPageIndex()) {
   case 0: //playlist
     {
       qDebug("playlist");
       if ( mediaPlayerState->playlist() ) {
         return d->selectedFiles->current();
       } else if ( d->setDocumentUsed && d->current ) {
         return d->current;
       } else {
         return d->files->selected();
       }
     }
     break;
   case 1://audio
     {
       qDebug("audioView");
       QListIterator<DocLnk> dit( files.children() );
       for ( ; dit.current(); ++dit ) {
         if( dit.current()->name() == audioView->currentItem()->text(0) && !insanityBool) {
           qDebug("here");
           insanityBool=TRUE;
           return dit;
         }
       }
     }
     break;
   case 2: // video
     {
       qDebug("videoView");
       QListIterator<DocLnk> Vdit( vFiles.children() );
       for ( ; Vdit.current(); ++Vdit ) {
         if( Vdit.current()->name() == videoView->currentItem()->text(0) && !insanityBool) {
           insanityBool=TRUE;
           return Vdit;
         }
       }
     }
     break;
   };
   return 0;
 }
 
 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;
   InputDialog *fileDlg = 0l;
   fileDlg = new InputDialog(this,tr("Save Playlist"),TRUE, 0);
   fileDlg->exec();
   if( fileDlg->result() == 1 ) {
     if ( d->current )
       delete d->current;
-    filename = fileDlg->LineEdit1->text();//+".playlist";
+    filename = fileDlg->text();//+".playlist";
     //         qDebug("saving playlist "+filename+".playlist");
     Config cfg( filename +".playlist");
     writeConfig( cfg );
 
     DocLnk lnk;
     lnk.setFile(QDir::homeDirPath()+"/Settings/"+filename+".playlist.conf"); //sets File property
     lnk.setType("playlist/plain");// hey is this a REGISTERED mime type?!?!? ;D
     lnk.setIcon("opieplayer2/playlist2");
     lnk.setName( filename); //sets file name
     // qDebug(filename);
     if(!lnk.writeLink()) {
       qDebug("Writing doclink did not work");
     }
   }
   Config config( "OpiePlayer" );
   config.writeEntry("CurrentPlaylist",filename);
   setCaption(tr("OpiePlayer: ")+filename);
   d->selectedFiles->first();
   if(fileDlg) {
     delete fileDlg;
   }
 }
 
 void PlayListWidget::loadList( const DocLnk & lnk) {
   QString name= lnk.name();
   // qDebug("currentList is "+name);
   if( name.length()>1) {
     setCaption("OpiePlayer: "+name);
     // qDebug("load list "+ name+".playlist");
     clearList();
     Config cfg( name+".playlist");
     readConfig(cfg);
 
     tabWidget->setCurrentPage(0);
 
     Config config( "OpiePlayer" );
     config.writeEntry("CurrentPlaylist", name);
     //        d->selectedFiles->first();
   }
 
 }
 
 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() {
 
   Config cfg( "OpiePlayer" );
   cfg.setGroup("PlayList");
   QString currentPlaylist = cfg.readEntry("CurrentPlaylist","");
   //    int noOfFiles = cfg.readNumEntry("NumberOfFiles", 0 );
 
   switch (tabWidget->currentPageIndex()) {
   case 0: //playlist
     break;
   case 1: { //audio
     QListViewItemIterator it(  audioView  );
     // iterate through all items of the listview
     for ( ; it.current(); ++it ) {
       if ( it.current()->isSelected() ) {
         QListIterator<DocLnk> dit( files.children() );
         for ( ; dit.current(); ++dit ) {
           if( dit.current()->name() == it.current()->text(0) ) {
             if(QFileInfo( dit.current()->file()).exists())
               d->selectedFiles->addToSelection(  **dit );
           }
         }
         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) ) {
             if(QFileInfo( dit.current()->file()).exists())
               d->selectedFiles->addToSelection(  **dit );
           }
         }
         videoView->setSelected( it.current(),FALSE);
       }
     }
     tabWidget->setCurrentPage(0);
   }
     break;
   };
 }
 
 void PlayListWidget::removeSelected() {
   d->selectedFiles->removeSelected( );
 }
 
 void PlayListWidget::playIt( QListViewItem *it) {
   if(!it) return;
   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)) {
           if(QFileInfo( dit.current()->file()).exists())
             d->selectedFiles->addToSelection(  **dit );
         }
       }
     }
       break;
     case 2: {
       QListIterator<DocLnk> dit( vFiles.children() );
       for ( ; dit.current(); ++dit ) {
         if( dit.current()->name() == it->text(0)) {
           if(QFileInfo( dit.current()->file()).exists())
             d->selectedFiles->addToSelection(  **dit );
         }
       }
     }
       break;
     case 0:
       break;
     };
     tabWidget->setCurrentPage(0);
   }
 }
 
 void PlayListWidget::tabChanged(QWidget *) {
 
   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 *, const QPoint& , int) {
   switch (mouse) {
   case 1:
     break;
   case 2:{
     QPopupMenu  m;
     m.insertItem( tr( "Play" ), this, SLOT( playSelected() ));
     m.insertItem( tr( "Add to Playlist" ), this, SLOT( addSelected() ));
     m.exec( QCursor::pos() );
   }
     break;
   };
 }
 
 void PlayListWidget::playSelected() {
   btnPlay( TRUE);
 }
 
 void PlayListWidget::playlistViewPressed( int mouse, QListViewItem *, const QPoint& , int ) {
   switch (mouse) {
   case 1:
 
     break;
   case 2:
     {
       QPopupMenu  m;
       m.insertItem( tr( "Play Selected" ), this, SLOT( playSelected() ));
       m.insertItem( tr( "Remove" ), this, SLOT( removeSelected() ));
       m.exec( QCursor::pos() );
     }
     break;
   };
 }
 
 
 void PlayListWidget::scanForAudio() {
   qDebug("scan for audio");
   files.detachChildren();
   QListIterator<DocLnk> sdit( files.children() );
   for ( ; sdit.current(); ++sdit ) {
     delete sdit.current();
   }
   Global::findDocuments(&files, "audio/*");
   audioScan = TRUE;
 }
 
 void PlayListWidget::scanForVideo() {
   qDebug("scan for video");
   vFiles.detachChildren();
   QListIterator<DocLnk> sdit( vFiles.children() );
   for ( ; sdit.current(); ++sdit ) {
     delete sdit.current();
   }
   Global::findDocuments(&vFiles, "video/*");
   videoScan = TRUE;
 }
 
 void PlayListWidget::populateAudioView() {
 
   audioView->clear();
   StorageInfo storageInfo;
   const QList<FileSystem> &fs = storageInfo.fileSystems();
   if(!audioScan) scanForAudio();
 
   QListIterator<DocLnk> dit( files.children() );
   QListIterator<FileSystem> it ( fs );
 
   QString storage;
   for ( ; dit.current(); ++dit ) {
     for( ; it.current(); ++it ){
       const QString name = (*it)->name();
       const QString path = (*it)->path();
       if(dit.current()->file().find(path) != -1 ) storage=name;
     }
 
     QListViewItem * newItem;
     if ( QFile( dit.current()->file()).exists()  ) {
       // qDebug(dit.current()->name());
       newItem= /*(void)*/ new QListViewItem( audioView, dit.current()->name(),
                                              QString::number( QFile( dit.current()->file()).size() ), storage);
       newItem->setPixmap(0, Resource::loadPixmap( "opieplayer2/musicfile" ));
     }
   }
 
 }
 
 void PlayListWidget::populateVideoView() {
   videoView->clear();
   StorageInfo storageInfo;
   const QList<FileSystem> &fs = storageInfo.fileSystems();
 
   if(!videoScan ) scanForVideo();
 
   QListIterator<DocLnk> Vdit( vFiles.children() );
   QListIterator<FileSystem> it ( fs );
   videoView->clear();
   QString storage;
   for ( ; Vdit.current(); ++Vdit ) {
     for( ; it.current(); ++it ){
       const QString name = (*it)->name();
       const QString path = (*it)->path();
       if( Vdit.current()->file().find(path) != -1 ) storage=name;
     }
 
     QListViewItem * newItem;
     if ( QFile( Vdit.current()->file()).exists() ) {
       newItem= /*(void)*/ new QListViewItem( videoView, Vdit.current()->name(),
                                              QString::number( QFile( Vdit.current()->file()).size() ), storage);
       newItem->setPixmap(0, Resource::loadPixmap( "opieplayer2/videofile" ));
     }
   }
 }
 
 void PlayListWidget::openFile() {
   QString filename, name;
   InputDialog *fileDlg;
   fileDlg = new InputDialog(this,tr("Open file or URL"),TRUE, 0);
   fileDlg->exec();
   if( fileDlg->result() == 1 ) {
-    filename = fileDlg->LineEdit1->text();
+    filename = fileDlg->text();
 
     qDebug("Selected filename is "+filename);
     if(filename.right(3) == "m3u") {
       readm3u( filename );
     } else if(filename.right(3) == "pls") {
       readPls( filename );
     } else {
       DocLnk lnk;
 
       lnk.setName(filename); //sets file name
       lnk.setFile(filename); //sets File property
       lnk.setType("audio/x-mpegurl");
       lnk.setExec("opieplayer");
       lnk.setIcon("opieplayer2/MPEGPlayer");
 
       if(!lnk.writeLink()) {
         qDebug("Writing doclink did not work");
       }
       d->selectedFiles->addToSelection(  lnk);
     }
   }
   if(fileDlg) {
     delete fileDlg;
   }
 }
 
 void PlayListWidget::keyReleaseEvent( QKeyEvent *e)
 {
   switch ( e->key() ) {
     ////////////////////////////// Zaurus keys
   case Key_F9: //activity
     //           if(audioUI->isHidden())
     //             audioUI->showMaximized();
     break;
   case Key_F10: //contacts
     //           if( videoUI->isHidden())
     //             videoUI->showMaximized();
     break;
   case Key_F11: //menu
     break;
   case Key_F12: //home
     //          doBlank();
     break;
   case Key_F13: //mail
     //           doUnblank();
     break;
   case Key_Q: //add to playlist
     qDebug("Add");
     addSelected();
     break;
   case Key_R: //remove from playlist
     removeSelected();
     break;
     //       case Key_P: //play
     //           qDebug("Play");
     //           playSelected();
     //           break;
   case Key_Space:
     qDebug("Play");
     //          playSelected(); puh
     break;
   case Key_1:
     tabWidget->setCurrentPage(0);
     break;
   case Key_2:
     tabWidget->setCurrentPage(1);
     break;
   case Key_3:
     tabWidget->setCurrentPage(2);
     break;
   case Key_4:
     tabWidget->setCurrentPage(3);
     break;
   case Key_Down:
     if ( !d->selectedFiles->next() )
       d->selectedFiles->first();
 
     break;
   case Key_Up:
     if ( !d->selectedFiles->prev() )
       //        d->selectedFiles->last();
 
       break;
 
   }
 }
 
 void PlayListWidget::keyPressEvent( QKeyEvent *)
 {
   //    qDebug("Key press");
   //     switch ( e->key() ) {
   // ////////////////////////////// Zaurus keys
   //       case Key_A: //add to playlist
   //           qDebug("Add");
   //           addSelected();
   //           break;
   //       case Key_R: //remove from playlist
   //           removeSelected();
   //           break;
   //       case Key_P: //play
   //           qDebug("Play");
   //           playSelected();
   //           break;
   //       case Key_Space:
   //           qDebug("Play");
   //           playSelected();
   //           break;
   //     }
 }
 
 
 
 void PlayListWidget::readm3u(const QString &filename) {
 
   qDebug("m3u filename is "+filename);
   QFile f(filename);
 
   if(f.open(IO_ReadOnly)) {
     QTextStream t(&f);
     QString s;//, first, second;
     int i=0;
     while ( !t.atEnd()) {
       s=t.readLine();
 
       if(s.find("#",0,TRUE) == -1) {
         if(s.find(" ",0,TRUE) == -1)  { // not sure if this is neede since cf uses vfat
           if(s.left(2) == "E:" || s.left(2) == "P:") {
             s=s.right(s.length()-2);
             //                         if(QFile(s).exists()) {
             DocLnk lnk( s );
             QFileInfo f(s);
             QString name = f.baseName();
             name = name.right( name.length()-name.findRev( "\\",-1,TRUE ) -1 );
             lnk.setName( name );
             s=s.replace( QRegExp("\\"),"/");
             lnk.setFile( s );
             lnk.writeLink();
             qDebug("add "+name);
             d->selectedFiles->addToSelection( lnk);
             //                         }
           } else { // is url
             s.replace(QRegExp("%20")," ");
             DocLnk lnk( s );
             QString name;
             if(name.left(4)=="http") {
               name = s.right( s.length() - 7);
             } else {
               name = s;
             }
             lnk.setName(name);
             if(s.at(s.length()-4) == '.') {
               lnk.setFile( s);
             } else {
               lnk.setFile( s+"/");
             }
             lnk.setType("audio/x-mpegurl");
             lnk.writeLink();
             d->selectedFiles->addToSelection( lnk);
           }
           i++;
         }
       }
     }
   }
   f.close();
 }
 
 void PlayListWidget::writem3u() {
 
   InputDialog *fileDlg;
   fileDlg = new InputDialog(this,tr("Save m3u Playlist "),TRUE, 0);
   fileDlg->exec();
   QString filename,list;
   if( fileDlg->result() == 1 ) {
-    filename = fileDlg->LineEdit1->text();
+    filename = fileDlg->text();
     qDebug(filename);
     int noOfFiles = 0;
     d->selectedFiles->first();
     do {
       // we dont check for existance because of url's
       //         qDebug(d->selectedFiles->current()->file());
       list += d->selectedFiles->current()->file()+"\n";
       noOfFiles++;
     }
     while ( d->selectedFiles->next() );
     qDebug(list);
     if(filename.left(1) != "/")
       filename=QPEApplication::documentDir()+"/"+filename;
     if(filename.right(3) != "m3u")
       filename=filename+".m3u";
 
     QFile f(filename);
     f.open(IO_WriteOnly);
     f.writeBlock(list, list.length());
     f.close();
   }
   if(fileDlg) delete fileDlg;
 }
 
 void PlayListWidget::readPls(const QString &filename) {
 
   qDebug("pls filename is "+filename);
   QFile f(filename);
 
   if(f.open(IO_ReadOnly)) {
     QTextStream t(&f);
     QString s;//, first, second;
     int i=0;
     while ( !t.atEnd()) {
       s=t.readLine();
       if(s.left(4) == "File") {
         s=s.right(s.length() - 6);
         s.replace(QRegExp("%20")," ");
         qDebug("adding "+s+" to playlist");
         // numberofentries=2
         // File1=http
         // Title
         // Length
         // Version
         // File2=http
         s=s.replace( QRegExp("\\"),"/");
         DocLnk lnk( s );
         QFileInfo f(s);
         QString name = f.baseName();
         if(name.left(4)=="http")
           name = s.right( s.length() - 7);
         else
           name=s;
         name = name.right(name.length()-name.findRev("\\",-1,TRUE)-1);
         lnk.setName( name);
         if(s.at(s.length()-4) == '.') // if this is probably a file
           lnk.setFile( s);
         else { //if its a url
           if( name.right(1).find('/') == -1)
             s+="/";
           lnk.setFile( s);
         }
         lnk.setType("audio/x-mpegurl");
 
         qDebug("DocLnk add "+name);
         d->selectedFiles->addToSelection( lnk);
       }
     }
     i++;
   }
 }
 
 void PlayListWidget::pmViewActivated(int index) {
   qDebug("%d", index);
   switch(index) {
   case -16:
     {
 
       mediaPlayerState->toggleFullscreen();
       bool b=mediaPlayerState->fullscreen();
       pmView->setItemChecked( index,b);
       Config cfg( "OpiePlayer" );
       cfg.writeEntry("FullScreen", b);
 
     }
     break;
   };
 }
 
 void PlayListWidget::populateSkinsMenu() {
   int item=0;
   defaultSkinIndex=0;
   QString skinName;
   Config cfg( "OpiePlayer" );
   cfg.setGroup("Options");
   QString skin = cfg.readEntry("Skin","default");
 
   QDir skinsDir(QPEApplication::qpeDir()+"/pics/opieplayer2/skins");
   skinsDir.setFilter( QDir::Dirs);
   skinsDir.setSorting(QDir::Name);
   const QFileInfoList *skinslist = skinsDir.entryInfoList();
   QFileInfoListIterator it( *skinslist );
   QFileInfo *fi;
   while ( (fi=it.current()) ) {
     skinName =  fi->fileName();
     qDebug(  fi->fileName());
     if( skinName != "." &&  skinName != ".." && skinName !="CVS")
       item = skinsMenu->insertItem( fi->fileName());
     if( skinName == "default")
       defaultSkinIndex = item;
     if( skinName == skin)
       skinsMenu->setItemChecked( item, TRUE);
 
     ++it;
   }
 }
 
 void PlayListWidget::skinsMenuActivated(int item) {
   for(int i = defaultSkinIndex; i > defaultSkinIndex - skinsMenu->count(); i--) {
     skinsMenu->setItemChecked( i, FALSE);
   }
   skinsMenu->setItemChecked( item, TRUE);
 
   Config cfg( "OpiePlayer" );
   cfg.setGroup("Options");
   cfg.writeEntry("Skin", skinsMenu->text( item));
 }
diff --git a/noncore/multimedia/opieplayer2/volumecontrol.cpp b/noncore/multimedia/opieplayer2/volumecontrol.cpp
index a795f3b..271b84e 100644
--- a/noncore/multimedia/opieplayer2/volumecontrol.cpp
+++ b/noncore/multimedia/opieplayer2/volumecontrol.cpp
@@ -1,62 +1,61 @@
 
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 #include "qpe/qcopenvelope_qws.h"
 #include <qmessagebox.h>
 
 #include "volumecontrol.h"
 
-int VolumeControl::getVolume() {
-    int volumePerc;
+int VolumeControl::volume() {
     Config cfg( "qpe" );
     cfg. setGroup( "Volume" );
-    volumePerc = cfg. readNumEntry( "VolumePercent", 50 );
-    m_volumePerc = volumePerc;
-    return volumePerc;
+    m_volumePerc = cfg. readNumEntry( "VolumePercent", 50 );
+    
+    return m_volumePerc;
 }
 
 
 void VolumeControl::setVolume( int volumePerc ) {
      Config cfg("qpe");
     cfg.setGroup("Volume");
 
     if ( volumePerc > 100 ) {
         volumePerc = 100;
     }
     if ( volumePerc < 0 ) {
         volumePerc = 0;
     }
 
     m_volumePerc = volumePerc;
     cfg.writeEntry("VolumePercent", volumePerc );
     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << false;
 //    QCopEnvelope( "QPE/System", "setVolume(int,int)" ) << 0, volumePerc;
 }
 
 
 void VolumeControl::incVol( int ammount ) {
-    int oldVol = getVolume();
+    int oldVol = volume();
     setVolume( oldVol + ammount);
 }
 
 void VolumeControl::decVol( int ammount ) {
-     int oldVol = getVolume();
+     int oldVol = volume();
     setVolume( oldVol - ammount);
 }
 
 
 VolumeControl::VolumeControl( ) {
-    getVolume();
+    volume();
 }
 
 VolumeControl::~VolumeControl() {
     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << false;
 }
 
 void VolumeControl::setMute(bool on) {
    QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << on;
 }
 
 
 
 
diff --git a/noncore/multimedia/opieplayer2/volumecontrol.h b/noncore/multimedia/opieplayer2/volumecontrol.h
index d0d34a2..040f978 100644
--- a/noncore/multimedia/opieplayer2/volumecontrol.h
+++ b/noncore/multimedia/opieplayer2/volumecontrol.h
@@ -1,48 +1,48 @@
 /*************
  * this is only a quick hack and will be later replaced by osound
  *
  **********/
 
 
 #ifndef VOLUMECONTROL_H
 #define VOLUMECONTROL_H
 
 
 
 #include <qobject.h>
 
 class VolumeControl : public QObject {
     Q_OBJECT
 public:
     VolumeControl();
     ~VolumeControl();
 
     // increase by "ammount"
     void incVol( int ammount );
     void decVol( int ammount );
 
     /**
      * Get the volume in percent
      * @return volume percentage
      */
-    int getVolume();
+    int volume();
 
 public slots:
 
     /**
      * Set the volume in percent
      * @value volumePerc between 0 and 100
      */
     void setVolume( int volumePerc );
 
     void setMute(bool); 
 
 
 private:
 
     int m_volumePerc;
 
 };
 
 #endif
 
diff --git a/noncore/multimedia/opieplayer2/xinecontrol.cpp b/noncore/multimedia/opieplayer2/xinecontrol.cpp
index 766ece2..12d80ba 100644
--- a/noncore/multimedia/opieplayer2/xinecontrol.cpp
+++ b/noncore/multimedia/opieplayer2/xinecontrol.cpp
@@ -1,200 +1,202 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 #include <qtimer.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/qpeapplication.h>
 #include "xinecontrol.h"
 #include "mediaplayerstate.h"
 #include "videowidget.h"
 
 extern MediaPlayerState *mediaPlayerState;
 extern VideoWidget *videoUI;
 XineControl::XineControl( QObject *parent, const char *name )
     : QObject( parent, name ) {
     libXine = new XINE::Lib(videoUI->vidWidget() );
 
     connect ( videoUI, SIGNAL( videoResized ( const QSize & )), this, SLOT( videoResized ( const QSize & )));
     connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( pause(bool) ) );
     connect( this, SIGNAL( positionChanged( long ) ), mediaPlayerState, SLOT( updatePosition( long ) ) );
     connect( mediaPlayerState, SIGNAL( playingToggled( bool ) ), this, SLOT( stop( bool ) ) );
     connect( mediaPlayerState, SIGNAL( fullscreenToggled( bool ) ), this, SLOT( setFullscreen( bool ) ) );
     connect( mediaPlayerState, SIGNAL( positionChanged( long ) ),  this,  SLOT( seekTo( long ) ) );
     connect( libXine, SIGNAL( stopped() ),  this, SLOT( nextMedia() ) );
 
     disabledSuspendScreenSaver = FALSE;
 }
 
 XineControl::~XineControl() {
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     if ( disabledSuspendScreenSaver ) {
         disabledSuspendScreenSaver = FALSE;
         // Re-enable the suspend mode
         QCopEnvelope("QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
     }
 #endif
     delete libXine;
 }
 
 void XineControl::play( const QString& fileName ) {
     hasVideoChannel=FALSE;
     hasAudioChannel=FALSE;
     m_fileName = fileName;
+    
     qDebug("<<FILENAME: " + fileName  + ">>>>");
+    
     libXine->play( fileName );
     mediaPlayerState->setPlaying( true );
     // default to audio view until we know how to handle video
     //   MediaDetect mdetect;
     char whichGui = mdetect.videoOrAudio( fileName );
     if (whichGui == 'f') {
         qDebug("Nicht erkannter Dateityp");
         return;
     }
 
     if (whichGui == 'a') {
         libXine->setShowVideo( false );
         hasAudioChannel=TRUE;
     } else {
         libXine->setShowVideo( true );
         hasVideoChannel=TRUE;
     }
 
     // determine if slider is shown
     mediaPlayerState->setIsStreaming( !libXine->isSeekable() );
     // which gui (video / audio)
     mediaPlayerState->setView( whichGui );
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     if ( !disabledSuspendScreenSaver ) {
         disabledSuspendScreenSaver = TRUE;
         // Stop the screen from blanking and power saving state
         QCopEnvelope("QPE/System", "setScreenSaverMode(int)" )
             << ( whichGui == 'v' ? QPEApplication::Disable : QPEApplication::DisableSuspend );
     }
 #endif
 
     length();
     position();
 }
 
 void XineControl::nextMedia() {
     mediaPlayerState->setNext();
 }
 
 void XineControl::stop( bool isSet ) {
     if ( !isSet) {
         libXine->stop( );
         mediaPlayerState->setList();
         //        mediaPlayerState->setPlaying( false );
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
         if ( disabledSuspendScreenSaver ) {
             disabledSuspendScreenSaver = FALSE;
             // Re-enable the suspend mode
             QCopEnvelope("QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
         }
 #endif
 
     } else {
         // play again
     }
 }
 
 /**
  * Pause playback
  * @isSet
  */
 void XineControl::pause( bool isSet) {
     if (isSet) {
         libXine->pause();
     } else {
         libXine->play( m_fileName, 0, m_currentTime);
     }
 }
 
 
 /**
  * get current time in playback
  */
 long XineControl::currentTime() {
     // todo: jede sekunde überprüfen
     m_currentTime =  libXine->currentTime();
     return m_currentTime;
     QTimer::singleShot( 1000, this, SLOT( currentTime() ) );
 }
 
 /**
  * Set the length of the media file
  */
 void  XineControl::length() {
     m_length = libXine->length();
     mediaPlayerState->setLength( m_length );
 }
 
 
 /**
  * Reports the position the xine backend is at right now
  * @return long the postion in seconds
  */
 long XineControl::position() {
     m_position = ( currentTime()  );
     mediaPlayerState->updatePosition( m_position  );
     long emitPos = (long)m_position;
     emit positionChanged( emitPos );
     if(mediaPlayerState->isPlaying)
     // needs to be stopped the media is stopped
     QTimer::singleShot( 1000, this, SLOT( position() ) );
 //    qDebug("POSITION : %d", m_position);
     return m_position;
 }
 
 /**
  * Set videoplayback to fullscreen
  * @param isSet
  */
 void XineControl::setFullscreen( bool isSet ) {
     libXine->showVideoFullScreen( isSet);
 }
 
 /**
  * Seek to a position in the track
  * @param second the second to jump to
  */
 void XineControl::seekTo( long second ) {
     libXine->play( m_fileName , 0, (int)second );
 }
 
 void XineControl::videoResized ( const QSize &s ) {
   libXine-> resize ( s );
 }
diff --git a/noncore/multimedia/opieplayer2/xinecontrol.h b/noncore/multimedia/opieplayer2/xinecontrol.h
index 88458be..4263b36 100644
--- a/noncore/multimedia/opieplayer2/xinecontrol.h
+++ b/noncore/multimedia/opieplayer2/xinecontrol.h
@@ -1,79 +1,79 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef XINECONTROL_H
 #define XINECONTROL_H
 
 #include "lib.h"
 #include "mediadetect.h"
 #include <qobject.h>
 
 class XineControl : public QObject  {
     Q_OBJECT
 public:
     XineControl( QObject *parent = 0, const char *name =0 );
     ~XineControl();
-    int m_length;
 
     bool hasVideo() const { return hasVideoChannel; }
     bool hasAudio() const { return hasAudioChannel; }
 
 public slots:
     void play( const QString& fileName );
     void stop( bool );
     void pause( bool );
     void setFullscreen( bool );
     long currentTime();
     void seekTo( long );
     // get length of media file and set it
     void length();
     long position();
     void nextMedia();
     void videoResized ( const QSize &s );
 
 private:
     XINE::Lib *libXine;
     MediaDetect mdetect;
-    long m_currentTime;
+    long m_currentTime;    
     long m_position;
+    int m_length;
     QString m_fileName;
-    bool disabledSuspendScreenSaver;
-    bool hasVideoChannel;
-    bool hasAudioChannel;
+    bool disabledSuspendScreenSaver : 1;
+    bool hasVideoChannel : 1;
+    bool hasAudioChannel : 1;
 signals:
     void positionChanged( long );
 
 };
 
 
 #endif
diff --git a/noncore/multimedia/opieplayer2/xinevideowidget.cpp b/noncore/multimedia/opieplayer2/xinevideowidget.cpp
index 3e28e54..bc95d86 100644
--- a/noncore/multimedia/opieplayer2/xinevideowidget.cpp
+++ b/noncore/multimedia/opieplayer2/xinevideowidget.cpp
@@ -1,270 +1,273 @@
 
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 LJP <>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include <qimage.h>
 #include <qpainter.h>
 #include <qgfx_qws.h>
 #include <qdirectpainter_qws.h>
 #include <qgfx_qws.h>
 #include <qsize.h>
 #include <qapplication.h>
 #include <qpainter.h>
 
 #include <qpe/resource.h>
 
 #include "xinevideowidget.h"
 
 
 static inline void memcpy_rev ( void *dst, void *src, size_t len )
 {
   ((char *) src ) += len;
 
   len >>= 1;
   while ( len-- )
     *((short int *) dst )++ = *--((short int *) src );
 }
 
 static inline void memcpy_step ( void *dst, void *src, size_t len, size_t step )
 {
   len >>= 1;
   while ( len-- ) {
     *((short int *) dst )++ = *((short int *) src );
     ((char *) src ) += step;
   }
 }
 
 static inline void memcpy_step_rev ( void *dst, void *src, size_t len, size_t step )
 {
   len >>= 1;
 
   ((char *) src ) += ( len * step );
 
   while ( len-- ) {
     ((char *) src ) -= step;
     *((short int *) dst )++ = *((short int *) src );
   }
 }
 
 
 XineVideoWidget::XineVideoWidget ( QWidget* parent, const char* name )
     : QWidget ( parent, name, WRepaintNoErase | WResizeNoErase )
 {
   setBackgroundMode ( NoBackground );
 
   m_image             = 0;
   m_buff              = 0;
   m_bytes_per_line_fb = qt_screen-> linestep ( );
   m_bytes_per_pixel   = ( qt_screen->depth() + 7 ) / 8;
   m_rotation          = 0;
 }
 
 
 XineVideoWidget::~XineVideoWidget ( )
 {
   delete m_image;
 }
 
 void XineVideoWidget::clear ( )
 {
   m_buff = 0;
   repaint ( false );
 }
 
 void XineVideoWidget::paintEvent ( QPaintEvent * )
 {
   //qWarning( "painting <<<" );
   if ( m_buff == 0 ) {
     QPainter p ( this );
     p. fillRect ( rect ( ), black );
     if ( m_image )
       p. drawImage ( 0, 0, *m_image );
     //qWarning ( "logo\n" );
   }
   else {
 //    qWarning ( "paintevent\n" );
 
     QArray <QRect> qt_bug_workaround_clip_rects;
 
     {
       QDirectPainter dp ( this );
 
       int rot = dp. transformOrientation ( ) + m_rotation;
 
       uchar *fb = dp. frameBuffer ( );
       uchar *frame = m_buff;  // rot == 0 ? m_buff : m_buff + ( m_thisframe. height ( ) - 1 ) * m_bytes_per_line_frame;
 
       QRect framerect = qt_screen-> mapToDevice ( QRect ( mapToGlobal ( m_thisframe. topLeft ( )), m_thisframe. size ( )), QSize ( qt_screen-> width ( ), qt_screen-> height ( )));
 
       qt_bug_workaround_clip_rects. resize ( dp. numRects ( ));
 
       for ( int i = dp. numRects ( ) - 1; i >= 0; i-- ) {
         const QRect &clip = dp. rect ( i );
 
         qt_bug_workaround_clip_rects [i] = qt_screen-> mapFromDevice ( clip, QSize ( qt_screen-> width ( ), qt_screen-> height ( )));
 
         uchar *dst = fb + ( clip. x ( ) * m_bytes_per_pixel ) + ( clip. y ( ) * m_bytes_per_line_fb );
         uchar *src = frame;
 
         switch ( rot ) {
           case 0: src += ( (( clip. x ( ) - framerect. x ( )) * m_bytes_per_pixel ) + (( clip. y ( ) - framerect. y ( )) * m_bytes_per_line_frame ) ); break;
           case 1: src += ( (( clip. y ( ) - framerect. y ( )) * m_bytes_per_pixel ) + (( clip. x ( ) - framerect. x ( )) * m_bytes_per_line_frame ) + (( framerect. height ( ) - 1 ) * m_bytes_per_pixel ) ); break;
           case 2: src += ( (( clip. x ( ) - framerect. x ( )) * m_bytes_per_pixel ) + (( clip. y ( ) - framerect. y ( )) * m_bytes_per_line_frame ) + (( framerect. height ( ) - 1 ) * m_bytes_per_line_frame ) ); break;
           case 3: src += ( (( clip. y ( ) - framerect. y ( )) * m_bytes_per_pixel ) + (( clip. x ( ) - framerect. x ( )) * m_bytes_per_line_frame ) ); break;
+          default: break;
         }
 
         uint leftfill = 0;
         uint framefill = 0;
         uint rightfill = 0;
         uint clipwidth = clip. width ( ) * m_bytes_per_pixel;
 
         if ( clip. left ( ) < framerect. left ( ))
           leftfill = (( framerect. left ( ) - clip. left ( )) * m_bytes_per_pixel ) <? clipwidth;
         if ( clip. right ( ) > framerect. right ( ))
           rightfill = (( clip. right ( ) - framerect. right ( )) * m_bytes_per_pixel ) <? clipwidth;
 
         framefill = clipwidth - ( leftfill + rightfill );
 
         for ( int y = clip. top ( ); y <= clip. bottom ( ); y++ ) {
           if (( y < framerect. top ( )) || ( y > framerect. bottom ( ))) {
             memset ( dst, 0, clipwidth );
           }
           else {
             if ( leftfill )
               memset ( dst, 0, leftfill );
 
             if ( framefill ) {
               switch ( rot ) {
                 case 0: memcpy ( dst + leftfill, src, framefill );                                  break;
                 case 1: memcpy_step ( dst + leftfill, src, framefill, m_bytes_per_line_frame );     break;
                 case 2: memcpy_rev ( dst + leftfill, src, framefill );                              break;
                 case 3: memcpy_step_rev ( dst + leftfill, src, framefill, m_bytes_per_line_frame ); break;
+                default: break;
               }
             }
             if ( rightfill )
               memset ( dst + leftfill + framefill, 0, rightfill );
           }
 
           dst += m_bytes_per_line_fb;
 
           switch ( rot ) {
             case 0: src += m_bytes_per_line_frame; break;
             case 1: src -= m_bytes_per_pixel;      break;
             case 2: src -= m_bytes_per_line_frame; break;
             case 3: src += m_bytes_per_pixel;      break;
+            default: break;
           }
         }
       }
     }
     //qWarning ( " ||| painting |||" );
     {
       // QVFB hack by MArtin Jones
       QPainter p ( this );
 
       for ( int i = qt_bug_workaround_clip_rects. size ( ) - 1; i >= 0; i-- ) {
         p. fillRect ( QRect ( mapFromGlobal ( qt_bug_workaround_clip_rects [i]. topLeft ( )), qt_bug_workaround_clip_rects [i]. size ( )), QBrush ( NoBrush ) );
       }
     }
   }
   //qWarning( "painting >>>" );
 }
 
 
 void XineVideoWidget::setImage ( QImage* image )
 {
   delete m_image;
   m_image = image;
 }
 
 void XineVideoWidget::setImage ( uchar* img, int w, int h, int bpl )
 {
   bool rot90 = (( -m_rotation ) & 1 );
 
   if ( rot90 ) {
     int d = w;
     w = h;
     h = d;
   }
 
   m_lastframe = m_thisframe;
   m_thisframe. setRect (( width ( ) - w ) / 2, ( height ( ) - h ) / 2, w , h );
 
 //  qDebug ( "Frame: %d,%d - %dx%d", ( width ( ) - w ) / 2, ( height ( ) - h ) / 2, w , h );
 
   m_buff                 = img;
   m_bytes_per_line_frame = bpl;
 
   repaint ((( m_thisframe & m_lastframe ) != m_lastframe ) ? m_lastframe : m_thisframe, false );
 }
 
 void XineVideoWidget::resizeEvent ( QResizeEvent * )
 {
   QSize s = size ( );
   bool fs = ( s == qApp-> desktop ( )-> size ( ));
 
   m_rotation = fs ? -qt_screen-> transformOrientation ( ) : 0;
 
   if ( fs && qt_screen-> isTransformed ( )) {
     s = qt_screen-> mapToDevice ( s );
   }
 
 //  qDebug ( "\n\nResize: %dx%d, Rot: %d", s.width(),s.height(),m_rotation );
 
   emit videoResized ( s );
 }
 
 
-void XineVideoWidget::mousePressEvent ( QMouseEvent *me )
+void XineVideoWidget::mousePressEvent ( QMouseEvent * /*me*/ )
 {
   QWidget *p = parentWidget ( );
 
   if ( p ) {
       // QMouseEvent pme ( QEvent::MouseButtonPress, mapToParent ( me-> pos ( )), me-> globalPos ( ), me-> button ( ), me-> state ( ));
 
       // QApplication::sendEvent ( p, &pme );
       //  emit clicked();
   }
 }
 
-void XineVideoWidget::mouseReleaseEvent ( QMouseEvent *me )
+void XineVideoWidget::mouseReleaseEvent ( QMouseEvent * /*me*/ )
 {
   QWidget *p = parentWidget ( );
 
   if ( p ) {
       //  QMouseEvent pme ( QEvent::MouseButtonRelease, mapToParent ( me-> pos ( )), me-> globalPos ( ), me-> button ( ), me-> state ( ));
 
       // QApplication::sendEvent ( p, &pme );
      emit clicked();
   }
 }