summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/multimedia/opieplayer2/audiowidget.cpp341
-rw-r--r--noncore/multimedia/opieplayer2/audiowidget.h125
-rw-r--r--noncore/multimedia/opieplayer2/inputDialog.cpp67
-rw-r--r--noncore/multimedia/opieplayer2/inputDialog.h30
-rw-r--r--noncore/multimedia/opieplayer2/main.cpp33
-rw-r--r--noncore/multimedia/opieplayer2/mediaplayer.cpp203
-rw-r--r--noncore/multimedia/opieplayer2/mediaplayer.h43
-rw-r--r--noncore/multimedia/opieplayer2/mediaplayerstate.cpp78
-rw-r--r--noncore/multimedia/opieplayer2/mediaplayerstate.h100
-rw-r--r--noncore/multimedia/opieplayer2/opie-mediaplayer2.control9
-rw-r--r--noncore/multimedia/opieplayer2/opieplayer2.pro17
-rw-r--r--noncore/multimedia/opieplayer2/playlistselection.cpp215
-rw-r--r--noncore/multimedia/opieplayer2/playlistselection.h63
-rw-r--r--noncore/multimedia/opieplayer2/playlistwidget.cpp1348
-rw-r--r--noncore/multimedia/opieplayer2/playlistwidget.h107
-rw-r--r--noncore/multimedia/opieplayer2/videowidget.cpp473
-rw-r--r--noncore/multimedia/opieplayer2/videowidget.h67
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
+
+
+