9 files changed, 126 insertions, 60 deletions

diff --git a/noncore/multimedia/opieplayer2/lib.cpp b/noncore/multimedia/opieplayer2/lib.cpp
index eb57b67..00c534a 100644
--- a/noncore/multimedia/opieplayer2/lib.cpp
+++ b/noncore/multimedia/opieplayer2/lib.cpp
@@ -42,93 +42,96 @@ Lib::Lib(XineVideoWidget* widget) {
     // get the configuration
     m_config = xine_config_file_init( str.data() );
 
     // allocate oss for sound
     // and fb for framebuffer
     m_audioOutput= xine_load_audio_output_plugin( m_config, "oss") ;
     if (m_audioOutput == NULL )
         printf("Failure\n");
     else
         printf("Success\n");
 
 
     // test code
 /*    m_videoOutput = xine_load_video_output_plugin(m_config, "fb",
                                                   VISUAL_TYPE_FB,
                                                   0 );
 */
 
     char** files = xine_list_video_output_plugins(3);
     char* out;
     int i = 0;
     while ( ( out = files[i] ) != 0 ) {
         printf("Video %s\n", out );
         i++;
     }
 //    m_xine = xine_init( m_videoOutput,
 //                      m_audioOutput,
 //                      m_config );
     // test loading
     m_videoOutput = ::init_video_out_plugin( m_config, NULL );
     if (m_wid != 0 ) {
         printf("!0\n" );
-        ::null_set_gui_width( m_videoOutput,  m_wid->image()->width() );
-        ::null_set_gui_height(m_videoOutput,  m_wid->image()->height() );
+        resize ( m_wid-> size ( ));
         ::null_set_mode( m_videoOutput, qt_screen->depth(), qt_screen->pixelType() );
-        m_bytes_per_pixel = ( qt_screen->depth() + 7 ) / 8;
-        QImage image = Resource::loadImage("");
-        image = image.smoothScale( m_wid->width(), m_wid->height() );
-        QImage* img = new QImage( image );
-        m_wid->setImage( img );
+        m_wid-> setImage ( new QImage ( Resource::loadImage("")));
         m_wid->repaint();
     }
     null_display_handler( m_videoOutput,
                           xine_display_frame,
                           this );
 
     m_xine = xine_init( m_videoOutput,
                         m_audioOutput, m_config );
     // install the event handler
     xine_register_event_listener( m_xine, xine_event_handler, this );
 }
 
 Lib::~Lib() {
     delete m_config;
     xine_remove_event_listener( m_xine, xine_event_handler );
     xine_exit( m_xine );
     delete m_videoOutput;
     //delete m_audioOutput;
 
 }
 
+void Lib::resize ( const QSize &s )
+{
+        if ( s. width ( ) && s. height ( )) {
+                ::null_set_gui_width( m_videoOutput,  s. width() );
+                ::null_set_gui_height(m_videoOutput,  s. height() );
+        }
+}
+
 QCString Lib::version() {
     QCString str( xine_get_str_version() );
     return str;
 };
 
 int Lib::majorVersion() {
     return xine_get_major_version();
 }
 int Lib::minorVersion() {
     return xine_get_minor_version();
 };
 
 int Lib::subVersion() {
     return xine_get_sub_version();
 }
 int Lib::play( const QString& fileName,
                int startPos,
                int start_time ) {
     QString str = fileName.stripWhiteSpace();
     //workaround OpiePlayer bug
     if (str.right(1) == QString::fromLatin1("/") )
         str = str.mid( str.length() -1 );
     return xine_play( m_xine, QFile::encodeName(str.utf8() ).data(),
                startPos, start_time);
 }
 void Lib::stop() {
     xine_stop(m_xine );
 }
 void Lib::pause(){
     xine_set_speed( m_xine, SPEED_PAUSE );
 }
 int Lib::speed() {
@@ -158,52 +161,46 @@ Frame Lib::currentFrame() {
 };
 int Lib::error() {
     return xine_get_error( m_xine );
 };
 void Lib::handleXineEvent( xine_event_t* t ) {
     if ( t->type == XINE_EVENT_PLAYBACK_FINISHED )
         emit stopped();
 }
 void Lib::setShowVideo( bool video ) {
     m_video = video;
     ::null_set_show_video( m_videoOutput,  video );
 }
 bool Lib::isShowingVideo() {
     return ::null_is_showing_video( m_videoOutput );
 }
 void Lib::showVideoFullScreen( bool fullScreen ) {
     ::null_set_fullscreen( m_videoOutput, fullScreen );
 }
 bool Lib::isVideoFullScreen() {
     return ::null_is_fullscreen( m_videoOutput );
 }
 void Lib::setScaling( bool scale ) {
     ::null_set_scaling( m_videoOutput, scale  );
 }
 bool Lib::isScaling() {
     return ::null_is_scaling( m_videoOutput );
 }
 void Lib::xine_event_handler( void* user_data, xine_event_t* t ) {
     ((Lib*)user_data)->handleXineEvent( t );
 }
 void Lib::xine_display_frame( void* user_data, uint8_t *frame,
                               int width,  int height,  int bytes ) {
-//    printf("display x frame");
-    ((Lib*)user_data)->drawFrame( frame,  width, height,  bytes );
-//    printf("displayed x frame\n");
+
+    ((Lib*)user_data)->drawFrame( frame,  width, height, bytes );
 }
 void Lib::drawFrame( uint8_t* frame,  int width,  int height,  int bytes ) {
     if (!m_video ) {
         qWarning("not showing video now");
         return;
     }
 //    qWarning("called draw frame %d %d",  width,  height);
 
-    QSize size = m_wid->size();
-    int xoffset  = (size.width() - width) / 2;
-    int yoffset  = (size.height() - height) / 2;
-    int linestep = qt_screen->linestep();
-
-    m_wid->setImage( frame, yoffset, xoffset, width, height, linestep, bytes, m_bytes_per_pixel );
+    m_wid->setImage( frame, width, height, bytes );
 //    m_wid->repaint(false);
 
 }
diff --git a/noncore/multimedia/opieplayer2/lib.h b/noncore/multimedia/opieplayer2/lib.h
index d568a32..a15f362 100644
--- a/noncore/multimedia/opieplayer2/lib.h
+++ b/noncore/multimedia/opieplayer2/lib.h
@@ -3,64 +3,66 @@
 #ifndef ZECKEXINELIB_H
 #define ZECKEXINELIB_H
 
 #include <qcstring.h>
 #include <qstring.h>
 #include <qobject.h>
 
 #include <xine.h>
 
 class XineVideoWidget;
 
 namespace XINE {
 
     /**
      * Lib wrapps the simple interface
      * of libxine for easy every day use
      * This will become a full C++ Wrapper
      * It supports playing, pausing, info,
      * stooping, seeking.
      */
     class Frame;
     class Lib : public QObject {
         Q_OBJECT
     public:
         Lib(XineVideoWidget* = 0);
         ~Lib();
         QCString version();
         int majorVersion()/*const*/;
         int minorVersion()/*const*/;
         int subVersion()/*const*/;
 
 
+                void resize ( const QSize &s );
+
         int play( const QString& fileName,
                   int startPos = 0,
                   int start_time = 0 );
         void stop() /*const*/;
         void pause()/*const*/;
 
         int speed() /*const*/;
         void setSpeed( int speed = SPEED_PAUSE );
 
         int status() /*const*/;
 
         int currentPosition()/*const*/;
         //in seconds
         int currentTime()/*const*/;
         int length() /*const*/;
 
         bool isSeekable()/*const*/;
 
         /**
          * Whether or not to show video output
          */
         void setShowVideo(bool video);
 
         /**
          * is we show video
          */
         bool isShowingVideo() /*const*/;
 
         /**
          *
          */
         void showVideoFullScreen( bool fullScreen );
diff --git a/noncore/multimedia/opieplayer2/nullvideo.c b/noncore/multimedia/opieplayer2/nullvideo.c
index 3a18a40..5ee8d5d 100644
--- a/noncore/multimedia/opieplayer2/nullvideo.c
+++ b/noncore/multimedia/opieplayer2/nullvideo.c
@@ -35,64 +35,65 @@ struct null_driver_s {
     uint8_t *yuv2rgb_cmap;
     yuv2rgb_factory_t *yuv2rgb_factory;
     vo_overlay_t *overlay;
     int user_ratio;
     double output_scale_factor;
     int last_frame_output_width;
     int last_frame_output_height;
     int gui_width;
     int gui_height;
     int gui_changed;
     double display_ratio;
     void* caller;
     display_xine_frame_t frameDis;
 
 
 };
 typedef struct opie_frame_s opie_frame_t;
 struct opie_frame_s {
     vo_frame_t frame;
     char* name;
     int version;
     int width;
     int height;
     int ratio_code;
     int format;
     int flags;
     int user_ratio;
 
     double ratio_factor;
     int ideal_width;
     int ideal_height;
     int output_width, output_height;
+    int gui_width, gui_height;
     uint8_t *chunk[3];
 
     yuv2rgb_t *yuv2rgb;
     uint8_t *rgb_dst;
     int yuv_stride;
     int stripe_height, stripe_inc;
   
     int bytes_per_line;
     uint8_t *data;
 
 //    int show_video;
     null_driver_t *output;
 };
 
 static uint32_t null_get_capabilities(vo_driver_t *self ){   
     null_driver_t* this = (null_driver_t*)self;
     printf("capabilities\n");
     return this->m_capabilities;
 }
 
 static void null_frame_copy (vo_frame_t *vo_img, uint8_t **src) {
   opie_frame_t  *frame = (opie_frame_t *) vo_img ;
   printf("frame copy\n");
   if(!frame->output->m_show_video ){ printf("no video\n"); return; } // no video
 
   if (frame->format == IMGFMT_YV12) {
       frame->yuv2rgb->yuv2rgb_fun (frame->yuv2rgb, frame->rgb_dst,
                                    src[0], src[1], src[2]);
   } else {
 
       frame->yuv2rgb->yuy22rgb_fun (frame->yuv2rgb, frame->rgb_dst,
                                     src[0]);
@@ -264,75 +265,77 @@ static void null_compute_rgb_size (null_driver_t *this, opie_frame_t *frame) {
            frame->output_width, frame->output_height,
            ( frame->width != frame->output_width
              || frame->height != frame->output_height
              ? ", software scaling"
              : "" )
            );
 #endif
 }
 
 
 // size specific
 
 
 static void null_update_frame_format( vo_driver_t* self, vo_frame_t* img,
                                       uint32_t width, uint32_t height,
                                       int ratio_code, int format, int flags ){
     null_driver_t* this = (null_driver_t*) self;
     opie_frame_t*  frame = (opie_frame_t*)img;
     /* not needed now */
     printf("update_frame_format\n");
     printf("al crash aye?\n");
 
     flags &= VO_BOTH_FIELDS;
 
     /* find out if we need to adapt this frame */
 
     if ((width != frame->width)
         || (height != frame->height)
         || (ratio_code != frame->ratio_code)
         || (flags != frame->flags)
         || (format != frame->format)
         || (this->user_ratio != frame->user_ratio)
-        || this->gui_changed ) {
+        || (this->gui_width != frame-> gui_width )
+        || (this-> gui_height != frame-> gui_height)) {
 
         frame->width      = width;
         frame->height     = height;
         frame->ratio_code = ratio_code;
         frame->flags      = flags;
         frame->format     = format;
         frame->user_ratio = this->user_ratio;
         this->gui_changed = 0;
         //frame->show_video = this->m_show_video;
-
+    frame->gui_width  = this->gui_width;
+    frame->gui_height = this->gui_height;
         
             null_compute_ideal_size (this, frame);
             null_compute_rgb_size (this, frame);
         
         /*
          * (re-) allocate 
          */
         if( frame->data ) {
             if(frame->chunk[0] ){
                 free( frame->chunk[0] );
                         frame->chunk[0] = NULL;
             }
             if(frame->chunk[1] ){
                 free ( frame->chunk[1] );
                 frame->chunk[1] = NULL;
                     }
             if(frame->chunk[2] ){
                 free ( frame->chunk[2] );
                 frame->chunk[2] = NULL;
             }
             free ( frame->data );
         }
         printf("after freeing\n");
         frame->data = xine_xmalloc (frame->output_width * frame->output_height *
                                     this->bytes_per_pixel );
 
         if( format == IMGFMT_YV12 ) {
             int image_size = width * height; /* cast ouch*/
             frame->frame.base[0] = xine_xmalloc_aligned(16, image_size,
                                                         (void **)&frame->chunk[0] );
             frame->frame.base[1] = xine_xmalloc_aligned(16, image_size,
                                                         (void **)&frame->chunk[1] );
@@ -507,66 +510,66 @@ static void null_get_property_min_max( vo_driver_t* self,
                                        int property, int *min,
                                        int *max ){
             printf("min max\n");                               
     *max = 0;
     *min = 0;
 }
 static int null_gui_data_exchange( vo_driver_t* self,
                                    int data_type,
                                    void *data ){
     return 0;
 }
 static void null_exit( vo_driver_t* self ){
     null_driver_t* this = (null_driver_t*)self;
     free ( this );
 }
 static int null_redraw_needed( vo_driver_t* self ){
     return 0;
 }
                                        
 
 vo_driver_t* init_video_out_plugin( config_values_t* conf,
                                     void* video ){
     null_driver_t *vo;
     vo = (null_driver_t*)malloc( sizeof(null_driver_t ) );
     
     /* memset? */
     memset(vo,0, sizeof(null_driver_t ) );
     vo->m_show_video = 0; // false
     vo->m_video_fullscreen = 0;
     vo->m_is_scaling = 0;
     vo->user_ratio = ASPECT_AUTO;
     vo->display_ratio = 1.0;
-    vo->gui_width = 200;
-    vo->gui_height = 150;
+    vo->gui_width = 16;
+    vo->gui_height = 8;
     vo->frameDis = NULL;
 
     /* install callback handlers*/
     vo->vo_driver.get_capabilities      = null_get_capabilities;
     vo->vo_driver.alloc_frame           = null_alloc_frame;
     vo->vo_driver.update_frame_format   = null_update_frame_format;
     vo->vo_driver.display_frame         = null_display_frame;
     vo->vo_driver.overlay_blend         = null_overlay_blend;
     vo->vo_driver.get_property          = null_get_property;
     vo->vo_driver.set_property          = null_set_property;
     vo->vo_driver.get_property_min_max  = null_get_property_min_max;
     vo->vo_driver.gui_data_exchange     = null_gui_data_exchange;
     vo->vo_driver.exit                  = null_exit;
     vo->vo_driver.redraw_needed         = null_redraw_needed;
     
 
     /* capabilities */
     vo->m_capabilities = VO_CAP_COPIES_IMAGE | VO_CAP_YUY2 | VO_CAP_YV12;
     vo->yuv2rgb_factory = yuv2rgb_factory_init (MODE_16_RGB, vo->yuv2rgb_swap, 
                                                 vo->yuv2rgb_cmap);
     printf("done initialisation\n");
     return (vo_driver_t*) vo;
 }
 
 static vo_info_t vo_info_null = {
     5,
     "null plugin",
     NULL,
     VISUAL_TYPE_FB,
     5
 };
 
diff --git a/noncore/multimedia/opieplayer2/videowidget.cpp b/noncore/multimedia/opieplayer2/videowidget.cpp
index 48caf00..af06079 100644
--- a/noncore/multimedia/opieplayer2/videowidget.cpp
+++ b/noncore/multimedia/opieplayer2/videowidget.cpp
@@ -81,83 +81,85 @@ 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 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" );
 
     cfg.setGroup("AudioWidget");
     QString skin = cfg.readEntry("Skin","default");
     QString skinPath = "opieplayer/skins/" + skin;
     backgroundPix =   QString("%1/background").arg(skinPath) ;
 
     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 ) );
 
+    videoFrame = new XineVideoWidget ( this, "Video frame" );
+
+        connect ( videoFrame, SIGNAL( videoResized ( const QSize & )), this, SIGNAL( videoResized ( const QSize & )));
+
     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( 240, 155 ,this, "Video frame" );
-
 }
 
 
 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() );
 }
@@ -250,84 +252,86 @@ void VideoWidget::mouseMoveEvent( QMouseEvent *event ) {
           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();
+        videoFrame-> setGeometry ( 0, 0, width ( ), height ( ));
   } else {
     setBackgroundPixmap( Resource::loadPixmap(  backgroundPix ) );
     showNormal();
     showMaximized();
     slider->show();
+    videoFrame->setGeometry( QRect( 10, 20, 220, 160  ) );
   }
 }
 
 
 void VideoWidget::paintEvent( QPaintEvent * ) {
     QPainter p( this );
 
     if ( mediaPlayerState->fullscreen() ) {
         // Clear the background
       p.setBrush( QBrush( Qt::black ) );
-      videoFrame->setGeometry( QRect( 0, 0 , 240 ,340  ) );
+//      videoFrame->setGeometry( QRect( 0, 0 , 240 ,320  ) );
 
     } else {
 
-      videoFrame->setGeometry( QRect( 0, 15 , 240 ,170  ) );
+ //     videoFrame->setGeometry( QRect( 0, 15 , 240 ,170  ) );
          // 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;
     int sh = 320;
     int dd = QPixmap::defaultDepth();
     int w = height();
     int h = width();
 
     return true;
 }
 
 
 
@@ -353,32 +357,38 @@ void VideoWidget::keyReleaseEvent( QKeyEvent *e)
               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;
 }
+
+
+void VideoWidget::setFullscreen ( bool b )
+{ 
+        setToggleButton( VideoFullscreen, b );
+}
\ No newline at end of file
diff --git a/noncore/multimedia/opieplayer2/videowidget.h b/noncore/multimedia/opieplayer2/videowidget.h
index 0122d5d..fc53f89 100644
--- a/noncore/multimedia/opieplayer2/videowidget.h
+++ b/noncore/multimedia/opieplayer2/videowidget.h
@@ -35,67 +35,68 @@
 #define VIDEO_WIDGET_H
 
 #include <qwidget.h>
 #include "xinevideowidget.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();
     XineVideoWidget* vidWidget();
 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 setFullscreen( bool b );
     void makeVisible();
     void setPosition( long );
     void setLength( long );
     void setView( char );
 
 signals:
     void sliderMoved( long );
+        void videoResized ( const QSize &s );
 
 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 );
 
     QString backgroundPix;
     QSlider *slider;
     QPixmap *pixmaps[3];
     QImage *currentFrame;
     int scaledWidth;
     int scaledHeight;
     XineVideoWidget* videoFrame;
 };
 
 #endif // VIDEO_WIDGET_H
 
 
 
diff --git a/noncore/multimedia/opieplayer2/xinecontrol.cpp b/noncore/multimedia/opieplayer2/xinecontrol.cpp
index 19a9172..33889d0 100644
--- a/noncore/multimedia/opieplayer2/xinecontrol.cpp
+++ b/noncore/multimedia/opieplayer2/xinecontrol.cpp
@@ -14,64 +14,65 @@
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 #include <qtimer.h>
 #include "xinecontrol.h"
 #include "mediaplayerstate.h"
 #include "videowidget.h"
 
 extern MediaPlayerState *mediaPlayerState;
 extern VideoWidget *videoUI;
 XineControl::XineControl( QObject *parent, const char *name )
     : QObject( parent, name ) {
     libXine = new XINE::Lib(videoUI->vidWidget() );
 
+        connect ( videoUI, SIGNAL( videoResized ( const QSize & )), this, SLOT( videoResized ( const QSize & )));
     connect( mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( pause(bool) ) );
     connect( this, SIGNAL( positionChanged( long ) ), mediaPlayerState, SLOT( updatePosition( long ) ) );
     connect( this, SIGNAL( positionChanged( long ) ), mediaPlayerState, SLOT( setPosition( long ) ) );
     connect( mediaPlayerState, SIGNAL( playingToggled( bool ) ), this, SLOT( stop( bool ) ) );
     connect( mediaPlayerState, SIGNAL( fullscreenToggled( bool ) ), this, SLOT( setFullscreen( bool ) ) );
     connect( mediaPlayerState, SIGNAL( positionChanged( long ) ),  this,  SLOT( seekTo( long ) ) );
 
 }
 
 XineControl::~XineControl() {
     delete libXine;
 }
 
 void XineControl::play( const QString& fileName ) {
     libXine->play( fileName );
     mediaPlayerState->setPlaying( true );
     // default to audio view until we know how to handle video
     //   MediaDetect mdetect;
     char whichGui = mdetect.videoOrAudio( fileName );
     if (whichGui == 'f') {
         qDebug("Nicht erkannter Dateityp");
         return;
     }
 
     if (whichGui == 'a') {
         libXine->setShowVideo( false );
     } else {
         libXine->setShowVideo( true );
     }
 
     // determine if slider is shown
     //    mediaPlayerState->setIsStreaming( mdetect.isStreaming( fileName ) );
@@ -99,32 +100,37 @@ void XineControl::pause( bool isSet) {
 long XineControl::currentTime() {
     // todo: jede sekunde überprüfen
     m_currentTime =  libXine->currentTime();
     return m_currentTime;
     QTimer::singleShot( 1000, this, SLOT( currentTime() ) );
 }
 
 void  XineControl::length() {
     m_length = libXine->length();
     mediaPlayerState->setLength( m_length );
 }
 
 long XineControl::position() {
     m_position = ( currentTime()  );
     mediaPlayerState->setPosition( m_position  );
     long emitPos = (long)m_position;
     emit positionChanged( emitPos );
     if(mediaPlayerState->isPlaying)
     // needs to be stopped the media is stopped
     QTimer::singleShot( 1000, this, SLOT( position() ) );
 //    qDebug("POSITION : %d", m_position);
     return m_position;
 }
 
 void XineControl::setFullscreen( bool isSet ) {
     libXine->showVideoFullScreen( isSet);
 }
 
 void XineControl::seekTo( long second ) {
     //  libXine->
 }
 
+
+void XineControl::videoResized ( const QSize &s )
+{
+        libXine-> resize ( s );
+}
diff --git a/noncore/multimedia/opieplayer2/xinecontrol.h b/noncore/multimedia/opieplayer2/xinecontrol.h
index 295d2b4..4a61f32 100644
--- a/noncore/multimedia/opieplayer2/xinecontrol.h
+++ b/noncore/multimedia/opieplayer2/xinecontrol.h
@@ -27,45 +27,47 @@
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef XINECONTROL_H
 #define XINECONTROL_H
 
 #include "lib.h"
 #include "mediadetect.h"
 #include <qobject.h>
 
 class XineControl : public QObject  {
     Q_OBJECT
 public:
     XineControl( QObject *parent = 0, const char *name =0 );
     ~XineControl();
     int m_length;
 
 public slots:
     void play( const QString& fileName );
     void stop( bool );
     void pause( bool );
     void setFullscreen( bool );
     long currentTime();
     void seekTo( long );
     // get length of media file and set it
     void length();
     long position();
 
+        void videoResized ( const QSize &s );
+
 private:
     XINE::Lib *libXine;
     MediaDetect mdetect;
     long m_currentTime;
     long m_position;
 
 signals:
     void positionChanged( long );
 
 };
 
 
 #endif
diff --git a/noncore/multimedia/opieplayer2/xinevideowidget.cpp b/noncore/multimedia/opieplayer2/xinevideowidget.cpp
index 4b69044..98446a0 100644
--- a/noncore/multimedia/opieplayer2/xinevideowidget.cpp
+++ b/noncore/multimedia/opieplayer2/xinevideowidget.cpp
@@ -9,144 +9,145 @@
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
  
 */
 
 #include <qimage.h>
 #include <qpainter.h>
 #include <qgfx_qws.h>
 #include <qdirectpainter_qws.h>
 #include <qgfx_qws.h>
 #include <qsize.h>
+#include <qapplication.h>
 
 #include <qpe/resource.h>
 
 #include "xinevideowidget.h"
 
+
 static inline void memcpy_rev ( void *dst, void *src, size_t len )
 {
         ((char *) src ) += len;
 
         len >>= 1; 
         while ( len-- )
                 *((short int *) dst )++ = *--((short int *) src );
 }
 
 static inline void memcpy_step ( void *dst, void *src, size_t len, size_t step )
 {
         len >>= 1;
         while ( len-- ) {
                 *((short int *) dst )++ = *((short int *) src );
                 ((char *) src ) += step;
         }
 }
 
 static inline void memcpy_step_rev ( void *dst, void *src, size_t len, size_t step )
 {
         len >>= 1;
         
         ((char *) src ) += ( len * step );
         
         while ( len-- ) {
                 ((char *) src ) -= step;
                 *((short int *) dst )++ = *((short int *) src );
         }
 }
 
 
-XineVideoWidget::XineVideoWidget( int width,
-                                  int height,
-                                  QWidget* parent,
-                                  const char* name )
+XineVideoWidget::XineVideoWidget ( QWidget* parent, const char* name )
                 : QWidget ( parent, name, WRepaintNoErase | WResizeNoErase )
 {
-        m_image = new QImage ( width, height, qt_screen-> depth ( ));
-        m_buff = 0;
         setBackgroundMode ( NoBackground );
-        /*    QImage image = Resource::loadImage("SoundPlayer");
-            image = image.smoothScale( width, height );
-         
-            m_image = new QImage( image );*/
+
+        m_image             = 0;
+        m_buff              = 0;
+        m_bytes_per_line_fb = qt_screen-> linestep ( );
+        m_bytes_per_pixel   = ( qt_screen->depth() + 7 ) / 8;
+        m_rotation          = 0;
 }
 
+
 XineVideoWidget::~XineVideoWidget ( )
 {
         delete m_image;
 }
 
 void XineVideoWidget::clear ( )
 {
         m_buff = 0;
         repaint ( false );
 }
 
 void XineVideoWidget::paintEvent ( QPaintEvent * )
 {
         //qWarning( "painting <<<" );
         if ( m_buff == 0 ) {
                 QPainter p ( this );
                 p. fillRect ( rect ( ), black );
-                p. drawImage ( 0, 0, *m_image );
+                if ( m_image )
+                        p. drawImage ( 0, 0, *m_image );
                 //qWarning ( "logo\n" );
         }
         else {
         //      qWarning ( "paintevent\n" );
                 
                 QArray <QRect> qt_bug_workaround_clip_rects;
                 
                 {
                         QDirectPainter dp ( this );
 
-                        int rot = dp. transformOrientation ( );
+                        int rot = dp. transformOrientation ( ) + m_rotation;
 
                         uchar *fb = dp. frameBuffer ( );
                         uchar *frame = m_buff;  // rot == 0 ? m_buff : m_buff + ( m_thisframe. height ( ) - 1 ) * m_bytes_per_line_frame;
                         
                         QRect framerect = qt_screen-> mapToDevice ( QRect ( mapToGlobal ( m_thisframe. topLeft ( )), m_thisframe. size ( )), QSize ( qt_screen-> width ( ), qt_screen-> height ( )));
                         
                         qt_bug_workaround_clip_rects. resize ( dp. numRects ( ));
 
                         for ( int i = dp. numRects ( ) - 1; i >= 0; i-- ) {
                                 const QRect &clip = dp. rect ( i );
                                                                 
                                 qt_bug_workaround_clip_rects [i] = qt_screen-> mapFromDevice ( clip, QSize ( qt_screen-> width ( ), qt_screen-> height ( )));
                                 
                                 uchar *dst = fb + ( clip. x ( ) * m_bytes_per_pixel ) + ( clip. y ( ) * m_bytes_per_line_fb ); 
                                 uchar *src = frame;
                                 
                                 switch ( rot ) {
                                         case 0: src += ( (( clip. x ( ) - framerect. x ( )) * m_bytes_per_pixel ) + (( clip. y ( ) - framerect. y ( )) * m_bytes_per_line_frame ) ); break;
                                         case 1: src += ( (( clip. y ( ) - framerect. y ( )) * m_bytes_per_pixel ) + (( clip. x ( ) - framerect. x ( )) * m_bytes_per_line_frame ) + (( framerect. height ( ) - 1 ) * m_bytes_per_pixel ) ); break;
                                         case 2: src += ( (( clip. x ( ) - framerect. x ( )) * m_bytes_per_pixel ) + (( clip. y ( ) - framerect. y ( )) * m_bytes_per_line_frame ) + (( framerect. height ( ) - 1 ) * m_bytes_per_line_frame ) ); break;
                                         case 3: src += ( (( clip. y ( ) - framerect. y ( )) * m_bytes_per_pixel ) + (( clip. x ( ) - framerect. x ( )) * m_bytes_per_line_frame ) ); break;
                                 }
 
                                 uint leftfill = 0;
                                 uint framefill = 0;
                                 uint rightfill = 0;
                                 uint clipwidth = clip. width ( ) * m_bytes_per_pixel;
                                 
                                 if ( clip. left ( ) < framerect. left ( ))
                                         leftfill = (( framerect. left ( ) - clip. left ( )) * m_bytes_per_pixel ) <? clipwidth;
                                 if ( clip. right ( ) > framerect. right ( ))
                                         rightfill = (( clip. right ( ) - framerect. right ( )) * m_bytes_per_pixel ) <? clipwidth;
@@ -168,63 +169,99 @@ void XineVideoWidget::paintEvent ( QPaintEvent * )
                                                                 case 2: memcpy_rev ( dst + leftfill, src, framefill );                              break;
                                                                 case 3: memcpy_step_rev ( dst + leftfill, src, framefill, m_bytes_per_line_frame ); break;
                                                         }
                                                         }
                                                 if ( rightfill )
                                                         memset ( dst + leftfill + framefill, 0, rightfill );
                                         }
                                         
                                         dst += m_bytes_per_line_fb;
                                         
                                         switch ( rot ) {
                                                 case 0: src += m_bytes_per_line_frame; break;
                                                 case 1: src -= m_bytes_per_pixel;      break;
                                                 case 2: src -= m_bytes_per_line_frame; break;
                                                 case 3: src += m_bytes_per_pixel;      break;
                                         }
                                 }
                         }
                 }
                         //qWarning ( " ||| painting |||" );     
                 {
                         // QVFB hack by MArtin Jones
                         QPainter p ( this );
 
                         for ( int i = qt_bug_workaround_clip_rects. size ( ) - 1; i >= 0; i-- ) {  
                                 p. fillRect ( QRect ( mapFromGlobal ( qt_bug_workaround_clip_rects [i]. topLeft ( )), qt_bug_workaround_clip_rects [i]. size ( )), QBrush ( NoBrush ) );
                         }
                 }
         }
         //qWarning( "painting >>>" );
 }
 
-int XineVideoWidget::height ( ) const
-{
-        return m_image-> height ( );
-}
-
-int XineVideoWidget::width ( ) const
-{
-        return m_image-> width ( );
-}
 
 void XineVideoWidget::setImage ( QImage* image )
 {
         delete m_image;
         m_image = image;
 }
 
-void XineVideoWidget::setImage( uchar* image, int yoffsetXLine,
-                                int xoffsetXBytes, int width,
-                                int height, int linestep, int bytes, int bpp )
+void XineVideoWidget::setImage ( uchar* img, int w, int h, int bpl )
 {
+        bool rot90 = (( -m_rotation ) & 1 );
+
+        if ( rot90 ) {
+                int d = w;
+                w = h;
+                h = d;
+        }
 
         m_lastframe = m_thisframe;
-        m_thisframe. setRect ( xoffsetXBytes, yoffsetXLine, width, height );
+        m_thisframe. setRect (( width ( ) - w ) / 2, ( height ( ) - h ) / 2, w , h );
 
-        m_buff                 = image;
-        m_bytes_per_line_fb    = linestep;
-        m_bytes_per_line_frame = bytes;
-        m_bytes_per_pixel      = bpp;
+        //qDebug ( "Frame: %d,%d - %dx%d", ( width ( ) - w ) / 2, ( height ( ) - h ) / 2, w , h );
+
+        m_buff                 = img;
+        m_bytes_per_line_frame = bpl;
 
         repaint ((( m_thisframe & m_lastframe ) != m_lastframe ) ? m_lastframe : m_thisframe, false );
 }
+
+void XineVideoWidget::resizeEvent ( QResizeEvent * )
+{
+        QSize s = size ( );
+        bool fs = ( s == qApp-> desktop ( )-> size ( ));
+                
+        m_rotation = fs ? -qt_screen-> transformOrientation ( ) : 0;
+                
+        if ( fs && qt_screen-> isTransformed ( )) {
+                        s = qt_screen-> mapToDevice ( s );      
+        }
+
+        //qDebug ( "\n\nResize: %dx%d, Rot: %d", s.width(),s.height(),m_rotation );
+        
+        emit videoResized ( s );
+}
+
+
+void XineVideoWidget::mousePressEvent ( QMouseEvent *me )
+{
+        QWidget *p = parentWidget ( );
+        
+        if ( p ) {
+                QMouseEvent pme ( QEvent::MouseButtonPress, mapToParent ( me-> pos ( )), me-> globalPos ( ), me-> button ( ), me-> state ( ));
+                
+                QApplication::sendEvent ( p, &pme );
+        }
+}
+
+void XineVideoWidget::mouseReleaseEvent ( QMouseEvent *me )
+{
+        QWidget *p = parentWidget ( );
+        
+        if ( p ) {
+                QMouseEvent pme ( QEvent::MouseButtonRelease, mapToParent ( me-> pos ( )), me-> globalPos ( ), me-> button ( ), me-> state ( ));
+                
+                QApplication::sendEvent ( p, &pme );
+        }
+}
+
diff --git a/noncore/multimedia/opieplayer2/xinevideowidget.h b/noncore/multimedia/opieplayer2/xinevideowidget.h
index 7d9a6d2..2fc627d 100644
--- a/noncore/multimedia/opieplayer2/xinevideowidget.h
+++ b/noncore/multimedia/opieplayer2/xinevideowidget.h
@@ -6,59 +6,67 @@
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 
 #include <qwidget.h>
 
+#include "lib.h"
+
 class QImage;
 class XineVideoWidget : public QWidget {
     Q_OBJECT
 public:
-    XineVideoWidget( int width,  int height, QWidget* parent,  const char* name );
+    XineVideoWidget( QWidget* parent,  const char* name );
     ~XineVideoWidget();
     QImage *image() { return m_image; };
     void setImage( QImage* image );
-    void setImage( uchar* image, int yoffsetXLine, int xoffsetXBytes,
-                   int width, int height,  int linestep,  int bytes,  int bpp);
-    int width() const;
-    int height() const;
+    void setImage( uchar* image, int width, int height, int linestep);
     void clear() ;
+    
 protected:
     void paintEvent( QPaintEvent* p );
+    void resizeEvent ( QResizeEvent *r );
+
+        void mousePressEvent ( QMouseEvent *e );
+        void mouseReleaseEvent ( QMouseEvent *e );
+
+signals:
+        void videoResized ( const QSize &s );
+    
 private:
         QRect m_lastframe;
         QRect m_thisframe;
 
     uchar* m_buff;
     int m_bytes_per_line_fb;
     int m_bytes_per_line_frame;
     int m_bytes_per_pixel;
     QImage* m_image;
-
+    int m_rotation;
 };