Fullscreen controller

Signed-off-by: Jean-Baptiste Kempf <jb@videolan.org>

modules/gui/qt4/components/interface_widgets.cpp

@@ -284,8 +284,7 @@ AdvControlsWidget::AdvControlsWidget( intf_thread_t *_p_i ) :
 
     /* A to B Button */
     ABButton = new QPushButton( "AB" );
-    ABButton->setMaximumSize( QSize( 26, 26 ) );
-    ABButton->setIconSize( QSize( 20, 20 ) );
+    setupSmallButton( ABButton );
     advLayout->addWidget( ABButton );
     BUTTON_SET_ACT( ABButton, "AB", qtr( "A to B" ), fromAtoB() );
     timeA = timeB = 0;
@@ -300,16 +299,14 @@ AdvControlsWidget::AdvControlsWidget( intf_thread_t *_p_i ) :
 #endif
 
     recordButton = new QPushButton( "R" );
-    recordButton->setMaximumSize( QSize( 26, 26 ) );
-    recordButton->setIconSize( QSize( 20, 20 ) );
+    setupSmallButton( recordButton );
     advLayout->addWidget( recordButton );
     BUTTON_SET_ACT_I( recordButton, "", record_16px.png,
             qtr( "Record" ), record() );
 
     /* Snapshot Button */
     snapshotButton = new QPushButton( "S" );
-    snapshotButton->setMaximumSize( QSize( 26, 26 ) );
-    snapshotButton->setIconSize( QSize( 20, 20 ) );
+    setupSmallButton( snapshotButton );
     advLayout->addWidget( snapshotButton );
     BUTTON_SET_ACT( snapshotButton, "S", qtr( "Take a snapshot" ), snapshot() );
 }
@@ -383,10 +380,12 @@ void AdvControlsWidget::frame(){}
 ControlsWidget::ControlsWidget( intf_thread_t *_p_i,
                                 MainInterface *_p_mi,
                                 bool b_advControls,
-                                bool b_shiny ) :
-                                QFrame( NULL ), p_intf( _p_i )
+                                bool b_shiny,
+                                bool b_fsCreation) :
+                                QFrame( _p_mi ), p_intf( _p_i )
 {
-    controlLayout = new QGridLayout( this );
+    controlLayout = new QGridLayout( );
+
     controlLayout->setSpacing( 0 );
 #if QT43
     controlLayout->setContentsMargins( 9, 6, 9, 6 );
@@ -394,6 +393,9 @@ ControlsWidget::ControlsWidget( intf_thread_t *_p_i,
     controlLayout->setMargin( 6 );
 #endif
 
+    if( !b_fsCreation )
+        setLayout( controlLayout );
+
     setSizePolicy( QSizePolicy::Preferred , QSizePolicy::Maximum );
 
     /** The main Slider **/
@@ -525,7 +527,7 @@ ControlsWidget::ControlsWidget( intf_thread_t *_p_i,
     controlLayout->setColumnStretch( 2, 0 );
 
     /** Prev + Stop + Next Block **/
-    QHBoxLayout *controlButLayout = new QHBoxLayout;
+    controlButLayout = new QHBoxLayout;
     controlButLayout->setSpacing( 0 ); /* Don't remove that, will be useful */
 
     /* Prev */
@@ -550,6 +552,7 @@ ControlsWidget::ControlsWidget( intf_thread_t *_p_i,
     controlButLayout->addWidget( nextButton );
 
     /* Add this block to the main layout */
+    if( !b_fsCreation )
         controlLayout->addLayout( controlButLayout, 3, 3, 1, 3 );
 
     BUTTON_SET_ACT_I( playButton, "", play.png, qtr( "Play" ), play() );
@@ -580,7 +583,7 @@ ControlsWidget::ControlsWidget( intf_thread_t *_p_i,
     CONNECT( playlistButton, clicked(), _p_mi, togglePlaylist() );
 
     /** extended Settings **/
-    QPushButton *extSettingsButton = new QPushButton( "F" );
+    extSettingsButton = new QPushButton;
     BUTTON_SET_ACT( extSettingsButton, "Ex", qtr( "Extended Settings" ),
             extSettings() );
     setupSmallButton( extSettingsButton );
@@ -591,7 +594,7 @@ ControlsWidget::ControlsWidget( intf_thread_t *_p_i,
     controlLayout->setColumnStretch( 14, 5 );
 
     /* Volume */
-    VolumeClickHandler *hVolLabel = new VolumeClickHandler( p_intf, this );
+    hVolLabel = new VolumeClickHandler( p_intf, this );
 
     volMuteLabel = new QLabel;
     volMuteLabel->setPixmap( QPixmap( ":/pixmaps/volume-medium.png" ) );
@@ -806,6 +809,323 @@ void ControlsWidget::toggleAdvanced()
 }
 
 
+/**********************************************************************
+ * Fullscrenn control widget
+ **********************************************************************/
+FullscreenControllerWidget::FullscreenControllerWidget( intf_thread_t *_p_i,
+        MainInterface *_p_mi, bool b_advControls, bool b_shiny )
+        : ControlsWidget( _p_i, _p_mi, b_advControls, b_shiny, true ),
+        i_lastPosX( -1 ), i_lastPosY( -1 ), i_hideTimeout( 1 ),
+        b_mouseIsOver( false )
+{
+    setWindowFlags( Qt::ToolTip );
+
+    setFrameShape( QFrame::StyledPanel );
+    setFrameStyle( QFrame::Sunken );
+    setSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
+
+    QGridLayout *fsLayout = new QGridLayout( this );
+    controlLayout->setSpacing( 0 );
+    controlLayout->setContentsMargins( 5, 1, 5, 1 );
+
+    fsLayout->addWidget( slowerButton, 0, 0 );
+    slider->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum);
+    fsLayout->addWidget( slider, 0, 1, 1, 6 );
+    fsLayout->addWidget( fasterButton, 0, 7 );
+
+    fsLayout->addWidget( volMuteLabel, 1, 0);
+    fsLayout->addWidget( volumeSlider, 1, 1 );
+
+    fsLayout->addLayout( controlButLayout, 1, 2 );
+
+    fsLayout->addWidget( playButton, 1, 3 );
+
+    fsLayout->addWidget( discFrame, 1, 4 );
+
+    fsLayout->addWidget( telexFrame, 1, 5 );
+
+    fsLayout->addWidget( advControls, 1, 6, Qt::AlignVCenter );
+
+    fsLayout->addWidget( fullscreenButton, 1, 7 );
+
+    /* hiding timer */
+    p_hideTimer = new QTimer( this );
+    CONNECT( p_hideTimer, timeout(), this, hideFSControllerWidget() );
+    p_hideTimer->setSingleShot( true );
+
+    /* slow hiding timer */
+    #ifdef TRANSPARENCY
+    p_slowHideTimer = new QTimer( this );
+    CONNECT( p_slowHideTimer, timeout(), this, slowHideFSC() );
+    #endif
+
+    adjustSize ();  /* need to get real width and height for moving */
+
+    /* center down */
+    QDesktopWidget * p_desktop = QApplication::desktop();
+
+    move( p_desktop->width() / 2 - width() / 2,
+          p_desktop->height() - height() );
+
+    #ifdef WIN32TRICK
+    setWindowOpacity( 0.0 );
+    fscHidden = true;
+    show();
+    #endif
+}
+
+FullscreenControllerWidget::~FullscreenControllerWidget()
+{
+}
+
+/**
+ * Hide fullscreen controller
+ * FIXME: under windows it have to be done by moving out of screen
+ *        because hide() doesnt work
+ */
+void FullscreenControllerWidget::hideFSControllerWidget()
+{
+    #ifdef WIN32TRICK
+    fscHidden = true;
+    setWindowOpacity( 0.0 );    // simulate hidding
+    #else
+    hide();
+    #endif
+}
+
+#ifdef TRANSPARENCY
+/**
+ * Hidding fullscreen controller slowly
+ * Linux: need composite manager
+ * Windows: it is blinking, so it can be enabled by define TRASPARENCY
+ */
+void FullscreenControllerWidget::slowHideFSC()
+{
+    static bool first_call = true;
+
+    if ( first_call )
+    {
+        first_call = false;
+
+        p_slowHideTimer->stop();
+        /* the last part of time divided to 100 pieces */
+        p_slowHideTimer->start( i_hideTimeout / 2 / ( windowOpacity() * 100 ) );
+    }
+    else
+    {
+         if ( windowOpacity() > 0.0 )
+         {
+             /* we should use 0.01 because of 100 pieces ^^^
+                but than it cannt be done in time */
+             setWindowOpacity( windowOpacity() - 0.02 );
+         }
+
+         if ( windowOpacity() == 0.0 )
+         {
+             first_call = true;
+             p_slowHideTimer->stop();
+         }
+    }
+}
+#endif
+
+/**
+ * Get state of visibility of FS controller on screen
+ * On windows control if it is on hidden position
+ */
+bool FullscreenControllerWidget::isFSCHidden()
+{
+    #ifdef WIN32TRICK
+    return fscHidden;
+    #endif
+
+    return isHidden();
+}
+
+/**
+ * event handling
+ * events: show, hide, start timer for hidding
+ */
+void FullscreenControllerWidget::customEvent( QEvent *event )
+{
+    int type = event->type();
+
+    if ( type == FullscreenControlShow_Type )
+    {
+        #ifdef WIN32TRICK
+        // after quiting and going to fs, we need to call show()
+        if ( isHidden() )
+            show();
+
+        if ( fscHidden )
+        {
+            fscHidden = false;
+            setWindowOpacity( 1.0 );
+        }
+        #else
+        show();
+        #endif
+
+        #ifdef TRANSPARENCY
+        setWindowOpacity( 0.75 );
+        #endif
+    }
+    else if ( type == FullscreenControlHide_Type )
+    {
+        hideFSControllerWidget();
+    }
+    else if ( type == FullscreenControlPlanHide_Type && !b_mouseIsOver )
+    {
+        p_hideTimer->start( i_hideTimeout );
+        #ifdef TRANSPARENCY
+        p_slowHideTimer->start( i_hideTimeout / 2 );
+        #endif
+    }
+}
+
+/**
+ * On mouse move
+ * moving with FSC
+ */
+void FullscreenControllerWidget::mouseMoveEvent( QMouseEvent *event )
+{
+    if ( event->buttons() == Qt::LeftButton )
+    {
+        int i_moveX = event->globalX() - i_lastPosX;
+        int i_moveY = event->globalY() - i_lastPosY;
+
+        move( x() + i_moveX, y() + i_moveY );
+
+        i_lastPosX = event->globalX();
+        i_lastPosY = event->globalY();
+    }
+}
+
+/**
+ * On mouse press
+ * store position of cursor
+ */
+void FullscreenControllerWidget::mousePressEvent( QMouseEvent *event )
+{
+    i_lastPosX = event->globalX();
+    i_lastPosY = event->globalY();
+}
+
+/**
+ * On mouse go above FSC
+ */
+void FullscreenControllerWidget::enterEvent( QEvent *event )
+{
+    p_hideTimer->stop();
+    #ifdef TRANSPARENCY
+    p_slowHideTimer->stop();
+    #endif
+    b_mouseIsOver = true;
+}
+
+/**
+ * On mouse go out from FSC
+ */
+void FullscreenControllerWidget::leaveEvent( QEvent *event )
+{
+    p_hideTimer->start( i_hideTimeout );
+    #ifdef TRANSPARENCY
+    p_slowHideTimer->start( i_hideTimeout / 2 );
+    #endif
+    b_mouseIsOver = false;
+}
+
+/**
+ * When you get pressed key, send it to video output
+ * FIXME: clearing focus by clearFocus() to not getting
+ * key press events didnt work
+ */
+void FullscreenControllerWidget::keyPressEvent( QKeyEvent *event )
+{
+    int i_vlck = qtEventToVLCKey( event );
+    if( i_vlck > 0 )
+    {
+        var_SetInteger( p_intf->p_libvlc, "key-pressed", i_vlck );
+        event->accept();
+    }
+    else
+        event->ignore();
+}
+
+/**
+ * It is called when video start
+ */
+void FullscreenControllerWidget::regFullscreenCallback( vout_thread_t *p_vout )
+{
+    if ( p_vout )
+    {
+        var_AddCallback( p_vout, "fullscreen", regMouseMoveCallback, this );
+    }
+}
+
+/**
+ * It is called after turn off video, because p_vout is NULL now
+ * we cannt delete callback, just hide if FScontroller is visible
+ */
+void FullscreenControllerWidget::unregFullscreenCallback()
+{
+    if ( isVisible() )
+        hide();
+}
+
+/**
+ * Register and unregister callback for mouse moving
+ */
+static int regMouseMoveCallback( vlc_object_t *vlc_object, const char *variable,
+                                 vlc_value_t old_val, vlc_value_t new_val,
+                                 void *data )
+{
+    vout_thread_t *p_vout = (vout_thread_t *) vlc_object;
+
+    static bool b_registered = false;
+    FullscreenControllerWidget *p_fs = (FullscreenControllerWidget *) data;
+
+    if ( var_GetBool( p_vout, "fullscreen" ) && !b_registered )
+    {
+        p_fs->SetHideTimeout( var_GetInteger( p_vout, "mouse-hide-timeout" ) );
+        var_AddCallback( p_vout, "mouse-moved",
+                        showFullscreenControllCallback, (void *) p_fs );
+        b_registered = true;
+    }
+
+    if ( !var_GetBool( p_vout, "fullscreen" ) && b_registered )
+    {
+        var_DelCallback( p_vout, "mouse-moved",
+                        showFullscreenControllCallback, (void *) p_fs );
+        b_registered = false;
+        p_fs->hide();
+    }
+
+    return VLC_SUCCESS;
+}
+
+/**
+ * Show fullscreen controller after mouse move
+ * after show immediately plan hide event
+ */
+static int showFullscreenControllCallback( vlc_object_t *vlc_object, const char *variable,
+                                           vlc_value_t old_val, vlc_value_t new_val,
+                                           void *data )
+{
+    FullscreenControllerWidget *p_fs = (FullscreenControllerWidget *) data;
+
+    if ( p_fs->isFSCHidden() )
+    {
+        IMEvent *event = new IMEvent( FullscreenControlShow_Type, 0 );
+        QApplication::postEvent( p_fs, static_cast<QEvent *>(event) );
+    }
+
+    IMEvent *e = new IMEvent( FullscreenControlPlanHide_Type, 0 );
+    QApplication::postEvent( p_fs, static_cast<QEvent *>(e) );
+
+    return VLC_SUCCESS;
+}
+
 /**********************************************************************
  * Speed control widget
  **********************************************************************/

modules/gui/qt4/components/interface_widgets.hpp

@@ -42,6 +42,22 @@
 #include <QFrame>
 #define VOLUME_MAX 200
 
+/* on WIN32 hide() for fullscreen controller doesnt work, so it have to be
+   done by trick with setting the opacity of window */
+#ifdef WIN32
+    #define WIN32TRICK
+#endif
+
+/* to trying transparency with fullscreen controller on windows enable that */
+/* #define TRANSPARENCY */
+
+/* it can be enabled on non windows systems,
+   but it will be transparent only with composite manager */
+#ifndef WIN32
+    #define TRANSPARENCY
+#endif
+
+
 class ResizeEvent;
 class QPalette;
 class QPixmap;
@@ -155,7 +171,8 @@ class ControlsWidget : public QFrame
     Q_OBJECT
 public:
     /* p_intf, advanced control visible or not, blingbling or not */
-    ControlsWidget( intf_thread_t *, MainInterface*, bool, bool );
+    ControlsWidget( intf_thread_t *_p_i, MainInterface *_p_mi,
+        bool b_advControls, bool b_shiny, bool b_fsCreation = false);
     virtual ~ControlsWidget();
 
     QPushButton *playlistButton;
@@ -167,21 +184,23 @@ public slots:
 protected:
     friend class MainInterface;
     friend class VolumeClickHandler;
-private:
+protected:
     intf_thread_t       *p_intf;
     QWidget             *discFrame;
     QWidget             *telexFrame;
     QGridLayout         *controlLayout;
     InputSlider         *slider;
     QPushButton         *prevSectionButton, *nextSectionButton, *menuButton;
-    QPushButton         *playButton, *fullscreenButton;
+    QPushButton         *playButton, *fullscreenButton, *extSettingsButton;
     QToolButton         *slowerButton, *fasterButton;
+    QHBoxLayout         *controlButLayout;
     AdvControlsWidget   *advControls;
     QLabel              *volMuteLabel;
     QAbstractSlider     *volumeSlider;
+    VolumeClickHandler  *hVolLabel;
 
     bool                 b_advancedVisible;
-private slots:
+protected slots:
     void play();
     void stop();
     void prev();
@@ -198,6 +217,69 @@ signals:
     void advancedControlsToggled( bool );
 };
 
+/***********************************
+ * Fullscreen controller
+ ***********************************/
+
+static int showFullscreenControllCallback(vlc_object_t *vlc_object, const char *variable, vlc_value_t old_val,
+    vlc_value_t new_val, void *data);
+
+static int regMouseMoveCallback(vlc_object_t *vlc_object, const char *variable, vlc_value_t old_val,
+    vlc_value_t new_val, void *data);
+
+class FullscreenControllerWidget : public ControlsWidget
+{
+    Q_OBJECT
+public:
+    FullscreenControllerWidget( intf_thread_t *, MainInterface*, bool, bool );
+    virtual ~FullscreenControllerWidget();
+
+    void SetHideTimeout( int hideTimeout ) { i_hideTimeout = hideTimeout; }
+    void regFullscreenCallback( vout_thread_t *p_vout );
+
+    bool isFSCHidden();
+
+public slots:
+    void unregFullscreenCallback();
+
+protected:
+    friend class MainInterface;
+    friend class VolumeClickHandler;
+
+    virtual void mouseMoveEvent( QMouseEvent *event );
+    virtual void mousePressEvent( QMouseEvent *event );
+    virtual void enterEvent( QEvent *event );
+    virtual void leaveEvent( QEvent *event );
+    virtual void keyPressEvent( QKeyEvent *event );
+
+private slots:
+    void hideFSControllerWidget();
+
+    #ifdef TRANSPARENCY
+    void slowHideFSC();
+    #endif
+
+private:
+    QTimer *p_hideTimer;
+
+    #ifdef TRANSPARENCY
+    QTimer *p_slowHideTimer;
+    #endif
+
+    int i_lastPosX;
+    int i_lastPosY;
+    int i_hideTimeout;  /* FSC hiding timeout, same as mouse hiding timeout */
+    bool b_mouseIsOver;
+
+    #ifdef WIN32TRICK
+    bool fscHidden;
+    #endif
+
+    virtual void customEvent( QEvent *event );
+};
+
+
+
 class VolumeClickHandler : public QObject
 {
 public:

modules/gui/qt4/input_manager.cpp

@@ -98,6 +98,7 @@ void InputManager::setInput( input_thread_t *_p_input )
         p_input = NULL;
         i_input_id = 0;
         emit rateChanged( INPUT_RATE_DEFAULT );
+        emit inputUnset();
     }
 }
 

modules/gui/qt4/input_manager.hpp

@@ -42,6 +42,9 @@ static int const ItemStateChanged_Type = QEvent::User + IMEventType + 3;
 static int const ItemTitleChanged_Type = QEvent::User + IMEventType + 4;
 static int const ItemRateChanged_Type  = QEvent::User + IMEventType + 5;
 static int const VolumeChanged_Type    = QEvent::User + IMEventType + 6;
+static int const FullscreenControlShow_Type = QEvent::User + IMEventType + 7;
+static int const FullscreenControlHide_Type = QEvent::User + IMEventType + 8;
+static int const FullscreenControlPlanHide_Type = QEvent::User + IMEventType + 9;
 
 class IMEvent : public QEvent
 {
@@ -113,6 +116,8 @@ signals:
     /// Play/pause status
     void statusChanged( int );
     void artChanged( QString );
+    /// Controll of fullscreen controller
+    void inputUnset();
 #ifdef ZVBI_COMPILED
     void teletextEnabled( bool );
 #endif

modules/gui/qt4/main_interface.cpp

@@ -82,10 +82,19 @@ static void *DoRequest( intf_thread_t *p_intf, vout_thread_t *p_vout,
 {
     return p_intf->p_sys->p_mi->requestVideo( p_vout, pi1, pi2, pi3, pi4 );
 }
+
+static void *DoNotEmbeddedRequest( intf_thread_t *p_intf, vout_thread_t *p_vout,
+                        int *pi1, int *pi2, unsigned int*pi3,unsigned int*pi4)
+{
+    p_intf->p_sys->p_mi->requestNotEmbeddedVideo( p_vout );
+    return NULL;
+}
+
 static void DoRelease( intf_thread_t *p_intf, void *p_win )
 {
     return p_intf->p_sys->p_mi->releaseVideo( p_win );
 }
+
 static int DoControl( intf_thread_t *p_intf, void *p_win, int i_q, va_list a )
 {
     return p_intf->p_sys->p_mi->controlVideo( p_win, i_q, a );
@@ -240,6 +249,13 @@ MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf )
     CONNECT( controls, advancedControlsToggled( bool ),
              this, doComponentsUpdate() );
 
+    CONNECT( fullscreenControls, advancedControlsToggled( bool ),
+             this, doComponentsUpdate() );
+
+    CONNECT( THEMIM->getIM(), inputUnset(),
+            fullscreenControls, unregFullscreenCallback() );
+
+
     /* Size and placement of interface */
     QVLCTools::restoreWidgetPosition(settings,this,QSize(350,60));
 
@@ -404,6 +420,12 @@ void MainInterface::handleMainUi( QSettings *settings )
                    settings->value( "adv-controls", false ).toBool(),
                    config_GetInt( p_intf, "qt-blingbling" ) );
 
+    /* Create the FULLSCREEN CONTROLS Widget */
+    /* bool b_shiny = config_GetInt( p_intf, "qt-blingbling" ); */
+    fullscreenControls = new FullscreenControllerWidget( p_intf, this,
+                   settings->value( "adv-controls", false ).toBool(),
+                   config_GetInt( p_intf, "qt-blingbling" ) );
+
     /* Add the controls Widget to the main Widget */
     mainLayout->insertWidget( 0, controls, 0, Qt::AlignBottom );
 
@@ -444,6 +466,10 @@ void MainInterface::handleMainUi( QSettings *settings )
         p_intf->pf_release_window  = ::DoRelease;
         p_intf->pf_control_window  = ::DoControl;
     }
+    else
+    {
+        p_intf->pf_request_window  = ::DoNotEmbeddedRequest;
+    }
 
     /* Finish the sizing */
     main->updateGeometry();
@@ -695,10 +721,19 @@ void *MainInterface::requestVideo( vout_thread_t *p_nvout, int *pi_x,
 
         emit askVideoToResize( *pi_width, *pi_height );
         emit askUpdate();
+
+        fullscreenControls->regFullscreenCallback( p_nvout );
     }
     return ret;
 }
 
+/* function called from ::DoRequest in order to show a nice VideoWidget
+    at the good size */
+void MainInterface::requestNotEmbeddedVideo( vout_thread_t *p_nvout )
+{
+    fullscreenControls->regFullscreenCallback( p_nvout );
+}
+
 void MainInterface::releaseVideo( void *p_win )
 {
     emit askReleaseVideo( p_win );
@@ -898,8 +933,10 @@ void MainInterface::setStatus( int status )
     msg_Dbg( p_intf, "I was here, updating your status" );
     /* Forward the status to the controls to toggle Play/Pause */
     controls->setStatus( status );
+    fullscreenControls->setStatus( status );
 
     controls->updateInput();
+    fullscreenControls->updateInput();
     speedControl->setEnable( THEMIM->getIM()->hasInput() );
 
     /* And in the systray for the menu */

modules/gui/qt4/main_interface.hpp

@@ -45,6 +45,7 @@ class PlaylistWidget;
 class VisualSelector;
 class AdvControlsWidget;
 class ControlsWidget;
+class FullscreenControllerWidget;
 class SpeedControlWidget;
 class QMenu;
 class QSize;
@@ -72,6 +73,7 @@ public:
     void *requestVideo( vout_thread_t *p_nvout, int *pi_x,
                         int *pi_y, unsigned int *pi_width,
                         unsigned int *pi_height );
+    void requestNotEmbeddedVideo( vout_thread_t *p_nvout );
     void releaseVideo( void * );
     int controlVideo( void *p_window, int i_query, va_list args );
     void requestLayoutUpdate();
@@ -99,6 +101,7 @@ private:
     QString              input_name;
     QVBoxLayout         *mainLayout;
     ControlsWidget      *controls;
+    FullscreenControllerWidget *fullscreenControls;
     QMenu               *speedControlMenu;
     SpeedControlWidget  *speedControl;
     QProgressBar        *pgBar;