gui

17 files changed, 3319 insertions, 0 deletions

diff --git a/noncore/multimedia/opieplayer2/audiowidget.cpp b/noncore/multimedia/opieplayer2/audiowidget.cpp
new file mode 100644
index 0000000..8d3963a
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/audiowidget.cpp
@@ -0,0 +1,341 @@
+
+#include <qpe/qpeapplication.h>
+#include <qpe/resource.h>
+#include <qpe/config.h>
+
+#include <qwidget.h>
+#include <qpixmap.h>
+#include <qbutton.h>
+#include <qpainter.h>
+#include <qframe.h>
+#include <qlayout.h>
+
+#include "audiowidget.h"
+#include "mediaplayerstate.h"
+
+extern MediaPlayerState *mediaPlayerState;
+
+
+static const int xo = -2; // movable x offset
+static const int yo = 22; // movable y offset
+
+
+struct MediaButton {
+    int  xPos, yPos;
+    int  color;
+    bool isToggle, isBig, isHeld, isDown;
+};
+
+
+// Layout information for the audioButtons (and if it is a toggle button or not)
+MediaButton audioButtons[] = {
+    { 3*30-15+xo, 3*30-13+yo, 0,  TRUE,  TRUE, FALSE, FALSE }, // play
+    {    1*30+xo,    5*30+yo, 2, FALSE, FALSE, FALSE, FALSE }, // stop
+    {    5*30+xo,    5*30+yo, 2,  TRUE, FALSE, FALSE, FALSE }, // pause
+    {  6*30-5+xo,    3*30+yo, 1, FALSE, FALSE, FALSE, FALSE }, // next
+    {  0*30+5+xo,    3*30+yo, 1, FALSE, FALSE, FALSE, FALSE }, // previous
+    {    3*30+xo,  0*30+5+yo, 3, FALSE, FALSE, FALSE, FALSE }, // volume up
+    {    3*30+xo,  6*30-5+yo, 3, FALSE, FALSE, FALSE, FALSE }, // volume down
+    {    5*30+xo,    1*30+yo, 0,  TRUE, FALSE, FALSE, FALSE }, // repeat/loop
+    {    1*30+xo,    1*30+yo, 0, FALSE, FALSE, FALSE, FALSE }  // playlist
+};
+
+
+static const int numButtons = (sizeof(audioButtons)/sizeof(MediaButton));
+
+
+AudioWidget::AudioWidget(QWidget* parent, const char* name, WFlags f) :
+    QWidget( parent, name, f )
+{
+    setCaption( tr("OpiePlayer - Audio") );
+    Config cfg("OpiePlayer");
+    cfg.setGroup("AudioWidget");
+
+    QString backgroundPix, buttonsAllPix, buttonsBigPix, controlsPix, animatedPix;
+    backgroundPix=cfg.readEntry( " backgroundPix", "opieplayer/metalFinish");
+    buttonsAllPix=cfg.readEntry( "buttonsAllPix","opieplayer/mediaButtonsAll");
+    buttonsBigPix=cfg.readEntry( "buttonsBigPix","opieplayer/mediaButtonsBig");
+    controlsPix=cfg.readEntry( "controlsPix","opieplayer/mediaControls");
+
+    setBackgroundPixmap( Resource::loadPixmap( backgroundPix) );
+    pixmaps[0] = new QPixmap( Resource::loadPixmap( buttonsAllPix ) );
+    pixmaps[1] = new QPixmap( Resource::loadPixmap( buttonsBigPix ) );
+    pixmaps[2] = new QPixmap( Resource::loadPixmap( controlsPix ) );
+
+    songInfo = new Ticker( this );
+    songInfo->setFocusPolicy( QWidget::NoFocus );
+    songInfo->setGeometry( QRect( 7, 3, 220, 20 ) );
+
+    slider = new QSlider( Qt::Horizontal, this );
+    slider->setFixedWidth( 220 );
+    slider->setFixedHeight( 20 );
+    slider->setMinValue( 0 );
+    slider->setMaxValue( 1 );
+    slider->setBackgroundPixmap( Resource::loadPixmap( backgroundPix ) );
+    slider->setFocusPolicy( QWidget::NoFocus );
+    slider->setGeometry( QRect( 7, 262, 220, 20 ) );
+
+    connect( slider,           SIGNAL( sliderPressed() ),      this, SLOT( sliderPressed() ) );
+    connect( slider,           SIGNAL( sliderReleased() ),     this, SLOT( sliderReleased() ) );
+    connect( mediaPlayerState, SIGNAL( lengthChanged(long) ),  this, SLOT( setLength(long) ) );
+    connect( mediaPlayerState, SIGNAL( viewChanged(char) ),    this, SLOT( setView(char) ) );
+    connect( mediaPlayerState, SIGNAL( loopingToggled(bool) ), this, SLOT( setLooping(bool) ) );
+    connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( setPaused(bool) ) );
+    connect( mediaPlayerState, SIGNAL( playingToggled(bool) ), this, SLOT( setPlaying(bool) ) );
+
+    // Intialise state
+    setLength( mediaPlayerState->length() );
+    setPosition( mediaPlayerState->position() );
+    setLooping( mediaPlayerState->fullscreen() );
+    setPaused( mediaPlayerState->paused() );
+    setPlaying( mediaPlayerState->playing() );
+
+}
+
+
+AudioWidget::~AudioWidget() {
+    mediaPlayerState->isStreaming = FALSE;
+    for ( int i = 0; i < 3; i++ ) {
+        delete pixmaps[i];
+    }
+}
+
+
+static bool audioSliderBeingMoved = FALSE;
+
+
+void AudioWidget::sliderPressed() {
+    audioSliderBeingMoved = TRUE;
+}
+
+
+void AudioWidget::sliderReleased() {
+    audioSliderBeingMoved = FALSE;
+    if ( slider->width() == 0 ) {
+        return;
+    }
+    long val = long((double)slider->value() * mediaPlayerState->length() / slider->width());
+    mediaPlayerState->setPosition( val );
+}
+
+
+void AudioWidget::setPosition( long i ) {
+    //    qDebug("set position %d",i);
+    updateSlider( i, mediaPlayerState->length() );
+}
+
+
+void AudioWidget::setLength( long max ) {
+    updateSlider( mediaPlayerState->position(), max );
+}
+
+
+void AudioWidget::setView( char view ) {
+    if (mediaPlayerState->isStreaming) {
+        if( !slider->isHidden()) slider->hide();
+        disconnect( mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
+        disconnect( mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
+    } else {
+        // this stops the slider from being moved, thus
+        // does not stop stream when it reaches the end
+        slider->show();
+        connect( mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
+        connect( mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
+    }
+
+    if ( view == 'a' ) {
+        startTimer( 150 );
+        // show();
+        showMaximized();
+    } else {
+        killTimers();
+        hide();
+    }
+}
+
+
+void AudioWidget::updateSlider( long i, long max ) {
+    if ( max == 0 ) {
+        return;
+    }
+    // Will flicker too much if we don't do this
+    // Scale to something reasonable
+    int width = slider->width();
+    int val = int((double)i * width / max);
+    if ( !audioSliderBeingMoved ) {
+        if ( slider->value() != val ) {
+            slider->setValue( val );
+        }
+
+        if ( slider->maxValue() != width ) {
+            slider->setMaxValue( width );
+        }
+    }
+}
+
+
+void AudioWidget::setToggleButton( int i, bool down ) {
+    if ( down != audioButtons[i].isDown ) {
+        toggleButton( i );
+    }
+}
+
+
+void AudioWidget::toggleButton( int i ) {
+    audioButtons[i].isDown = !audioButtons[i].isDown;
+    QPainter p(this);
+    paintButton ( &p, i );
+}
+
+
+void AudioWidget::paintButton( QPainter *p, int i ) {
+    int x = audioButtons[i].xPos;
+    int y = audioButtons[i].yPos;
+    int offset = 22 + 14 * audioButtons[i].isBig + audioButtons[i].isDown;
+    int buttonSize = 64 + audioButtons[i].isBig * (90 - 64);
+    p->drawPixmap( x, y, *pixmaps[audioButtons[i].isBig], buttonSize * (audioButtons[i].isDown + 2 * audioButtons[i].color), 0, buttonSize, buttonSize );
+    p->drawPixmap( x + offset, y + offset, *pixmaps[2], 18 * i, 0, 18, 18 );
+}
+
+
+void AudioWidget::timerEvent( QTimerEvent * ) {
+    static int frame = 0;
+    if ( !mediaPlayerState->paused() && audioButtons[ AudioPlay ].isDown ) {
+        frame = frame >= 7 ? 0 : frame + 1;
+    }
+}
+
+
+void AudioWidget::mouseMoveEvent( QMouseEvent *event ) {
+    for ( int i = 0; i < numButtons; i++ ) {
+        int size = audioButtons[i].isBig;
+        int x = audioButtons[i].xPos;
+        int y = audioButtons[i].yPos;
+        if ( event->state() == QMouseEvent::LeftButton ) {
+              // The test to see if the mouse click is inside the circular button or not
+              // (compared with the radius squared to avoid a square-root of our distance)
+            int radius = 32 + 13 * size;
+            QPoint center = QPoint( x + radius, y + radius );
+            QPoint dXY = center - event->pos();
+            int dist = dXY.x() * dXY.x() + dXY.y() * dXY.y();
+            bool isOnButton = dist <= (radius * radius);
+            if ( isOnButton && !audioButtons[i].isHeld ) {
+                audioButtons[i].isHeld = TRUE;
+                toggleButton(i);
+                qDebug("button toggled1  %d",i);
+                switch (i) {
+                  case AudioVolumeUp:   emit moreClicked(); return;
+                  case AudioVolumeDown: emit lessClicked(); return;
+                }
+            } else if ( !isOnButton && audioButtons[i].isHeld ) {
+                audioButtons[i].isHeld = FALSE;
+                toggleButton(i);
+                qDebug("button toggled2  %d",i);
+            }
+        } else {
+            if ( audioButtons[i].isHeld ) {
+                audioButtons[i].isHeld = FALSE;
+                if ( !audioButtons[i].isToggle )
+                    setToggleButton( i, FALSE );
+                qDebug("button toggled3  %d",i);
+                switch (i) {
+                  case AudioPlay:       mediaPlayerState->setPlaying(audioButtons[i].isDown); return;
+                  case AudioStop:       mediaPlayerState->setPlaying(FALSE); return;
+                  case AudioPause:      mediaPlayerState->setPaused(audioButtons[i].isDown); return;
+                  case AudioNext:       mediaPlayerState->setNext(); return;
+                  case AudioPrevious:   mediaPlayerState->setPrev(); return;
+                  case AudioLoop:       mediaPlayerState->setLooping(audioButtons[i].isDown); return;
+                  case AudioVolumeUp:   emit moreReleased(); return;
+                  case AudioVolumeDown: emit lessReleased(); return;
+                  case AudioPlayList:   mediaPlayerState->setList();  return;
+                }
+            }
+        }
+    }
+}
+
+
+void AudioWidget::mousePressEvent( QMouseEvent *event ) {
+    mouseMoveEvent( event );
+}
+
+
+void AudioWidget::mouseReleaseEvent( QMouseEvent *event ) {
+    mouseMoveEvent( event );
+}
+
+
+void AudioWidget::showEvent( QShowEvent* ) {
+    QMouseEvent event( QEvent::MouseMove, QPoint( 0, 0 ), 0, 0 );
+    mouseMoveEvent( &event );
+}
+
+
+void AudioWidget::closeEvent( QCloseEvent* ) {
+    mediaPlayerState->setList();
+}
+
+
+void AudioWidget::paintEvent( QPaintEvent * ) {
+    QPainter p( this );
+    for ( int i = 0; i < numButtons; i++ )
+  paintButton( &p, i );
+}
+
+void AudioWidget::keyReleaseEvent( QKeyEvent *e)
+{
+    switch ( e->key() ) {
+////////////////////////////// Zaurus keys
+      case Key_Home:
+          break;
+      case Key_F9: //activity
+           hide();
+//           qDebug("Audio F9");
+          break;
+      case Key_F10: //contacts
+          break;
+      case Key_F11: //menu
+          break;
+      case Key_F12: //home
+          break;
+      case Key_F13: //mail
+          break;
+      case Key_Space: {
+          if(mediaPlayerState->playing()) {
+//                toggleButton(1);
+              mediaPlayerState->setPlaying(FALSE);
+//                toggleButton(1);
+          } else {
+//                toggleButton(0);
+              mediaPlayerState->setPlaying(TRUE);
+//                toggleButton(0);
+          }
+      }
+          break;
+      case Key_Down:
+            toggleButton(6);
+          emit lessClicked();
+          emit lessReleased();
+          toggleButton(6);
+          break;
+      case Key_Up:
+           toggleButton(5);
+           emit moreClicked();
+           emit moreReleased();
+           toggleButton(5);
+           break;
+      case Key_Right:
+//            toggleButton(3);
+          mediaPlayerState->setNext();
+//            toggleButton(3);
+          break;
+      case Key_Left:
+//            toggleButton(4);
+          mediaPlayerState->setPrev();
+//            toggleButton(4);
+          break;
+      case Key_Escape:
+          break;
+
+    };
+}
diff --git a/noncore/multimedia/opieplayer2/audiowidget.h b/noncore/multimedia/opieplayer2/audiowidget.h
new file mode 100644
index 0000000..eab5df4
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/audiowidget.h
@@ -0,0 +1,125 @@
+#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>
+
+
+class QPixmap;
+
+enum AudioButtons {
+    AudioPlay,
+    AudioStop,
+    AudioPause,
+    AudioNext,
+    AudioPrevious,
+    AudioVolumeUp,
+    AudioVolumeDown,
+    AudioLoop,
+    AudioPlayList
+};
+
+
+#define USE_DBLBUF
+
+
+class Ticker : public QFrame {
+    Q_OBJECT
+public:
+    Ticker( QWidget* parent=0 ) : QFrame( parent ) {
+        setFrameStyle( WinPanel | Sunken );
+        setText( "No Song" );
+    }
+    ~Ticker() { }
+    void 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();
+    }
+protected:
+    void timerEvent( QTimerEvent * ) {
+  pos = ( pos + 1 > pixelLen ) ? 0 : pos + 1;
+#ifndef USE_DBLBUF
+  scroll( -1, 0, contentsRect() );
+#else
+  repaint( FALSE );
+#endif
+    }
+    void drawContents( QPainter *p ) {
+#ifndef USE_DBLBUF
+  for ( int i = 0; i - pos < width() && (i < 1 || pixelLen > width()); i += pixelLen )
+      p->drawText( i - pos, 0, INT_MAX, height(), AlignVCenter, scrollText );
+#else
+  // Double buffering code.
+  // Looks like qvfb makes it look like it flickers but I don't think it really is
+  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 );
+#endif
+    }
+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 ); }
+    bool isStreaming;
+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 sliderMoved(long);
+
+protected:
+    void doBlank();
+    void doUnblank();
+    void paintEvent( QPaintEvent *pe );
+    void showEvent( QShowEvent *se );
+    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:
+    void toggleButton( int );
+    void setToggleButton( int, bool );
+    void paintButton( QPainter *p, int i );
+    QPixmap *pixmaps[4];
+    Ticker *songInfo;
+    QSlider *slider;
+};
+
+
+#endif // AUDIO_WIDGET_H
+
diff --git a/noncore/multimedia/opieplayer2/inputDialog.cpp b/noncore/multimedia/opieplayer2/inputDialog.cpp
new file mode 100644
index 0000000..da8e276
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/inputDialog.cpp
@@ -0,0 +1,67 @@
+/****************************************************************************
+** Form implementation generated from reading ui file 'inputDialog.ui'
+**
+** Created: Sat Mar 2 07:55:03 2002
+**      by:  The User Interface Compiler (uic)
+**
+** WARNING! All changes made in this file will be lost!
+****************************************************************************/
+#include "inputDialog.h"
+
+#include <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 ) );
+}
+
+/*
+ *  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
new file mode 100644
index 0000000..3e3e36f
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/inputDialog.h
@@ -0,0 +1,30 @@
+/****************************************************************************
+** Form interface generated from reading ui file 'inputDialog.ui'
+**
+** Created: Sat Mar 2 07:54:46 2002
+**      by:  The User Interface Compiler (uic)
+**
+** WARNING! All changes made in this file will be lost!
+****************************************************************************/
+#ifndef INPUTDIALOG_H
+#define INPUTDIALOG_H
+
+#include <qvariant.h>
+#include <qdialog.h>
+
+class QLineEdit;
+
+class InputDialog : public QDialog
+{ 
+    Q_OBJECT
+
+public:
+    InputDialog( QWidget* parent = 0, const char* name = 0, bool modal = FALSE, WFlags fl = 0 );
+    ~InputDialog();
+    QString inputText;
+    QLineEdit* LineEdit1;
+protected slots:
+    void browse();
+};
+
+#endif // INPUTDIALOG_H
diff --git a/noncore/multimedia/opieplayer2/main.cpp b/noncore/multimedia/opieplayer2/main.cpp
new file mode 100644
index 0000000..827f773
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/main.cpp
@@ -0,0 +1,33 @@
+
+#include <qpe/qpeapplication.h>
+#include "mediaplayerstate.h"
+#include "playlistwidget.h"
+#include "audiowidget.h"
+#include "videowidget.h"
+#include "mediaplayer.h"
+
+MediaPlayerState *mediaPlayerState;
+PlayListWidget *playList;
+AudioWidget *audioUI;
+VideoWidget *videoUI;
+
+int main(int argc, char **argv) {
+    QPEApplication a(argc,argv);
+
+    MediaPlayerState st( 0, "mediaPlayerState" );
+    mediaPlayerState = &st;
+    PlayListWidget pl( 0, "playList" );
+    playList = &pl;
+    AudioWidget aw( 0, "audioUI" );
+    audioUI = &aw;
+    VideoWidget vw( 0, "videoUI" );
+    videoUI = &vw;
+
+    MediaPlayer mp( 0, "mediaPlayer" );
+
+    a.showMainDocumentWidget(&pl);
+
+    return a.exec();
+}
+
+
diff --git a/noncore/multimedia/opieplayer2/mediaplayer.cpp b/noncore/multimedia/opieplayer2/mediaplayer.cpp
new file mode 100644
index 0000000..e6d0525
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/mediaplayer.cpp
@@ -0,0 +1,203 @@
+#include <qpe/qpeapplication.h>
+#include <qpe/qlibrary.h>
+#include <qpe/resource.h>
+#include <qpe/config.h>
+
+#include <qmainwindow.h>
+#include <qmessagebox.h>
+#include <qwidgetstack.h>
+#include <qfile.h>
+
+#include "mediaplayer.h"
+#include "playlistwidget.h"
+#include "audiowidget.h"
+
+#include "mediaplayerstate.h"
+
+
+extern AudioWidget *audioUI;
+extern PlayListWidget *playList;
+extern MediaPlayerState *mediaPlayerState;
+
+
+MediaPlayer::MediaPlayer( QObject *parent, const char *name )
+    : QObject( parent, name ), volumeDirection( 0 ), currentFile( NULL ) {
+
+
+//    QPEApplication::grabKeyboard(); // EVIL
+    connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
+
+    connect( mediaPlayerState, SIGNAL( playingToggled( bool ) ), this, SLOT( setPlaying( bool ) ) );
+    connect( mediaPlayerState, SIGNAL( pausedToggled( bool ) ),  this, SLOT( pauseCheck( bool ) ) );
+    connect( mediaPlayerState, SIGNAL( next() ),     this, SLOT( next() ) );
+    connect( mediaPlayerState, SIGNAL( prev() ),     this, SLOT( prev() ) );
+
+    connect( audioUI,  SIGNAL( moreClicked() ),         this, SLOT( startIncreasingVolume() ) );
+    connect( audioUI,  SIGNAL( lessClicked() ),         this, SLOT( startDecreasingVolume() ) );
+    connect( audioUI,  SIGNAL( moreReleased() ),        this, SLOT( stopChangingVolume() ) );
+    connect( audioUI,  SIGNAL( lessReleased() ),        this, SLOT( stopChangingVolume() ) );
+}
+
+MediaPlayer::~MediaPlayer() {
+}
+
+void MediaPlayer::pauseCheck( bool b ) {
+    // Only pause if playing
+    if ( b && !mediaPlayerState->playing() )
+  mediaPlayerState->setPaused( FALSE );
+}
+
+void MediaPlayer::play() {
+    mediaPlayerState->setPlaying( FALSE );
+    mediaPlayerState->setPlaying( TRUE );
+}
+
+void MediaPlayer::setPlaying( bool play ) {
+    if ( !play ) {
+  mediaPlayerState->setPaused( FALSE );
+//  loopControl->stop( FALSE );
+  return;
+    }
+
+    if ( mediaPlayerState->paused() ) {
+  mediaPlayerState->setPaused( FALSE );
+  return;
+    }
+
+    const DocLnk *playListCurrent = playList->current();
+    if ( playListCurrent != NULL ) {
+//  loopControl->stop( TRUE );
+  currentFile = playListCurrent;
+    }
+
+    /*
+
+    if ( currentFile == NULL ) {
+  QMessageBox::critical( 0, tr( "No file"), tr( "Error: There is no file selected" ) );
+  mediaPlayerState->setPlaying( FALSE );
+  return;
+    }
+
+    if ( ((currentFile->file()).left(4) != "http") && !QFile::exists( currentFile->file() ) ) {
+  QMessageBox::critical( 0, tr( "File not found"), tr( "The following file was not found: <i>" ) + currentFile->file() + "</i>" );
+  mediaPlayerState->setPlaying( FALSE );
+  return;
+    }
+
+    if ( !mediaPlayerState->newDecoder( currentFile->file() ) ) {
+  QMessageBox::critical( 0, tr( "No decoder found"), tr( "Sorry, no appropriate decoders found for this file: <i>" ) + currentFile->file() + "</i>" );
+  mediaPlayerState->setPlaying( FALSE );
+  return;
+    }
+
+//    if ( !loopControl->init( currentFile->file() ) ) {
+//  QMessageBox::critical( 0, tr( "Error opening file"), tr( "Sorry, an error occured trying to play the file: <i>" ) + currentFile->file() + "</i>" );
+//  mediaPlayerState->setPlaying( FALSE );
+//  return;
+//    }
+//   long seconds = loopControl->totalPlaytime();
+    long seconds = 120;
+    QString time;
+   time.sprintf("%li:%02i", seconds/60, (int)seconds%60 );
+    QString tickerText;
+    if( currentFile->file().left(4) == "http" )
+     tickerText= tr( " File: " ) + currentFile->name();
+    else
+    tickerText = tr( " File: " ) + currentFile->name() + tr(", Length: ") + time;
+
+    QString fileInfo = mediaPlayerState->curDecoder()->fileInfo();
+    if ( !fileInfo.isEmpty() )
+  tickerText += ", " + fileInfo;
+    audioUI->setTickerText( tickerText + "." );
+
+
+    */ // alles nicht nötig, xine kümmert sich drum, man muss nur den return andio oder video gui geben
+
+
+    //   loopControl->play();
+
+    //  mediaPlayerState->setView( loopControl->hasVideo() ? 'v' : 'a' );
+}
+
+
+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 );
+    // sollte volumeapplet machen
+    //  AudioDevice::decreaseVolume();
+}
+
+
+void MediaPlayer::startIncreasingVolume() {
+    volumeDirection = +1;
+    startTimer( 100 );
+    //  AudioDevice::increaseVolume();
+}
+
+
+void MediaPlayer::stopChangingVolume() {
+    killTimers();
+}
+
+
+void MediaPlayer::timerEvent( QTimerEvent * ) {
+//    if ( volumeDirection == +1 )
+//  AudioDevice::increaseVolume();
+//    else if ( volumeDirection == -1 )
+        //       AudioDevice::decreaseVolume();
+}
+
+void MediaPlayer::keyReleaseEvent( QKeyEvent *e) {
+    switch ( e->key() ) {
+////////////////////////////// Zaurus keys
+      case Key_Home:
+          break;
+      case Key_F9: //activity
+          break;
+      case Key_F10: //contacts
+          break;
+      case Key_F11: //menu
+          break;
+      case Key_F12: //home
+          qDebug("Blank here");
+          break;
+      case Key_F13: //mail
+          break;
+    }
+}
+
+void MediaPlayer::doBlank() {
+
+}
+
+void MediaPlayer::doUnblank() {
+
+}
+
+void MediaPlayer::cleanUp() {
+//     QPEApplication::grabKeyboard();
+//     QPEApplication::ungrabKeyboard();
+
+}
diff --git a/noncore/multimedia/opieplayer2/mediaplayer.h b/noncore/multimedia/opieplayer2/mediaplayer.h
new file mode 100644
index 0000000..c4d38b5
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/mediaplayer.h
@@ -0,0 +1,43 @@
+
+#ifndef MEDIA_PLAYER_H
+#define MEDIA_PLAYER_H
+
+#include <qmainwindow.h>
+#include <qframe.h>
+#include <qpe/qlibrary.h>
+#include <qpe/mediaplayerplugininterface.h>
+
+
+class DocLnk;
+
+
+class MediaPlayer : public QObject {
+    Q_OBJECT
+public:
+    MediaPlayer( QObject *parent, const char *name );
+    ~MediaPlayer();
+
+private slots:
+    void setPlaying( bool );
+    void pauseCheck( bool );
+    void play();
+    void next();
+    void prev();
+    void startIncreasingVolume();
+    void startDecreasingVolume();
+    void stopChangingVolume();
+    void cleanUp();
+
+protected:
+    void timerEvent( QTimerEvent *e );
+    void keyReleaseEvent( QKeyEvent *e);
+    void doBlank();
+    void doUnblank();
+private:
+    int     volumeDirection;
+    const DocLnk  *currentFile;
+};
+
+
+#endif // MEDIA_PLAYER_H
+
diff --git a/noncore/multimedia/opieplayer2/mediaplayerstate.cpp b/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
new file mode 100644
index 0000000..9b5f70e
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
@@ -0,0 +1,78 @@
+
+
+
+#include <qpe/qpeapplication.h>
+#include <qpe/qlibrary.h>
+#include <qpe/config.h>
+#include <qvaluelist.h>
+#include <qobject.h>
+#include <qdir.h>
+#include <qpe/mediaplayerplugininterface.h>
+#include "mediaplayerstate.h"
+
+
+
+#ifdef QT_NO_COMPONENT
+// Plugins which are compiled in when no plugin architecture available
+#include "libmad/libmadpluginimpl.h"
+#include "libmpeg3/libmpeg3pluginimpl.h"
+#include "wavplugin/wavpluginimpl.h"
+#endif
+
+
+//#define MediaPlayerDebug(x) qDebug x
+#define MediaPlayerDebug(x)
+
+
+MediaPlayerState::MediaPlayerState( QObject *parent, const char *name )
+        : QObject( parent, name ), decoder( NULL ), libmpeg3decoder( NULL ) {
+    Config cfg( "OpiePlayer" );
+    readConfig( cfg );
+}
+
+
+MediaPlayerState::~MediaPlayerState() {
+    Config cfg( "OpiePlayer" );
+    writeConfig( cfg );
+}
+
+
+void MediaPlayerState::readConfig( Config& cfg ) {
+    cfg.setGroup("Options");
+    isFullscreen = cfg.readBoolEntry( "FullScreen" );
+    isScaled = cfg.readBoolEntry( "Scaling" );
+    isLooping = cfg.readBoolEntry( "Looping" );
+    isShuffled = cfg.readBoolEntry( "Shuffle" );
+    usePlaylist = cfg.readBoolEntry( "UsePlayList" );
+    usePlaylist = TRUE;
+    isPlaying = FALSE;
+    isPaused = FALSE;
+    curPosition = 0;
+    curLength = 0;
+    curView = 'l';
+}
+
+
+void MediaPlayerState::writeConfig( Config& cfg ) const {
+    cfg.setGroup("Options");
+    cfg.writeEntry("FullScreen", isFullscreen );
+    cfg.writeEntry("Scaling", isScaled );
+    cfg.writeEntry("Looping", isLooping );
+    cfg.writeEntry("Shuffle", isShuffled );
+    cfg.writeEntry("UsePlayList", usePlaylist );
+}
+
+
+struct MediaPlayerPlugin {
+#ifndef QT_NO_COMPONENT
+    QLibrary *library;
+#endif
+    MediaPlayerPluginInterface *iface;
+    MediaPlayerDecoder *decoder;
+    MediaPlayerEncoder *encoder;
+};
+
+
+static QValueList<MediaPlayerPlugin> pluginList;
+
+
diff --git a/noncore/multimedia/opieplayer2/mediaplayerstate.h b/noncore/multimedia/opieplayer2/mediaplayerstate.h
new file mode 100644
index 0000000..374e780
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/mediaplayerstate.h
@@ -0,0 +1,100 @@
+
+#ifndef MEDIA_PLAYER_STATE_H
+#define MEDIA_PLAYER_STATE_H
+
+
+#include <qobject.h>
+
+
+class MediaPlayerDecoder;
+class Config;
+
+
+class MediaPlayerState : public QObject {
+Q_OBJECT
+public:
+    MediaPlayerState( QObject *parent, const char *name );
+    ~MediaPlayerState();
+
+    bool isStreaming;
+    bool fullscreen()    { return isFullscreen; }
+    bool scaled()    { return isScaled; }
+    bool looping()     { return isLooping; }
+    bool shuffled()    { return isShuffled; }
+    bool playlist()    { return usePlaylist; }
+    bool paused()    { return isPaused; }
+    bool playing()     { return isPlaying; }
+    long position()    { return curPosition; }
+    long length()    { return curLength; }
+    char view()      { return curView; }
+
+    MediaPlayerDecoder *newDecoder( const QString& file );
+    MediaPlayerDecoder *curDecoder();
+    MediaPlayerDecoder *libMpeg3Decoder(); // ### Yucky hack needed to use libmpeg3plugin to get the
+             // number of audio samples if we are using the libmad plugin
+public slots:
+    void setFullscreen( bool b ) { if ( isFullscreen == b ) return; isFullscreen = b; emit fullscreenToggled(b); }
+    void setScaled( bool b )     { if ( isScaled     == b ) return; isScaled = b;     emit scaledToggled(b); }
+    void setLooping( bool b )    { if ( isLooping    == b ) return; isLooping = b;    emit loopingToggled(b); }
+    void setShuffled( bool b )   { if ( isShuffled   == b ) return; isShuffled = b;   emit shuffledToggled(b); }
+    void setPlaylist( bool b )   { if ( usePlaylist  == b ) return; usePlaylist = b;  emit playlistToggled(b); }
+    void setPaused( bool b )   { if ( isPaused     == b ) return; isPaused = b;     emit pausedToggled(b); }
+    void setPlaying( bool b )  { if ( isPlaying    == b ) return; isPlaying = b;    emit playingToggled(b); }
+    void setPosition( long p )   { if ( curPosition  == p ) return; curPosition = p;  emit positionChanged(p); }
+    void updatePosition( long p ){ if ( curPosition  == p ) return; curPosition = p;  emit positionUpdated(p); }
+    void setLength( long l )   { if ( curLength    == l ) return; curLength = l;    emit lengthChanged(l); }
+    void setView( char v )   { if ( curView      == v ) return; curView = v;      emit viewChanged(v); }
+
+    void setPrev()     { emit prev(); }
+    void setNext()     { emit next(); }
+    void setList()     { setPlaying( FALSE ); setView('l'); }
+    void setVideo()    { setView('v'); }
+    void setAudio()    { setView('a'); }
+
+    void toggleFullscreen()  { setFullscreen( !isFullscreen ); }
+    void toggleScaled()    { setScaled( !isScaled); }
+    void toggleLooping()   { setLooping( !isLooping); }
+    void toggleShuffled()  { setShuffled( !isShuffled); }
+    void togglePlaylist()  { setPlaylist( !usePlaylist); }
+    void togglePaused()    { setPaused( !isPaused); }
+    void togglePlaying()   { setPlaying( !isPlaying); }
+
+signals:
+    void fullscreenToggled( bool );
+    void scaledToggled( bool );
+    void loopingToggled( bool );
+    void shuffledToggled( bool );
+    void playlistToggled( bool );
+    void pausedToggled( bool );
+    void playingToggled( bool );
+    void positionChanged( long ); // When the slider is moved
+    void positionUpdated( long ); // When the media file progresses
+    void lengthChanged( long );
+    void viewChanged( char );
+
+    void prev();
+    void next();
+
+private:
+    bool isFullscreen;
+    bool isScaled;
+    bool isLooping;
+    bool isShuffled;
+    bool usePlaylist;
+    bool isPaused;
+    bool isPlaying;
+    long curPosition;
+    long curLength;
+    char curView;
+
+    MediaPlayerDecoder *decoder;
+    MediaPlayerDecoder *libmpeg3decoder;
+//    MediaPlayerDecoder *libwavdecoder;
+
+    void readConfig( Config& cfg );
+    void writeConfig( Config& cfg ) const;
+};
+
+
+#endif // MEDIA_PLAYER_STATE_H
+
diff --git a/noncore/multimedia/opieplayer2/opie-mediaplayer2.control b/noncore/multimedia/opieplayer2/opie-mediaplayer2.control
new file mode 100644
index 0000000..c0fd2a8
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/opie-mediaplayer2.control
@@ -0,0 +1,9 @@
+Files: bin/opieplayer2 pics/opieplayer apps/Applications/opieplayer.desktop
+Priority: optional
+Section: opie/applications
+Maintainer: L.J.Potter <ljp@llornkcor.com>
+Architecture: arm
+Version: $QPE_VERSION-$SUB_VERSION
+Depends: opie-base ($QPE_VERSION), libopie ($QPE_VERSION)
+Description: The Opie media player
+ The mediaplayer for Opie. It plays mp3, mpeg, and wav, ogg, quicktime, divx
diff --git a/noncore/multimedia/opieplayer2/opieplayer2.pro b/noncore/multimedia/opieplayer2/opieplayer2.pro
new file mode 100644
index 0000000..47683ac
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/opieplayer2.pro
@@ -0,0 +1,17 @@
+TEMPLATE  = app
+CONFIG    = qt warn_on release
+#release
+DESTDIR   = $(OPIEDIR)/bin
+HEADERS   = playlistselection.h mediaplayerstate.h \
+              videowidget.h audiowidget.h playlistwidget.h mediaplayer.h inputDialog.h
+SOURCES   = main.cpp \
+              playlistselection.cpp mediaplayerstate.cpp \
+              videowidget.cpp audiowidget.cpp playlistwidget.cpp mediaplayer.cpp inputDialog.cpp
+TARGET    = opieplayer
+INCLUDEPATH += $(OPIEDIR)/include
+DEPENDPATH  += $(OPIEDIR)/include
+LIBS            += -lqpe -lpthread -lopie
+
+INCLUDEPATH += $(OPIEDIR)/include
+DEPENDPATH  += $(OPIEDIR)/include
+
diff --git a/noncore/multimedia/opieplayer2/playlistselection.cpp b/noncore/multimedia/opieplayer2/playlistselection.cpp
new file mode 100644
index 0000000..85228a9
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/playlistselection.cpp
@@ -0,0 +1,215 @@
+/**********************************************************************
+** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
+**
+** This file is part of the Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+#include <qpe/applnk.h>
+#include <qpe/resource.h>
+#include <qpe/config.h>
+
+#include <qpainter.h>
+#include <qimage.h>
+#include <qheader.h>
+#include <qlistview.h>
+#include <qlist.h>
+#include <qpixmap.h>
+
+#include "playlistselection.h"
+
+#include <stdlib.h>
+
+class PlayListSelectionItem : public QListViewItem {
+public:
+    PlayListSelectionItem( QListView *parent, const DocLnk *f ) : QListViewItem( parent ), fl( f ) {
+  setText( 0, f->name() );
+  setPixmap( 0, f->pixmap() );
+    }
+
+    ~PlayListSelectionItem() {
+    };
+
+    const DocLnk *file() const { return fl; }
+
+private:
+    const DocLnk *fl;
+};
+
+
+PlayListSelection::PlayListSelection( QWidget *parent, const char *name )
+    : QListView( parent, name )
+{
+//    qDebug("starting playlistselector");
+// #ifdef USE_PLAYLIST_BACKGROUND
+//    setStaticBackground( TRUE );
+//      setBackgroundPixmap( Resource::loadPixmap( "opieplayer/background" ) );
+
+//      setBackgroundPixmap( Resource::loadPixmap( "launcher/opielogo" ) );
+// #endif
+//      addColumn("Title",236);
+//      setAllColumnsShowFocus( TRUE );
+     addColumn( tr( "Playlist Selection" ) );
+    header()->hide();
+    setSorting( -1, FALSE );
+}
+
+
+PlayListSelection::~PlayListSelection() {
+}
+
+
+// #ifdef USE_PLAYLIST_BACKGROUND
+void PlayListSelection::drawBackground( QPainter *p, const QRect &r ) {
+//  qDebug("drawBackground");
+   p->fillRect( r, QBrush( white ) );
+//        QImage logo = Resource::loadImage( "launcher/opielogo" );
+//          if ( !logo.isNull() )
+//        p->drawImage( (width() - logo.width()) / 2, (height() - logo.height()) / 2, logo );
+}
+// #endif
+
+
+void PlayListSelection::contentsMouseMoveEvent( QMouseEvent *event ) {
+    if ( event->state() == QMouseEvent::LeftButton ) {
+  QListViewItem *currentItem = selectedItem();
+  QListViewItem *itemUnder = itemAt( QPoint( event->pos().x(), event->pos().y() - contentsY() ) );
+  if ( currentItem && currentItem->itemAbove() == itemUnder )
+      moveSelectedUp();
+  else if ( currentItem && currentItem->itemBelow() == itemUnder )
+      moveSelectedDown();
+    }
+}
+
+
+const DocLnk *PlayListSelection::current() {
+    PlayListSelectionItem *item = (PlayListSelectionItem *)selectedItem();
+    if ( item )
+  return item->file();
+    return NULL;
+}
+
+
+void PlayListSelection::addToSelection( const DocLnk &lnk ) {
+    PlayListSelectionItem *item = new PlayListSelectionItem( this, new DocLnk( lnk ) );
+    QListViewItem *current = selectedItem();
+    if ( current )
+        item->moveItem( current );
+    setSelected( item, TRUE );
+    ensureItemVisible( selectedItem() );
+}
+
+
+void PlayListSelection::removeSelected() {
+    QListViewItem *item = selectedItem();
+    if ( item )
+  delete item;
+    setSelected( currentItem(), TRUE );
+    ensureItemVisible( selectedItem() );
+}
+
+
+void PlayListSelection::moveSelectedUp() {
+    QListViewItem *item = selectedItem();
+    if ( item && item->itemAbove() )
+  item->itemAbove()->moveItem( item );
+    ensureItemVisible( selectedItem() );
+}
+
+
+void PlayListSelection::moveSelectedDown() {
+    QListViewItem *item = selectedItem();
+    if ( item && item->itemBelow() )
+        item->moveItem( item->itemBelow() );
+    ensureItemVisible( selectedItem() );
+}
+
+
+bool PlayListSelection::prev() {
+    QListViewItem *item = selectedItem();
+    if ( item && item->itemAbove() )
+        setSelected( item->itemAbove(), TRUE );
+    else
+  return FALSE;
+    ensureItemVisible( selectedItem() );
+    return TRUE;
+}
+
+bool PlayListSelection::next() {
+    QListViewItem *item = selectedItem();
+    if ( item && item->itemBelow() )
+        setSelected( item->itemBelow(), TRUE );
+    else
+  return FALSE;
+    ensureItemVisible( selectedItem() );
+    return TRUE;
+}
+
+
+bool PlayListSelection::first() {
+    QListViewItem *item = firstChild();
+    if ( item )
+        setSelected( item, TRUE );
+    else
+  return FALSE;
+    ensureItemVisible( selectedItem() );
+    return TRUE;
+}
+
+
+bool PlayListSelection::last() {
+    QListViewItem *prevItem = NULL;
+    QListViewItem *item = firstChild();
+    while ( ( item = item->nextSibling() ) )
+  prevItem = item;
+    if ( prevItem )
+        setSelected( prevItem, TRUE );
+    else
+  return FALSE;
+    ensureItemVisible( selectedItem() );
+    return TRUE;
+}
+
+void PlayListSelection::unSelect()
+{
+    QListViewItem *item = selectedItem();
+    setSelected( currentItem(), FALSE);
+}
+
+void PlayListSelection::writeCurrent( Config& cfg ) {
+    cfg.setGroup("PlayList");
+    QListViewItem *item = selectedItem();
+    if ( item )
+        cfg.writeEntry("current", item->text(0) );
+    qDebug(item->text(0));
+
+}
+
+void  PlayListSelection::setSelectedItem(const QString &strk ) {
+
+    unSelect();
+    QListViewItemIterator it( this );
+    for ( ; it.current(); ++it ) {
+//        qDebug( it.current()->text(0));
+        if( strk == it.current()->text(0)) {
+//             qDebug( "We have a match "+strk);
+            setSelected( it.current(), TRUE);
+            ensureItemVisible( it.current() );
+            return;
+        }
+    }
+//     setSelected( item, TRUE );
+//     ensureItemVisible( selectedItem() );
+}
diff --git a/noncore/multimedia/opieplayer2/playlistselection.h b/noncore/multimedia/opieplayer2/playlistselection.h
new file mode 100644
index 0000000..d10bc82
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/playlistselection.h
@@ -0,0 +1,63 @@
+/**********************************************************************
+** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
+**
+** This file is part of the Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+#ifndef PLAY_LIST_SELECTION_H
+#define PLAY_LIST_SELECTION_H
+
+#include <qlist.h>
+#include <qlistview.h>
+#include <qpe/applnk.h>
+#include <qpe/config.h>
+
+class PlayListSelection : public QListView {
+    Q_OBJECT
+public:
+    PlayListSelection( QWidget *parent, const char *name=0 );
+    ~PlayListSelection();
+
+    const DocLnk *current(); // retrieve the current playlist entry (media file link)
+public slots:
+    void addToSelection( const DocLnk & ); // Add a media file to the playlist
+    void removeSelected();   // Remove a media file from the playlist
+    void moveSelectedUp();   // Move the media file up the playlist so it is played earlier
+    void moveSelectedDown(); // Move the media file down the playlist so it is played later
+  void unSelect();
+  void writeCurrent( Config &);
+  void setSelectedItem( const QString & );
+    bool prev();
+    bool next();
+    bool first();
+    bool last();
+
+protected:
+    virtual void contentsMouseMoveEvent(QMouseEvent *);
+/* #ifdef USE_PLAYLIST_BACKGROUND */
+    virtual void drawBackground( QPainter *p, const QRect &r );
+    virtual void paintEmptyArea( QPainter *p, const QRect &r ) { drawBackground( p, r ); };
+/* #endif */
+
+private:
+    QList<DocLnk>   selectedList;
+    const DocLnk    *lnk;
+};
+
+
+#endif // PLAY_LIST_SELECTION_H
+
+
diff --git a/noncore/multimedia/opieplayer2/playlistwidget.cpp b/noncore/multimedia/opieplayer2/playlistwidget.cpp
new file mode 100644
index 0000000..0390c99
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/playlistwidget.cpp
@@ -0,0 +1,1348 @@
+
+// code added by L. J. Potter Sat 03-02-2002 06:17:54
+#define QTOPIA_INTERNAL_FSLP
+#include <qpe/qcopenvelope_qws.h>
+
+#include <qpe/qpemenubar.h>
+#include <qpe/qpetoolbar.h>
+#include <qpe/fileselector.h>
+#include <qpe/qpeapplication.h>
+#include <qpe/lnkproperties.h>
+#include <qpe/storage.h>
+
+#include <qpe/applnk.h>
+#include <qpe/config.h>
+#include <qpe/global.h>
+#include <qpe/resource.h>
+#include <qaction.h>
+#include <qcursor.h>
+#include <qimage.h>
+#include <qfile.h>
+#include <qdir.h>
+#include <qlayout.h>
+#include <qlabel.h>
+#include <qlist.h>
+#include <qlistbox.h>
+#include <qmainwindow.h>
+#include <qmessagebox.h>
+#include <qtoolbutton.h>
+#include <qtabwidget.h>
+#include <qlistview.h>
+#include <qpoint.h>
+#include <qlineedit.h>
+#include <qpushbutton.h>
+#include <qregexp.h>
+#include <qtextstream.h>
+
+//#include <qtimer.h>
+
+#include "playlistselection.h"
+#include "playlistwidget.h"
+#include "mediaplayerstate.h"
+
+#include "inputDialog.h"
+
+#include <stdlib.h>
+#include "audiowidget.h"
+#include "videowidget.h"
+
+#include <unistd.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/soundcard.h>
+
+// for setBacklight()
+#include <linux/fb.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+
+#define BUTTONS_ON_TOOLBAR
+#define SIDE_BUTTONS
+#define CAN_SAVE_LOAD_PLAYLISTS
+
+extern AudioWidget *audioUI;
+extern VideoWidget *videoUI;
+extern MediaPlayerState *mediaPlayerState;
+
+// class myFileSelector {
+
+// };
+class PlayListWidgetPrivate {
+public:
+    QToolButton *tbPlay, *tbFull, *tbLoop, *tbScale, *tbShuffle, *tbAddToList,  *tbRemoveFromList, *tbMoveUp, *tbMoveDown, *tbRemove;
+    QFrame *playListFrame;
+    FileSelector *files;
+    PlayListSelection *selectedFiles;
+    bool setDocumentUsed;
+    DocLnk *current;
+};
+
+
+class ToolButton : public QToolButton {
+public:
+    ToolButton( QWidget *parent, const char *name, const QString& icon, QObject *handler, const QString& slot, bool t = FALSE )
+            : QToolButton( parent, name ) {
+        setTextLabel( name );
+        setPixmap( Resource::loadPixmap( icon ) );
+        setAutoRaise( TRUE );
+        setFocusPolicy( QWidget::NoFocus );
+        setToggleButton( t );
+        connect( this, t ? SIGNAL( toggled(bool) ) : SIGNAL( clicked() ), handler, slot );
+        QPEMenuToolFocusManager::manager()->addWidget( this );
+    }
+};
+
+
+class MenuItem : public QAction {
+public:
+    MenuItem( QWidget *parent, const QString& text, QObject *handler, const QString& slot )
+            : QAction( text, QString::null, 0, 0 ) {
+        connect( this, SIGNAL( activated() ), handler, slot );
+        addTo( parent );
+    }
+};
+
+
+PlayListWidget::PlayListWidget( QWidget* parent, const char* name, WFlags fl )
+        : QMainWindow( parent, name, fl ) {
+
+    d = new PlayListWidgetPrivate;
+    d->setDocumentUsed = FALSE;
+    d->current = NULL;
+    fromSetDocument = FALSE;
+    insanityBool=FALSE;
+    audioScan = FALSE;
+    videoScan = FALSE;
+//    menuTimer = new QTimer( this ,"menu timer"),
+//     connect( menuTimer, SIGNAL( timeout() ), SLOT( addSelected() ) );
+
+    setBackgroundMode( PaletteButton );
+
+    setCaption( tr("OpiePlayer") );
+    setIcon( Resource::loadPixmap( "opieplayer/MPEGPlayer" ) );
+
+    setToolBarsMovable( FALSE );
+
+      // Create Toolbar
+    QPEToolBar *toolbar = new QPEToolBar( this );
+    toolbar->setHorizontalStretchable( TRUE );
+
+      // Create Menubar
+    QPEMenuBar *menu = new QPEMenuBar( toolbar );
+    menu->setMargin( 0 );
+
+    QPEToolBar *bar = new QPEToolBar( this );
+    bar->setLabel( tr( "Play Operations" ) );
+//      d->tbPlayCurList =  new ToolButton( bar, tr( "play List" ), "opieplayer/play_current_list",
+//                                        this , SLOT( addSelected()) );
+    tbDeletePlaylist = new QPushButton( Resource::loadIconSet("trash"),"",bar,"close");
+    tbDeletePlaylist->setFlat(TRUE);
+    tbDeletePlaylist->setFixedSize(20,20);
+
+    d->tbAddToList =  new ToolButton( bar, tr( "Add to Playlist" ), "opieplayer/add_to_playlist",
+                                      this , SLOT(addSelected()) );
+    d->tbRemoveFromList = new ToolButton( bar, tr( "Remove from Playlist" ), "opieplayer/remove_from_playlist",
+                                          this , SLOT(removeSelected()) );
+//    d->tbPlay    = new ToolButton( bar, tr( "Play" ), "opieplayer/play", /*this */mediaPlayerState , SLOT(setPlaying(bool) /* btnPlay() */), TRUE );
+    d->tbPlay    = new ToolButton( bar, tr( "Play" ), "opieplayer/play",
+                                   this , SLOT( btnPlay(bool) ), TRUE );
+    d->tbShuffle = new ToolButton( bar, tr( "Randomize" ),"opieplayer/shuffle",
+                                   mediaPlayerState, SLOT(setShuffled(bool)), TRUE );
+    d->tbLoop    = new ToolButton( bar, tr( "Loop" ),"opieplayer/loop",
+                                   mediaPlayerState, SLOT(setLooping(bool)), TRUE );
+    tbDeletePlaylist->hide();
+
+    QPopupMenu *pmPlayList = new QPopupMenu( this );
+    menu->insertItem( tr( "File" ), pmPlayList );
+    new MenuItem( pmPlayList, tr( "Clear List" ), this, SLOT( clearList() ) );
+    new MenuItem( pmPlayList, tr( "Add all audio files" ), this, SLOT( addAllMusicToList() ) );
+    new MenuItem( pmPlayList, tr( "Add all video files" ), this, SLOT( addAllVideoToList() ) );
+    new MenuItem( pmPlayList, tr( "Add all files" ), this, SLOT( addAllToList() ) );
+    pmPlayList->insertSeparator(-1);
+    new MenuItem( pmPlayList, tr( "Save PlayList" ), this, SLOT( saveList() ) );
+    new MenuItem( pmPlayList, tr( "Export playlist to m3u" ), this, SLOT(writem3u() ) );
+    pmPlayList->insertSeparator(-1);
+    new MenuItem( pmPlayList, tr( "Open File or URL" ), this,SLOT( openFile() ) );
+    pmPlayList->insertSeparator(-1);
+    new MenuItem( pmPlayList, tr( "Rescan for Audio Files" ), this,SLOT( scanForAudio() ) );
+    new MenuItem( pmPlayList, tr( "Rescan for Video Files" ), this,SLOT( scanForVideo() ) );
+
+    QPopupMenu *pmView = new QPopupMenu( this );
+    menu->insertItem( tr( "View" ), pmView );
+
+    fullScreenButton = new QAction(tr("Full Screen"), Resource::loadPixmap("fullscreen"), QString::null, 0, this, 0);
+    fullScreenButton->addTo(pmView);
+    scaleButton = new QAction(tr("Scale"), Resource::loadPixmap("opieplayer/scale"), QString::null, 0, this, 0);
+    scaleButton->addTo(pmView);
+
+    QVBox *vbox5 = new QVBox( this ); vbox5->setBackgroundMode( PaletteButton );
+    QVBox *vbox4 = new QVBox( vbox5 ); vbox4->setBackgroundMode( PaletteButton );
+
+    QHBox *hbox6 = new QHBox( vbox4 ); hbox6->setBackgroundMode( PaletteButton );
+
+    tabWidget = new QTabWidget( hbox6, "tabWidget" );
+    tabWidget->setTabShape(QTabWidget::Triangular);
+
+    QWidget *pTab;
+    pTab = new QWidget( tabWidget, "pTab" );
+//      playlistView = new QListView( pTab, "playlistview" );
+//    playlistView->setMinimumSize(236,260);
+    tabWidget->insertTab( pTab,"Playlist");
+
+
+      // Add the playlist area
+
+    QVBox *vbox3 = new QVBox( pTab ); vbox3->setBackgroundMode( PaletteButton );
+    d->playListFrame = vbox3;
+    d->playListFrame ->setMinimumSize(235,260);
+
+    QHBox *hbox2 = new QHBox( vbox3 ); hbox2->setBackgroundMode( PaletteButton );
+
+    d->selectedFiles = new PlayListSelection( hbox2);
+    QVBox *vbox1 = new QVBox( hbox2 ); vbox1->setBackgroundMode( PaletteButton );
+
+    QPEApplication::setStylusOperation( d->selectedFiles->viewport(),QPEApplication::RightOnHold);
+
+
+
+    QVBox *stretch1 = new QVBox( vbox1 ); stretch1->setBackgroundMode( PaletteButton ); // add stretch
+    new ToolButton( vbox1, tr( "Move Up" ),   "opieplayer/up",   d->selectedFiles, SLOT(moveSelectedUp()) );
+    new ToolButton( vbox1, tr( "Remove" ),    "opieplayer/cut",  d->selectedFiles, SLOT(removeSelected()) );
+    new ToolButton( vbox1, tr( "Move Down" ), "opieplayer/down", d->selectedFiles, SLOT(moveSelectedDown()) );
+    QVBox *stretch2 = new QVBox( vbox1 ); stretch2->setBackgroundMode( PaletteButton ); // add stretch
+
+    QWidget *aTab;
+    aTab = new QWidget( tabWidget, "aTab" );
+    audioView = new QListView( aTab, "Audioview" );
+    audioView->setMinimumSize(233,260);
+    audioView->addColumn( tr("Title"),140);
+    audioView->addColumn(tr("Size"), -1);
+    audioView->addColumn(tr("Media"),-1);
+    audioView->setColumnAlignment(1, Qt::AlignRight);
+    audioView->setColumnAlignment(2, Qt::AlignRight);
+    audioView->setAllColumnsShowFocus(TRUE);
+
+    audioView->setMultiSelection( TRUE );
+    audioView->setSelectionMode( QListView::Extended);
+
+    tabWidget->insertTab(aTab,tr("Audio"));
+
+    QPEApplication::setStylusOperation( audioView->viewport(),QPEApplication::RightOnHold);
+
+//    audioView
+//     populateAudioView();
+// videowidget
+
+    QWidget *vTab;
+    vTab = new QWidget( tabWidget, "vTab" );
+    videoView = new QListView( vTab, "Videoview" );
+    videoView->setMinimumSize(233,260);
+
+    videoView->addColumn(tr("Title"),140);
+    videoView->addColumn(tr("Size"),-1);
+    videoView->addColumn(tr("Media"),-1);
+    videoView->setColumnAlignment(1, Qt::AlignRight);
+    videoView->setColumnAlignment(2, Qt::AlignRight);
+    videoView->setAllColumnsShowFocus(TRUE);
+    videoView->setMultiSelection( TRUE );
+    videoView->setSelectionMode( QListView::Extended);
+
+    QPEApplication::setStylusOperation( videoView->viewport(),QPEApplication::RightOnHold);
+
+    tabWidget->insertTab( vTab,tr("Video"));
+//  populateVideoView();
+
+//playlists list
+    QWidget *LTab;
+    LTab = new QWidget( tabWidget, "LTab" );
+    playLists = new FileSelector( "playlist/plain", LTab, "fileselector" , FALSE, FALSE); //buggy
+    playLists->setMinimumSize(233,260);
+    tabWidget->insertTab(LTab,tr("Lists"));
+
+//      connect( playLists, SIGNAL( newSelected( const DocLnk &) ), this, SLOT( newFile( const DocLnk & ) ) );
+
+// add the library area
+
+//     connect( audioView, SIGNAL( rightButtonClicked( QListViewItem *, const QPoint &, int)),
+//              this, SLOT( fauxPlay( QListViewItem *) ) );
+//     connect( videoView, SIGNAL( rightButtonClicked( QListViewItem *, const QPoint &, int)),
+//              this, SLOT( fauxPlay( QListViewItem *)) );
+
+//    connect( audioView, SIGNAL( clicked( QListViewItem *) ), this, SLOT( fauxPlay( QListViewItem *) ) );
+//    connect( videoView, SIGNAL( clicked( QListViewItem *) ), this, SLOT( fauxPlay( QListViewItem *) ) );
+
+    connect(tbDeletePlaylist,(SIGNAL(released())),SLOT( deletePlaylist()));
+    connect( fullScreenButton, SIGNAL(activated()), mediaPlayerState, SLOT(toggleFullscreen()) );
+    connect( scaleButton, SIGNAL(activated()), mediaPlayerState, SLOT(toggleScaled()) );
+    connect( d->selectedFiles, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
+             this,SLOT( playlistViewPressed(int, QListViewItem *, const QPoint&, int)) );
+
+    connect( audioView, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
+             this,SLOT( viewPressed(int, QListViewItem *, const QPoint&, int)) );
+
+    connect( audioView, SIGNAL( returnPressed( QListViewItem *)),
+             this,SLOT( playIt( QListViewItem *)) );
+    connect( audioView, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( addToSelection( QListViewItem *) ) );
+
+    connect( videoView, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
+             this,SLOT( viewPressed(int, QListViewItem *, const QPoint&, int)) );
+    connect( videoView, SIGNAL( returnPressed( QListViewItem *)),
+             this,SLOT( playIt( QListViewItem *)) );
+    connect( videoView, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( addToSelection( QListViewItem *) ) );
+
+    connect( playLists, SIGNAL( fileSelected( const DocLnk &) ), this, SLOT( loadList( const DocLnk & ) ) );
+
+
+    connect( tabWidget, SIGNAL (currentChanged(QWidget*)),this,SLOT(tabChanged(QWidget*)));
+
+    connect( mediaPlayerState, SIGNAL( playingToggled( bool ) ),    d->tbPlay,    SLOT( setOn( bool ) ) );
+    connect( mediaPlayerState, SIGNAL( loopingToggled( bool ) ),    d->tbLoop,    SLOT( setOn( bool ) ) );
+    connect( mediaPlayerState, SIGNAL( shuffledToggled( bool ) ),   d->tbShuffle, SLOT( setOn( bool ) ) );
+    connect( mediaPlayerState, SIGNAL( playlistToggled( bool ) ),   this,         SLOT( setPlaylist( bool ) ) );
+
+    connect( d->selectedFiles, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( playIt( QListViewItem *) ) );
+//   connect( d->selectedFiles, SIGNAL( fileSelected( const DocLnk & ) ), this, SLOT( addToSelection( const DocLnk & ) ) );
+
+    setCentralWidget( vbox5 );
+
+    Config cfg( "OpiePlayer" );
+    readConfig( cfg );
+    QString currentPlaylist = cfg.readEntry("CurrentPlaylist","");
+//    qDebug("currentList is "+currentPlaylist);
+    loadList(DocLnk( currentPlaylist));
+    setCaption(tr("OpiePlayer: ")+ currentPlaylist );
+
+    initializeStates();
+}
+
+
+PlayListWidget::~PlayListWidget() {
+    Config cfg( "OpiePlayer" );
+    writeConfig( cfg );
+
+
+    if ( d->current )
+        delete d->current;
+    delete d;
+}
+
+
+void PlayListWidget::initializeStates() {
+
+    d->tbPlay->setOn( mediaPlayerState->playing() );
+    d->tbLoop->setOn( mediaPlayerState->looping() );
+    d->tbShuffle->setOn( mediaPlayerState->shuffled() );
+//     d->tbFull->setOn( mediaPlayerState->fullscreen() );
+//     d->tbScale->setOn( mediaPlayerState->scaled() );
+//     d->tbScale->setEnabled( mediaPlayerState->fullscreen() );
+//    setPlaylist( mediaPlayerState->playlist() );
+    setPlaylist( true);
+//     d->selectedFiles->first();
+
+}
+
+
+void PlayListWidget::readConfig( Config& cfg ) {
+    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 );
+        DocLnk lnk( linkFile );
+        if ( lnk.isValid() ) {
+            d->selectedFiles->addToSelection( lnk );
+        }
+    }
+    d->selectedFiles->setSelectedItem( currentString);
+//    d->selectedFiles->setSelectedItem( (const QString &)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 );
+//            qDebug(entryName);
+            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 ) {
+//    qDebug("add");
+//     if( lnk.file().find(" ",0,TRUE) != -1 || lnk.file().find("%20",0,TRUE) != -1) {
+//         QMessageBox::message("Note","You are trying to play\na malformed url.");
+
+//     } else {
+
+        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;
+    }
+//    qDebug("setDocument "+fileref);
+    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() {
+      // 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
+
+//      if( fromSetDocument) {
+//          qDebug("from setDoc");
+//          DocLnkSet files;
+//          Global::findDocuments(&files, "video/*;audio/*");
+//          QListIterator<DocLnk> dit( files.children() );
+//          for ( ; dit.current(); ++dit ) {
+//              if(dit.current()->linkFile() ==  setDocFileRef) {
+//                  qDebug(setDocFileRef);
+//                  return dit;
+//              }
+//          }
+//      } else
+
+
+    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;
+    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";
+//         qDebug("saving playlist "+filename+".playlist");
+        Config cfg( filename +".playlist");
+        writeConfig( cfg );
+
+        DocLnk lnk;
+//        lnk.setComment( "");
+        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("opieplayer/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
+//                 QString entryName;
+//                 entryName.sprintf( "File%i", i + 1 );
+//                 QString linkFile = cfg.readEntry( entryName );
+          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) ) {
+                          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) ) {
+                          d->selectedFiles->addToSelection(  **dit );
+                      }
+                  }
+
+                  videoView->setSelected( it.current(),FALSE);
+              }
+          }
+//             for ( int i = 0; i < noOfFiles; i++ ) {
+//                 QString entryName;
+//                 entryName.sprintf( "File%i", i + 1 );
+//                 QString linkFile = cfg.readEntry( entryName );
+//                   if( DocLnk( linkFile).name() == videoView->selectedItem()->text(0) ) {
+//                       int result= QMessageBox::warning(this,tr("OpiePlayer"),
+//                                   tr("This is all ready in your playlist.\nContinue?"),
+//                                   tr("Yes"),tr("No"),0,0,1);
+//                       if (result !=0)
+//                           return;
+//                   }
+//             }
+//             addToSelection( videoView->selectedItem() );
+          tabWidget->setCurrentPage(0);
+      }
+      break;
+    };
+}
+
+void PlayListWidget::removeSelected() {
+    d->selectedFiles->removeSelected( );
+}
+
+void PlayListWidget::playIt( QListViewItem *it) {
+//   d->setDocumentUsed = FALSE;
+//  mediaPlayerState->curPosition =0;
+    qDebug("playIt");
+    mediaPlayerState->setPlaying(FALSE);
+    mediaPlayerState->setPlaying(TRUE);
+    d->selectedFiles->unSelect();
+}
+
+void PlayListWidget::addToSelection( QListViewItem *it) {
+    d->setDocumentUsed = FALSE;
+
+    if(it) {
+        switch (tabWidget->currentPageIndex()) {
+          case 1: {
+              QListIterator<DocLnk> dit( files.children() );
+              for ( ; dit.current(); ++dit ) {
+                  if( dit.current()->name() == it->text(0)) {
+                      d->selectedFiles->addToSelection(  **dit );
+                  }
+              }
+          }
+          break;
+          case 2: {
+              QListIterator<DocLnk> dit( vFiles.children() );
+              for ( ; dit.current(); ++dit ) {
+                  if( dit.current()->name() == it->text(0)) {
+                      d->selectedFiles->addToSelection(  **dit );
+                  }
+              }
+          }
+          break;
+          case 0:
+              break;
+        };
+        tabWidget->setCurrentPage(0);
+    }
+}
+
+void PlayListWidget::tabChanged(QWidget *widg) {
+
+    switch ( tabWidget->currentPageIndex()) {
+      case 0:
+      {
+          if( !tbDeletePlaylist->isHidden())
+              tbDeletePlaylist->hide();
+          d->tbRemoveFromList->setEnabled(TRUE);
+          d->tbAddToList->setEnabled(FALSE);
+      }
+      break;
+      case 1:
+      {
+          audioView->clear();
+          populateAudioView();
+
+          if( !tbDeletePlaylist->isHidden())
+              tbDeletePlaylist->hide();
+          d->tbRemoveFromList->setEnabled(FALSE);
+          d->tbAddToList->setEnabled(TRUE);
+      }
+      break;
+      case 2:
+      {
+          videoView->clear();
+          populateVideoView();
+          if( !tbDeletePlaylist->isHidden())
+              tbDeletePlaylist->hide();
+          d->tbRemoveFromList->setEnabled(FALSE);
+          d->tbAddToList->setEnabled(TRUE);
+      }
+      break;
+      case 3:
+      {
+          if( tbDeletePlaylist->isHidden())
+              tbDeletePlaylist->show();
+          playLists->reread();
+      }
+      break;
+    };
+}
+
+void PlayListWidget::btnPlay(bool b) {
+
+//    mediaPlayerState->setPlaying(b);
+    switch ( tabWidget->currentPageIndex()) {
+      case 0:
+      {
+//            if( d->selectedFiles->current()->file().find(" ",0,TRUE) != -1
+//                if( d->selectedFiles->current()->file().find("%20",0,TRUE) != -1) {
+//                 QMessageBox::message("Note","You are trying to play\na malformed url.");
+//            } else {
+              mediaPlayerState->setPlaying(b);
+//          }
+    }
+      break;
+      case 1:
+      {
+          addToSelection( audioView->currentItem() );
+          mediaPlayerState->setPlaying(b);
+          d->selectedFiles->removeSelected( );
+          tabWidget->setCurrentPage(1);
+          d->selectedFiles->unSelect();
+          insanityBool=FALSE;
+      }//          audioView->clearSelection();
+      break;
+      case 2:
+      {
+          addToSelection( videoView->currentItem() );
+          mediaPlayerState->setPlaying(b);
+          qApp->processEvents();
+          d->selectedFiles->removeSelected( );
+          tabWidget->setCurrentPage(2);
+          d->selectedFiles->unSelect();
+          insanityBool=FALSE;
+      }//          videoView->clearSelection();
+      break;
+    };
+
+}
+
+void PlayListWidget::deletePlaylist() {
+    switch( QMessageBox::information( this, (tr("Remove Playlist?")),
+                                      (tr("You really want to delete\nthis playlist?")),
+                                      (tr("Yes")), (tr("No")), 0 )){
+      case 0: // Yes clicked,
+          QFile().remove(playLists->selected()->file());
+          QFile().remove(playLists->selected()->linkFile());
+          playLists->reread();
+          break;
+      case 1: // Cancel
+          break;
+    };
+}
+
+void PlayListWidget::viewPressed( int mouse, QListViewItem *item, const QPoint& point, int i)
+{
+    switch (mouse) {
+      case 1:
+          break;
+      case 2:{
+
+          QPopupMenu  m;
+          m.insertItem( tr( "Play" ), this, SLOT( playSelected() ));
+          m.insertItem( tr( "Add to Playlist" ), this, SLOT( addSelected() ));
+          m.insertSeparator();
+          if( QFile(QPEApplication::qpeDir()+"lib/libopie.so").exists() )
+              m.insertItem( tr( "Properties" ), this, SLOT( listDelete() ));
+
+          m.exec( QCursor::pos() );
+      }
+      break;
+    };
+}
+
+void PlayListWidget::playSelected()
+{
+    btnPlay( TRUE);
+//    d->selectedFiles->unSelect();
+}
+
+void PlayListWidget::playlistViewPressed( int mouse, QListViewItem *item, const QPoint& point, int i)
+{
+    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.insertSeparator();
+//     m.insertItem( tr( "Properties" ), this, SLOT( listDelete() ));
+          m.exec( QCursor::pos() );
+      }
+      break;
+    };
+
+}
+
+void PlayListWidget::listDelete() {
+    Config cfg( "OpiePlayer" );
+    cfg.setGroup("PlayList");
+    QString currentPlaylist = cfg.readEntry("CurrentPlaylist","");
+    QString file;
+    int noOfFiles = cfg.readNumEntry("NumberOfFiles", 0 );
+    switch ( tabWidget->currentPageIndex()) {
+      case 0:
+          break;
+      case 1:
+      {
+          file = audioView->selectedItem()->text(0);
+//           Global::findDocuments(&files, "audio/*");
+//           AppLnkSet appFiles;
+          QListIterator<DocLnk> dit( files.children() );
+          for ( ; dit.current(); ++dit ) {
+              if( dit.current()->name() == file) {
+//                  qDebug(file);
+                  LnkProperties prop( dit.current() );
+//  connect(&prop, SIGNAL(select(const AppLnk *)), this, SLOT(externalSelected(const AppLnk *)));
+                  prop.showMaximized();
+                  prop.exec();
+              }
+          }
+          populateAudioView();
+      }
+      break;
+      case 2:
+      {
+//           file = videoView->selectedItem()->text(0);
+//           for ( int i = 0; i < noOfFiles; i++ ) {
+//               QString entryName;
+//               entryName.sprintf( "File%i", i + 1 );
+//               QString linkFile = cfg.readEntry( entryName );
+//                   AppLnk lnk( AppLnk(linkFile));
+//               if( lnk.name() == file ) {
+//                   LnkProperties prop( &lnk);
+// //  connect(&prop, SIGNAL(select(const AppLnk *)), this, SLOT(externalSelected(const AppLnk *)));
+//                   prop.showMaximized();
+//                   prop.exec();
+//               }
+//            }
+      }
+      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( "opieplayer/musicfile" ));
+        }
+    }
+
+}
+
+void PlayListWidget::populateVideoView() {
+    videoView->clear();
+    StorageInfo storageInfo;
+    const QList<FileSystem> &fs = storageInfo.fileSystems();
+
+    if(!videoScan ) scanForVideo();
+
+    QListIterator<DocLnk> Vdit( vFiles.children() );
+    QListIterator<FileSystem> it ( fs );
+    videoView->clear();
+    QString storage;
+    for ( ; Vdit.current(); ++Vdit ) {
+        for( ; it.current(); ++it ){
+            const QString name = (*it)->name();
+            const QString path = (*it)->path();
+            if( Vdit.current()->file().find(path) != -1 ) storage=name;
+        }
+
+        QListViewItem * newItem;
+        if ( QFile( Vdit.current()->file()).exists() ) {
+            newItem= /*(void)*/ new QListViewItem( videoView, Vdit.current()->name(),
+                                                   QString::number( QFile( Vdit.current()->file()).size() ), storage);
+            newItem->setPixmap(0, Resource::loadPixmap( "opieplayer/videofile" ));
+        }
+    }
+}
+
+void PlayListWidget::openFile() {
+    QString filename, name;
+    InputDialog *fileDlg;
+    fileDlg = new InputDialog(this,tr("Open file or URL"),TRUE, 0);
+    fileDlg->exec();
+    if( fileDlg->result() == 1 ) {
+        filename = fileDlg->LineEdit1->text();
+// http://205.188.234.129:8030
+// http://66.28.68.70:8000
+//        filename.replace(QRegExp("%20")," ");
+        if(filename.find(" ",0,TRUE) != -1 || filename.find("%20",0,TRUE) != -1) {
+            QMessageBox::message("Note","Spaces in urls are not allowed.");
+            return;
+        } else {
+            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
+                if(filename.right(1) != "/" && filename.right(3) != "mp3" && filename.right(3) != "MP3")
+                    filename += "/";
+                lnk.setFile(filename); //sets File property
+
+                lnk.setType("audio/x-mpegurl");
+                lnk.setExec("opieplayer");
+                lnk.setIcon("opieplayer/MPEGPlayer");
+
+                if(!lnk.writeLink())
+                    qDebug("Writing doclink did not work");
+                d->selectedFiles->addToSelection(  lnk);
+//     if(fileDlg2)
+//         delete fileDlg2;
+            }
+        }
+    }
+    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 *e)
+{
+//    qDebug("Key press");
+//     switch ( e->key() ) {
+// ////////////////////////////// Zaurus keys
+//       case Key_A: //add to playlist
+//           qDebug("Add");
+//           addSelected();
+//           break;
+//       case Key_R: //remove from playlist
+//           removeSelected();
+//           break;
+//       case Key_P: //play
+//           qDebug("Play");
+//           playSelected();
+//           break;
+//       case Key_Space:
+//           qDebug("Play");
+//           playSelected();
+//           break;
+//     }
+}
+
+void PlayListWidget::doBlank() {
+    qDebug("do blanking");
+    fd=open("/dev/fb0",O_RDWR);
+    if (fd != -1) {
+        ioctl(fd,FBIOBLANK,1);
+//            close(fd);
+    }
+}
+
+void PlayListWidget::doUnblank() {
+      // this crashes opieplayer with a segfault
+//      int fd;
+//       fd=open("/dev/fb0",O_RDWR);
+    qDebug("do unblanking");
+    if (fd != -1) {
+        ioctl(fd,FBIOBLANK,0);
+        close(fd);
+    }
+    QCopEnvelope h("QPE/System", "setBacklight(int)");
+    h <<-3;// v[1]; // -3 Force on
+}
+
+void PlayListWidget::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()) {
+//        Lview->insertLine(t.readLine(),-1);
+            s=t.readLine();
+            if(s.find(" ",0,TRUE) != -1 || s.find("%20",0,TRUE) != -1) {
+                QMessageBox::message("Note","Spaces in urls are not allowed.");
+            }
+            else 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);
+                        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();
+//                         lnk.setIcon(opieplayer/MPEGPlayer);
+                        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;
+//                         name = name.right(name.length()-name.findRev("\\",-1,TRUE)-1);
+                        lnk.setName(name);
+                        if(s.at(s.length()-4) == '.')
+                            lnk.setFile( s);
+                        else
+                            lnk.setFile( s+"/");
+//                         lnk.setFile( filename);
+//                         lnk.setComment( s+"/");
+                        lnk.setType("audio/x-mpegurl");
+                        lnk.writeLink();
+//                          lnk.setIcon( "opieplayer/MPEGPlayer");
+//                          qDebug("add "+s);
+                        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();
+        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);
+//             QFileInfo f(s);
+//             QString name = f.baseName();
+//             name = name.left(name.length()-4);
+//             name = name.right(name.findRev("/",0,TRUE));
+                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++;
+    }
+}
+
diff --git a/noncore/multimedia/opieplayer2/playlistwidget.h b/noncore/multimedia/opieplayer2/playlistwidget.h
new file mode 100644
index 0000000..e44096b
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/playlistwidget.h
@@ -0,0 +1,107 @@
+
+#ifndef PLAY_LIST_WIDGET_H
+#define PLAY_LIST_WIDGET_H
+
+#include <qmainwindow.h>
+#include <qpe/applnk.h>
+#include <qtabwidget.h>
+#include <qpe/fileselector.h>
+#include <qpushbutton.h>
+
+/* #include <qtimer.h> */
+
+
+class PlayListWidgetPrivate;
+class Config;
+class QListViewItem;
+class QListView;
+class QPoint;
+class QAction;
+class QLabel;
+
+class PlayListWidget : public QMainWindow {
+    Q_OBJECT
+public:
+    PlayListWidget( QWidget* parent=0, const char* name=0, WFlags fl=0 );
+    ~PlayListWidget();
+    QTabWidget * tabWidget;
+    QAction *fullScreenButton, *scaleButton;
+    DocLnkSet files;
+    DocLnkSet vFiles;
+    QListView *audioView, *videoView, *playlistView;
+    QLabel *libString;
+    bool fromSetDocument;
+    bool insanityBool;
+    QString setDocFileRef;
+    // retrieve the current playlist entry (media file link)
+    const DocLnk *current();
+    void useSelectedDocument();
+/*     QTimer    * menuTimer; */
+    FileSelector*  playLists;
+    QPushButton *tbDeletePlaylist;
+    int fd, selected;
+public slots:
+    bool first();
+    bool last();
+    bool next();
+    bool prev();
+/*     void setFullScreen(); */
+/*     void setScaled(); */
+protected:
+/*     void contentsMousePressEvent( QMouseEvent * e ); */
+/*     void contentsMouseReleaseEvent( QMouseEvent * e ); */
+void keyReleaseEvent( QKeyEvent *e);
+void keyPressEvent( QKeyEvent *e);
+private:
+    bool audioScan, videoScan;
+    void doBlank();
+    void doUnblank();
+    void readm3u(const QString &);
+    void readPls(const QString &);
+
+
+    void initializeStates();
+    void readConfig( Config& cfg );
+    void writeConfig( Config& cfg ) const;
+    PlayListWidgetPrivate *d; // Private implementation data
+    void populateAudioView();
+    void populateVideoView();
+private slots:
+    void writem3u();
+    void scanForAudio();
+    void scanForVideo();
+    void openFile();
+    void setDocument( const QString& fileref );
+    void addToSelection( const DocLnk& ); // Add a media file to the playlist
+    void addToSelection( QListViewItem* ); // Add a media file to the playlist
+    void setActiveWindow(); // need to handle this to show the right view
+    void setPlaylist( bool ); // Show/Hide the playlist
+    void setView( char );
+    void clearList();
+    void addAllToList();
+    void addAllMusicToList();
+    void addAllVideoToList();
+    void saveList();  // Save the playlist
+    void loadList( const DocLnk &);  // Load a playlist
+    void playIt( QListViewItem *);
+
+    void btnPlay(bool);
+    void deletePlaylist();
+    void addSelected();
+    void removeSelected();
+    void tabChanged(QWidget*);
+    void viewPressed( int, QListViewItem *, const QPoint&, int);
+    void playlistViewPressed( int, QListViewItem *, const QPoint&, int);
+    void playSelected();
+    void listDelete();
+
+protected slots:
+/*     void cancelMenuTimer(); */
+/*     void showFileMenu(); */
+
+
+};
+
+
+#endif // PLAY_LIST_WIDGET_H
+
diff --git a/noncore/multimedia/opieplayer2/videowidget.cpp b/noncore/multimedia/opieplayer2/videowidget.cpp
new file mode 100644
index 0000000..5625c0e
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/videowidget.cpp
@@ -0,0 +1,473 @@
+
+#include <qpe/resource.h>
+#include <qpe/mediaplayerplugininterface.h>
+#include <qpe/config.h>
+
+#include <qwidget.h>
+#include <qpainter.h>
+#include <qpixmap.h>
+#include <qslider.h>
+#include <qdrawutil.h>
+#include "videowidget.h"
+#include "mediaplayerstate.h"
+
+
+#ifdef Q_WS_QWS
+# define USE_DIRECT_PAINTER
+# include <qdirectpainter_qws.h>
+# include <qgfxraster_qws.h>
+#endif
+
+
+extern MediaPlayerState *mediaPlayerState;
+
+
+static const int xo = 2; // movable x offset
+static const int yo = 0; // movable y offset
+
+
+struct MediaButton {
+    int  xPos, yPos;
+    bool isToggle, isHeld, isDown;
+    int  controlType;
+};
+
+
+// Layout information for the videoButtons (and if it is a toggle button or not)
+MediaButton videoButtons[] = {
+    { 5+0*32+xo, 200+yo, FALSE, FALSE, FALSE, 4 }, // previous
+    { 5+1*32+xo, 200+yo, FALSE, FALSE, FALSE, 1 }, // stop
+    { 5+2*32+xo, 200+yo,  TRUE, FALSE, FALSE, 0 }, // play
+    { 5+3*32+xo, 200+yo,  TRUE, FALSE, FALSE, 2 }, // pause
+    { 5+4*32+xo, 200+yo, FALSE, FALSE, FALSE, 3 }, // next
+    { 5+5*32+xo, 200+yo, FALSE, FALSE, FALSE, 8 }, // playlist
+    { 5+6*32+xo, 200+yo,  TRUE, FALSE, FALSE, 9 }  // fullscreen
+};
+
+
+static const int numButtons = (sizeof(videoButtons)/sizeof(MediaButton));
+
+
+VideoWidget::VideoWidget(QWidget* parent, const char* name, WFlags f) :
+    QWidget( parent, name, f ), scaledWidth( 0 ), scaledHeight( 0 ) {
+    setCaption( tr("OpiePlayer - Video") );
+    Config cfg("OpiePlayer");
+    cfg.setGroup("VideoWidget");
+
+    QString backgroundPix, Button0aPix, Button0bPix, controlsPix;
+    backgroundPix=cfg.readEntry( "backgroundPix", "opieplayer/metalFinish");
+    Button0aPix=cfg.readEntry( "Button0aPix", "opieplayer/mediaButton0a");
+    Button0bPix=cfg.readEntry( "Button0bPix","opieplayer/mediaButton0b");
+    controlsPix=cfg.readEntry( "controlsPix","opieplayer/mediaControls0" );
+
+    setBackgroundPixmap( Resource::loadPixmap( backgroundPix) );
+    pixmaps[0] = new QPixmap( Resource::loadPixmap( Button0aPix ) );
+    pixmaps[1] = new QPixmap( Resource::loadPixmap( Button0bPix ) );
+    pixmaps[2] = new QPixmap( Resource::loadPixmap( controlsPix) );
+    currentFrame = new QImage( 220 + 2, 160, (QPixmap::defaultDepth() == 16) ? 16 : 32 );
+
+    slider = new QSlider( Qt::Horizontal, this );
+    slider->setMinValue( 0 );
+    slider->setMaxValue( 1 );
+    slider->setBackgroundPixmap( Resource::loadPixmap( backgroundPix ) );
+    slider->setFocusPolicy( QWidget::NoFocus );
+    slider->setGeometry( QRect( 7, 250, 220, 20 ) );
+
+    connect( slider,         SIGNAL( sliderPressed() ),      this, SLOT( sliderPressed() ) );
+    connect( slider,         SIGNAL( sliderReleased() ),     this, SLOT( sliderReleased() ) );
+
+    connect( mediaPlayerState, SIGNAL( lengthChanged(long) ),  this, SLOT( setLength(long) ) );
+    connect( mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
+    connect( mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
+    connect( mediaPlayerState, SIGNAL( viewChanged(char) ),    this, SLOT( setView(char) ) );
+    connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( setPaused(bool) ) );
+    connect( mediaPlayerState, SIGNAL( playingToggled(bool) ), this, SLOT( setPlaying(bool) ) );
+
+    // Intialise state
+    setLength( mediaPlayerState->length() );
+    setPosition( mediaPlayerState->position() );
+    setFullscreen( mediaPlayerState->fullscreen() );
+    setPaused( mediaPlayerState->paused() );
+    setPlaying( mediaPlayerState->playing() );
+}
+
+
+VideoWidget::~VideoWidget() {
+    for ( int i = 0; i < 3; i++ ) {
+        delete pixmaps[i];
+    }
+    delete currentFrame;
+}
+
+
+static bool videoSliderBeingMoved = FALSE;
+
+
+void VideoWidget::sliderPressed() {
+    videoSliderBeingMoved = TRUE;
+}
+
+
+void VideoWidget::sliderReleased() {
+    videoSliderBeingMoved = FALSE;
+    if ( slider->width() == 0 ) {
+        return;
+    }
+    long val = long((double)slider->value() * mediaPlayerState->length() / slider->width());
+    mediaPlayerState->setPosition( val );
+}
+
+
+void VideoWidget::setPosition( long i ) {
+    updateSlider( i, mediaPlayerState->length() );
+}
+
+
+void VideoWidget::setLength( long max ) {
+    updateSlider( mediaPlayerState->position(), max );
+}
+
+
+void VideoWidget::setView( char view ) {
+    if ( view == 'v' ) {
+        makeVisible();
+    } else {
+        // Effectively blank the view next time we show it so it looks nicer
+        scaledWidth = 0;
+        scaledHeight = 0;
+        hide();
+    }
+}
+
+
+void VideoWidget::updateSlider( long i, long max ) {
+    // Will flicker too much if we don't do this
+    if ( max == 0 ) {
+        return;
+    }
+    int width = slider->width();
+    int val = int((double)i * width / max);
+    if ( !mediaPlayerState->fullscreen() && !videoSliderBeingMoved ) {
+        if ( slider->value() != val ) {
+            slider->setValue( val );
+        }
+        if ( slider->maxValue() != width ) {
+            slider->setMaxValue( width );
+        }
+    }
+}
+
+
+void VideoWidget::setToggleButton( int i, bool down ) {
+    if ( down != videoButtons[i].isDown ) {
+        toggleButton( i );
+    }
+}
+
+
+void VideoWidget::toggleButton( int i ) {
+    videoButtons[i].isDown = !videoButtons[i].isDown;
+    QPainter p(this);
+    paintButton ( &p, i );
+}
+
+
+void VideoWidget::paintButton( QPainter *p, int i ) {
+    int x = videoButtons[i].xPos;
+    int y = videoButtons[i].yPos;
+    int offset = 10 + videoButtons[i].isDown;
+    p->drawPixmap( x, y, *pixmaps[videoButtons[i].isDown] );
+    p->drawPixmap( x + 1 + offset, y + offset, *pixmaps[2], 9 * videoButtons[i].controlType, 0, 9, 9 );
+}
+
+
+void VideoWidget::mouseMoveEvent( QMouseEvent *event ) {
+    for ( int i = 0; i < numButtons; i++ ) {
+        int x = videoButtons[i].xPos;
+        int y = videoButtons[i].yPos;
+        if ( event->state() == QMouseEvent::LeftButton ) {
+              // The test to see if the mouse click is inside the circular button or not
+              // (compared with the radius squared to avoid a square-root of our distance)
+            int radius = 16;
+            QPoint center = QPoint( x + radius, y + radius );
+            QPoint dXY = center - event->pos();
+            int dist = dXY.x() * dXY.x() + dXY.y() * dXY.y();
+            bool isOnButton = dist <= (radius * radius);
+            if ( isOnButton != videoButtons[i].isHeld ) {
+                videoButtons[i].isHeld = isOnButton;
+                toggleButton(i);
+            }
+        } else {
+            if ( videoButtons[i].isHeld ) {
+                videoButtons[i].isHeld = FALSE;
+                if ( !videoButtons[i].isToggle )
+                    setToggleButton( i, FALSE );
+            }
+        }
+        switch (i) {
+          case VideoPlay:       mediaPlayerState->setPlaying(videoButtons[i].isDown); return;
+          case VideoStop:       mediaPlayerState->setPlaying(FALSE); return;
+          case VideoPause:      mediaPlayerState->setPaused(videoButtons[i].isDown); return;
+          case VideoNext:       mediaPlayerState->setNext(); return;
+          case VideoPrevious:   mediaPlayerState->setPrev(); return;
+          case VideoPlayList:   mediaPlayerState->setList(); return;
+          case VideoFullscreen: mediaPlayerState->setFullscreen( TRUE ); makeVisible(); return;
+        }
+
+    }
+}
+
+
+void VideoWidget::mousePressEvent( QMouseEvent *event ) {
+    mouseMoveEvent( event );
+}
+
+
+void VideoWidget::mouseReleaseEvent( QMouseEvent *event ) {
+    if ( mediaPlayerState->fullscreen() ) {
+        mediaPlayerState->setFullscreen( FALSE );
+        makeVisible();
+
+        mouseMoveEvent( event );
+    }
+}
+
+
+void VideoWidget::makeVisible() {
+    if ( mediaPlayerState->fullscreen() ) {
+        setBackgroundMode( QWidget::NoBackground );
+        showFullScreen();
+        resize( qApp->desktop()->size() );
+        slider->hide();
+    } else {
+        setBackgroundPixmap( Resource::loadPixmap( "opieplayer/metalFinish" ) );
+        showNormal();
+        showMaximized();
+        slider->show();
+    }
+}
+
+
+void VideoWidget::paintEvent( QPaintEvent * ) {
+    QPainter p( this );
+
+    if ( mediaPlayerState->fullscreen() ) {
+        // Clear the background
+        p.setBrush( QBrush( Qt::black ) );
+        p.drawRect( rect() );
+
+        // Draw the current frame
+        //p.drawImage( ); // If using directpainter we won't have a copy except whats on the screen
+    } else {
+        // draw border
+        qDrawShadePanel( &p, 4, 15, 230, 170, colorGroup(), TRUE, 5, NULL );
+
+        // Clear the movie screen first
+        p.setBrush( QBrush( Qt::black ) );
+        p.drawRect( 9, 20, 220, 160 );
+
+        // draw current frame (centrally positioned from scaling to maintain aspect ratio)
+        p.drawImage( 9 + (220 - scaledWidth) / 2, 20 + (160 - scaledHeight) / 2, *currentFrame, 0, 0, scaledWidth, scaledHeight );
+
+        // draw the buttons
+        for ( int i = 0; i < numButtons; i++ ) {
+            paintButton( &p, i );
+        }
+
+        // draw the slider
+        slider->repaint( TRUE );
+    }
+}
+
+
+void VideoWidget::closeEvent( QCloseEvent* ) {
+    mediaPlayerState->setList();
+}
+
+
+bool VideoWidget::playVideo() {
+    bool result = FALSE;
+
+    int stream = 0;
+
+    int sw = 240;     //mediaPlayerState->curDecoder()->videoWidth( stream );
+    int sh = 320;    //mediaPlayerState->curDecoder()->videoHeight( stream );
+    int dd = QPixmap::defaultDepth();
+    int w = height();
+    int h = width();
+
+    ColorFormat format = (dd == 16) ? RGB565 : BGRA8888;
+
+    if ( mediaPlayerState->fullscreen() ) {
+#ifdef USE_DIRECT_PAINTER
+        QDirectPainter p(this);
+
+        if ( ( qt_screen->transformOrientation() == 3 ) &&
+             ( ( dd == 16 ) || ( dd == 32 ) ) && ( p.numRects() == 1 ) ) {
+
+            w = 320;
+            h = 240;
+
+            if ( mediaPlayerState->scaled() ) {
+                // maintain aspect ratio
+                if ( w * sh > sw * h )
+                    w = sw * h / sh;
+                else
+                    h = sh * w / sw;
+            } else  {
+                w = sw;
+                h = sh;
+            }
+
+            w--; // we can't allow libmpeg to overwrite.
+            QPoint roff = qt_screen->mapToDevice( p.offset(), QSize( qt_screen->width(), qt_screen->height() ) );
+
+            int ox = roff.x() - height() + 2 + (height() - w) / 2;
+            int oy = roff.y() + (width() - h) / 2;
+            int sx = 0, sy = 0;
+
+            uchar* fp = p.frameBuffer() + p.lineStep() * oy;
+            fp += dd * ox / 8;
+            uchar **jt = new uchar*[h];
+            for ( int i = h; i; i-- ) {
+                jt[h - i] = fp;
+                fp += p.lineStep();
+            }
+
+            result = 42;   //mediaPlayerState->curDecoder()->videoReadScaledFrame( jt, sx, sy, sw, sh, w, h, format, 0) == 0;
+
+            delete [] jt;
+        } else {
+#endif
+            QPainter p(this);
+
+            w = 320;
+            h = 240;
+
+            if ( mediaPlayerState->scaled() ) {
+                // maintain aspect ratio
+                if ( w * sh > sw * h ) {
+                    w = sw * h / sh;
+                } else {
+                    h = sh * w / sw;
+                }
+            } else  {
+                w = sw;
+                h = sh;
+            }
+
+            int bytes = ( dd == 16 ) ? 2 : 4;
+            QImage tempFrame( w, h, bytes << 3 );
+            result = 42; // mediaPlayerState->curDecoder()->videoReadScaledFrame( tempFrame.jumpTable(),
+            //                                                0, 0, sw, sh, w, h, format, 0) == 0;
+            if ( result && mediaPlayerState->fullscreen() ) {
+
+                int rw = h, rh = w;
+                QImage rotatedFrame( rw, rh, bytes << 3 );
+
+                ushort* in  = (ushort*)tempFrame.bits();
+                ushort* out = (ushort*)rotatedFrame.bits();
+                int spl = rotatedFrame.bytesPerLine() / bytes;
+                for (int x=0; x<h; x++) {
+                    if ( bytes == 2 ) {
+                        ushort* lout = out++ + (w - 1)*spl;
+                        for (int y=0; y<w; y++) {
+                            *lout=*in++;
+                            lout-=spl;
+                        }
+                    } else {
+                        ulong* lout = ((ulong *)out)++ + (w - 1)*spl;
+                        for (int y=0; y<w; y++) {
+                            *lout=*((ulong*)in)++;
+                            lout-=spl;
+                        }
+                    }
+                }
+
+                p.drawImage( (240 - rw) / 2, (320 - rh) / 2, rotatedFrame, 0, 0, rw, rh );
+            }
+#ifdef USE_DIRECT_PAINTER
+        }
+#endif
+    } else {
+
+        w = 220;
+        h = 160;
+
+        // maintain aspect ratio
+        if ( w * sh > sw * h ) {
+            w = sw * h / sh;
+        } else {
+            h = sh * w / sw;
+        }
+
+        result = 42 ; //mediaPlayerState->curDecoder()->videoReadScaledFrame( currentFrame->jumpTable(), 0, 0, sw, sh, w, h, format, 0) == 0;
+
+        QPainter p( this );
+
+  // Image changed size, therefore need to blank the possibly unpainted regions first
+        if ( scaledWidth != w || scaledHeight != h ) {
+            p.setBrush( QBrush( Qt::black ) );
+            p.drawRect( 9, 20, 220, 160 );
+        }
+
+        scaledWidth = w;
+        scaledHeight = h;
+
+        if ( result ) {
+            p.drawImage( 9 + (220 - scaledWidth) / 2, 20 + (160 - scaledHeight) / 2, *currentFrame, 0, 0, scaledWidth, scaledHeight );
+        }
+    }
+    return result;
+}
+
+
+
+void VideoWidget::keyReleaseEvent( QKeyEvent *e)
+{
+    switch ( e->key() ) {
+////////////////////////////// Zaurus keys
+      case Key_Home:
+          break;
+      case Key_F9: //activity
+          break;
+      case Key_F10: //contacts
+//           hide();
+          break;
+      case Key_F11: //menu
+          break;
+      case Key_F12: //home
+          break;
+      case Key_F13: //mail
+          break;
+      case Key_Space: {
+          if(mediaPlayerState->playing()) {
+              mediaPlayerState->setPlaying(FALSE);
+          } else {
+              mediaPlayerState->setPlaying(TRUE);
+          }
+      }
+          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:
+          mediaPlayerState->setNext();
+          break;
+      case Key_Left:
+          mediaPlayerState->setPrev();
+          break;
+      case Key_Escape:
+          break;
+
+    };
+}
diff --git a/noncore/multimedia/opieplayer2/videowidget.h b/noncore/multimedia/opieplayer2/videowidget.h
new file mode 100644
index 0000000..e18edd1
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/videowidget.h
@@ -0,0 +1,67 @@
+
+#ifndef VIDEO_WIDGET_H
+#define VIDEO_WIDGET_H
+
+
+#include <qwidget.h>
+
+class QPixmap;
+class QSlider;
+
+enum VideoButtons {
+    VideoPrevious,
+    VideoStop,
+    VideoPlay,
+    VideoPause,
+    VideoNext,
+    VideoPlayList,
+    VideoFullscreen
+};
+
+class VideoWidget : public QWidget {
+    Q_OBJECT
+public:
+    VideoWidget( QWidget* parent=0, const char* name=0, WFlags f=0 );
+    ~VideoWidget();
+
+    bool playVideo();
+
+public slots:
+    void updateSlider( long, long );
+    void sliderPressed( );
+    void sliderReleased( );
+    void setPaused( bool b)      { setToggleButton( VideoPause, b ); }
+    void setPlaying( bool b)     { setToggleButton( VideoPlay, b ); }
+    void setFullscreen( bool b ) { setToggleButton( VideoFullscreen, b ); }
+    void makeVisible();
+    void setPosition( long );
+    void setLength( long );
+    void setView( char );
+
+signals:
+    void sliderMoved( long );
+
+protected:
+    void paintEvent( QPaintEvent *pe );
+    void mouseMoveEvent( QMouseEvent *event );
+    void mousePressEvent( QMouseEvent *event );
+    void mouseReleaseEvent( QMouseEvent *event );
+    void closeEvent( QCloseEvent *event );
+    void keyReleaseEvent( QKeyEvent *e);
+
+private:
+    void paintButton( QPainter *p, int i );
+    void toggleButton( int );
+    void setToggleButton( int, bool );
+
+    QSlider *slider;
+    QPixmap *pixmaps[3];
+    QImage *currentFrame;
+    int scaledWidth;
+    int scaledHeight;
+};
+
+#endif // VIDEO_WIDGET_H
+
+
+