cleanups

2 files changed, 4 insertions, 17 deletions

diff --git a/noncore/multimedia/opieplayer2/playlistwidget.cpp b/noncore/multimedia/opieplayer2/playlistwidget.cpp
index cd53748..cce445b 100644
--- a/noncore/multimedia/opieplayer2/playlistwidget.cpp
+++ b/noncore/multimedia/opieplayer2/playlistwidget.cpp
@@ -1,98 +1,97 @@
 
-// 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 "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 MediaPlayerState *mediaPlayerState;
 
 
 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 );
     }
diff --git a/noncore/multimedia/opieplayer2/videowidget.cpp b/noncore/multimedia/opieplayer2/videowidget.cpp
index d3898a0..bce6b89 100644
--- a/noncore/multimedia/opieplayer2/videowidget.cpp
+++ b/noncore/multimedia/opieplayer2/videowidget.cpp
@@ -29,360 +29,348 @@
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #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() );
 
-    videoFrame = new XineVideoWidget( 200, 150 ,this, "Video frame" );
-    videoFrame->setGeometry( QRect( 10, 20, 220, 160  ) );
+    videoFrame = new XineVideoWidget( 240, 155 ,this, "Video frame" );
+    videoFrame->setGeometry( QRect( 0, 15 , 240 ,170  ) );
 }
 
 
 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() );
+      p.setBrush( QBrush( Qt::black ) );
+      videoFrame->setGeometry( QRect( 0, 0 , 240 ,340  ) );
 
     } 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 );
-//	videoFrame->repaint( TRUE );
     }
 }
 
 
 void VideoWidget::closeEvent( QCloseEvent* ) {
     mediaPlayerState->setList();
 }
 
 
 bool VideoWidget::playVideo() {
     bool result = FALSE;
 
     int stream = 0;
 
     int sw = 240;
     int sh = 320;
     int dd = QPixmap::defaultDepth();
     int w = height();
     int h = width();
 
     return true;
 }
 
 
 
 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;
 
     };
 }
 XineVideoWidget* VideoWidget::vidWidget() {
     return videoFrame;
 }