* compiles-but-untested complete implementation of menus and popups

* handle play/pause status

modules/gui/qt4/dialogs_provider.cpp

@@ -45,6 +45,9 @@ DialogsProvider::DialogsProvider( intf_thread_t *_p_intf ) :
     connect( menusMapper, SIGNAL( mapped(QObject *) ), this,
             SLOT(menuAction( QObject *)) );
 
+    menusUpdateMapper = new QSignalMapper();
+    connect( menusMapper, SIGNAL( mapped(QObject *) ), this,
+            SLOT(menuUpdateAction( QObject *)) );
 }
 
 DialogsProvider::~DialogsProvider()
@@ -152,6 +155,12 @@ void DialogsProvider::menuAction( QObject *data )
     QVLCMenu::DoAction( p_intf, data );
 }
 
+void DialogsProvider::menuUpdateAction( QObject *data )
+{
+    MenuFunc * f = qobject_cast<MenuFunc *>(data);
+    f->doFunc( p_intf );
+}
+
 void DialogsProvider::simpleOpenDialog()
 {
 }

modules/gui/qt4/dialogs_provider.hpp

@@ -56,6 +56,7 @@ public:
 protected:
     friend class QVLCMenu;
     QSignalMapper *menusMapper;
+    QSignalMapper *menusUpdateMapper;
     void customEvent( QEvent *);
 private:
     DialogsProvider( intf_thread_t *);
@@ -73,6 +74,7 @@ public slots:
     void popupMenu( int );
     void doInteraction( intf_dialog_args_t * );
     void menuAction( QObject *);
+    void menuUpdateAction( QObject *);
     void streamingDialog();
 };
 

modules/gui/qt4/input_manager.cpp

@@ -34,10 +34,10 @@
 InputManager::InputManager( QObject *parent, intf_thread_t *_p_intf) :
                            QObject( parent ), p_intf( _p_intf )
 {
+    i_old_playing_status = END_S;
     p_input = NULL;
     /* Subscribe to updates */
-    connect( DialogsProvider::getInstance( p_intf )->fixed_timer,
-             SIGNAL( timeout() ), this, SLOT( update() ) );
+    connect( THEDP->fixed_timer, SIGNAL( timeout() ), this, SLOT( update() ) );
 }
 
 InputManager::~InputManager()
@@ -103,6 +103,14 @@ void InputManager::update()
     }
     emit nameChanged( text );
 
+    /* Update playing status */
+    var_Get( p_input, "state", &val );
+    val.i_int = val.i_int == PAUSE_S ? PAUSE_S : PLAYING_S;
+    if( i_old_playing_status != val.i_int )
+    {
+        i_old_playing_status = val.i_int;
+        emit statusChanged(  val.i_int == PAUSE_S ? PAUSE_S : PLAYING_S );
+    }
 }
 
 void InputManager::sliderUpdate( float new_pos )
@@ -111,6 +119,24 @@ void InputManager::sliderUpdate( float new_pos )
         var_SetFloat( p_input, "position", new_pos );
 }
 
+void InputManager::togglePlayPause()
+{
+    vlc_value_t state;
+    var_Get( p_input, "state", &state );
+    if( state.i_int != PAUSE_S )
+    {
+        /* A stream is being played, pause it */
+        state.i_int = PAUSE_S;
+    }
+    else
+    {
+        /* Stream is paused, resume it */
+        state.i_int = PLAYING_S;
+    }
+    var_Set( p_input, "state", state );
+    emit statusChanged( state.i_int );
+}
+
 /**********************************************************************
  * MainInputManager implementation. Wrap an input manager and
  * take care of updating the main playlist input
@@ -157,3 +183,13 @@ void MainInputManager::updateInput()
     }
     vlc_mutex_unlock( &p_intf->change_lock );
 }
+
+void MainInputManager::togglePlayPause()
+{
+    if( p_input == NULL )
+    {
+        playlist_Play( THEPL );
+        return;
+    }
+    getIM()->togglePlayPause();
+}

modules/gui/qt4/input_manager.hpp

@@ -37,8 +37,10 @@ public:
 private:
     intf_thread_t *p_intf;
     input_thread_t *p_input;
+    int i_old_playing_status;
 
 public slots:
+    void togglePlayPause();
     void update(); ///< Periodic updates
     void setInput( input_thread_t * ); ///< Our controlled input changed
     void sliderUpdate( float ); ///< User dragged the slider. We get new pos
@@ -70,6 +72,8 @@ private:
     input_thread_t *p_input;
     static MainInputManager *instance;
     MainInputManager( intf_thread_t *);
+public slots:
+    void togglePlayPause();
 private slots:
     void updateInput();
 signals:

modules/gui/qt4/main_interface.cpp

@@ -30,6 +30,7 @@
 #include <QCloseEvent>
 #include <assert.h>
 #include <QPushButton>
+#include "menus.hpp"
 
 static int InteractCallback( vlc_object_t *, const char *, vlc_value_t,
                              vlc_value_t, void *);
@@ -57,10 +58,9 @@ MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf )
     ui.volLowLabel->setPixmap( QPixmap( ":/pixmaps/volume-low.png" ) );
     ui.volHighLabel->setPixmap( QPixmap( ":/pixmaps/volume-high.png" ) );
 
-    //QVLCMenu::createMenuBar();
+    QVLCMenu::createMenuBar( menuBar(), p_intf );
 
     resize (500, 131 );
-    fprintf( stderr, "Before creating the video widget, size is %ix%i\n", size().width(), size().height() );
 //    if( config_GetInt( p_intf, "embedded" ) )
 
     {
@@ -99,19 +99,18 @@ MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf )
     MainInputManager::getInstance( p_intf );
 
     /* Get timer updates */
-    connect( DialogsProvider::getInstance(NULL)->fixed_timer,
-             SIGNAL( timeout() ), this, SLOT(updateOnTimer() ) );
+    connect( THEDP->fixed_timer, SIGNAL( timeout() ),
+             this, SLOT(updateOnTimer() ) );
 
     /* Connect the input manager to the GUI elements it manages */
-    connect( MainInputManager::getInstance( p_intf )->getIM(),
-             SIGNAL(positionUpdated( float, int, int ) ),
+    connect( THEMIM->getIM(),SIGNAL(positionUpdated( float, int, int ) ),
              slider, SLOT( setPosition( float,int, int ) ) );
-    connect( slider, SIGNAL( sliderDragged( float ) ),
-             MainInputManager::getInstance( p_intf )->getIM(),
-             SLOT( sliderUpdate( float ) ) );
-    connect( MainInputManager::getInstance( p_intf )->getIM(),
-             SIGNAL( positionUpdated( float, int, int ) ),
+    connect( THEMIM->getIM(), SIGNAL( positionUpdated( float, int, int ) ),
              this, SLOT( setDisplay( float, int, int ) ) );
+    connect( THEMIM->getIM(), SIGNAL( statusChanged( int ) ),
+             this, SLOT( setStatus( int ) ) );
+    connect( slider, SIGNAL( sliderDragged( float ) ),
+             THEMIM->getIM(),SLOT( sliderUpdate( float ) ) );
 
     /* Actions */
     connect( ui.playButton, SLOT( clicked() ), this, SLOT( play() ) );
@@ -119,8 +118,8 @@ MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf )
     connect( ui.nextButton, SLOT( clicked() ), this, SLOT( next() ) );
     connect( ui.prevButton, SLOT( clicked() ), this, SLOT( prev() ) );
 
-    connect( ui.playlistButton, SLOT(clicked() ), 
-             DialogsProvider::getInstance( p_intf ), SLOT( playlistDialog() ) );
+    connect( ui.playlistButton, SLOT(clicked()),
+             THEDP, SLOT( playlistDialog() ) );
 
     var_Create( p_intf, "interaction", VLC_VAR_ADDRESS );
     var_AddCallback( p_intf, "interaction", InteractCallback, this );
@@ -143,16 +142,8 @@ MainInterface::~MainInterface()
 
 void MainInterface::resizeEvent( QResizeEvent *e )
 {
-    fprintf( stderr, "Resized to %ix%i\n", e->size().width(), e->size().height() );
-
-     fprintf( stderr, "MI constraints %ix%i -> %ix%i\n",
-                             p_intf->p_sys->p_mi->minimumSize().width(),
-                             p_intf->p_sys->p_mi->minimumSize().height(),
-                               p_intf->p_sys->p_mi->maximumSize().width(),
-                               p_intf->p_sys->p_mi->maximumSize().height() );
-     
-        videoSize.setHeight( e->size().height() - addSize.height() );
-        videoSize.setWidth( e->size().width() - addSize.width() );
+    videoSize.setHeight( e->size().height() - addSize.height() );
+    videoSize.setWidth( e->size().width() - addSize.width() );
     p_intf->p_sys->p_video->updateGeometry() ;
 }
 
@@ -162,7 +153,14 @@ void MainInterface::stop()
 }
 void MainInterface::play()
 {
-    playlist_Play( THEPL );
+    if( !THEPL->i_size || !THEPL->i_enabled )
+    {
+        /* The playlist is empty, open a file requester */
+        THEDP->openDialog();
+        setStatus( 0 );
+        return;
+    }
+    THEMIM->togglePlayPause();
 }
 void MainInterface::prev()
 {
@@ -183,6 +181,15 @@ void MainInterface::setDisplay( float pos, int time, int length )
     ui.sliderBox->setTitle( title );
 }
 
+void MainInterface::setStatus( int status )
+{
+    fprintf( stderr, "Status is now %i\n", status );
+    if( status == 2 ) // Playing
+        ui.playButton->setIcon( QIcon( ":/pixmaps/pause.png" ) );
+    else
+        ui.playButton->setIcon( QIcon( ":/pixmaps/play.png" ) );
+}
+
 void MainInterface::updateOnTimer()
 {
     if( p_intf->b_die )
@@ -206,7 +213,6 @@ static int InteractCallback( vlc_object_t *p_this,
     
     MainInterface *p_interface = (MainInterface*)param;
     DialogEvent *event = new DialogEvent( INTF_DIALOG_INTERACTION, 0, p_arg );
-    QApplication::postEvent( DialogsProvider::getInstance( NULL ),
-                                             static_cast<QEvent*>(event) );
+    QApplication::postEvent( THEDP, static_cast<QEvent*>(event) );
     return VLC_SUCCESS;
 }

modules/gui/qt4/main_interface.hpp

@@ -53,6 +53,7 @@ private:
     input_thread_t *p_input;
     Ui::MainInterfaceUI ui;
 private slots:
+    void setStatus( int );
     void setDisplay( float, int, int );
     void updateOnTimer();
     void play();

modules/gui/qt4/menus.cpp

@@ -23,7 +23,9 @@
 
 #include "menus.hpp"
 #include "dialogs_provider.hpp"
+#include "input_manager.hpp"
 #include <QMenu>
+#include <QMenuBar>
 #include <QAction>
 #include <QActionGroup>
 #include <QSignalMapper>
@@ -37,59 +39,23 @@ enum
 
 static QActionGroup *currentGroup;
 
-/*****************************************************************************
- * Static menu helpers
- * These create already mapped and connected menus
- *****************************************************************************/
-
-#define STATIC_ADD( text, help, icon, slot ) { QAction *action = menu->addAction( text, THEDP, SLOT( slot ) ); }
-
-QMenu *QVLCMenu::FileMenu()
-{
-    QMenu *menu = new QMenu();
-
-    STATIC_ADD( _("Quick &Open File...") , "", NULL, simpleOpenDialog() );
-    STATIC_ADD( _("&Advanced Open..." ), "", NULL, openDialog() );
-    menu->addSeparator();
-    STATIC_ADD( _("Streaming..."), "", NULL, streamingDialog() );
-    menu->addSeparator();
-    STATIC_ADD( _("&Quit") , "", NULL, quit() );
-
-    return menu;
-}
-
-#if 0
-QMenu *OpenStreamMenu( intf_thread_t *p_intf )
-{
-    QMenu *menu = new QMenu;
-    menu->Append( OpenFileSimple_Event, wxU(_("Quick &Open File...")) );
-    menu->Append( OpenFile_Event, wxU(_("Open &File...")) );
-    menu->Append( OpenDirectory_Event, wxU(_("Open D&irectory...")) );
-    menu->Append( OpenDisc_Event, wxU(_("Open &Disc...")) );
-    menu->Append( OpenNet_Event, wxU(_("Open &Network Stream...")) );
-    menu->Append( OpenCapture_Event, wxU(_("Open &Capture Device...")) );
-    return menu;
-}
-
-wxMenu *MiscMenu( intf_thread_t *p_intf )
-{
-    wxMenu *menu = new wxMenu;
-    menu->Append( MediaInfo_Event, wxU(_("Media &Info...")) );
-    menu->Append( Messages_Event, wxU(_("&Messages...")) );
-    menu->Append( Preferences_Event, wxU(_("&Preferences...")) );
-    return menu;
-}
+// Add static entries to menus
+#define DP_SADD( text, help, icon, slot ) { if( strlen(icon) > 0 ) { QAction *action = menu->addAction( text, THEDP, SLOT( slot ) ); action->setIcon(QIcon(icon));} else { menu->addAction( text, THEDP, SLOT( slot ) ); } }
+#define MIM_SADD( text, help, icon, slot ) { if( strlen(icon) > 0 ) { QAction *action = menu->addAction( text, THEMIM, SLOT( slot ) ); action->setIcon(QIcon(icon));} else { menu->addAction( text, THEMIM, SLOT( slot ) ); } }
 
-#endif
 /*****************************************************************************
- * Builders for the dynamic menus
+ * Definitions of variables for the dynamic menus
  *****************************************************************************/
-#define PUSH_VAR( var ) rs_varnames.push_back( var ); \
-                        ri_objects.push_back( p_object->i_object_id )
+#define PUSH_VAR( var ) varnames.push_back( var ); \
+                        objects.push_back( p_object->i_object_id )
+
+#define PUSH_SEPARATOR if( objects.size() != i_last_separator ) { \
+                           objects.push_back( 0 ); varnames.push_back( "" ); \
+                           i_last_separator = objects.size(); }
 
 static int InputAutoMenuBuilder( vlc_object_t *p_object,
-                                 vector<int> &ri_objects,
-                                 vector<const char *> &rs_varnames )
+                                 vector<int> &objects,
+                                 vector<const char *> &varnames )
 {
     PUSH_VAR( "bookmark");
     PUSH_VAR( "title" );
@@ -101,8 +67,8 @@ static int InputAutoMenuBuilder( vlc_object_t *p_object,
 }
 
 static int VideoAutoMenuBuilder( vlc_object_t *p_object, 
-                                 vector<int> &ri_objects,
-                                 vector<const char *> &rs_varnames )
+                                 vector<int> &objects,
+                                 vector<const char *> &varnames )
 {
     PUSH_VAR( "fullscreen" );
     PUSH_VAR( "zoom" );
@@ -125,8 +91,8 @@ static int VideoAutoMenuBuilder( vlc_object_t *p_object,
 }
 
 static int AudioAutoMenuBuilder( vlc_object_t *p_object,
-                                 vector<int> &ri_objects,
-                                 vector<const char *> &rs_varnames )
+                                 vector<int> &objects,
+                                 vector<const char *> &varnames )
 {
     PUSH_VAR( "audio-device" );
     PUSH_VAR( "audio-channels" );
@@ -135,321 +101,310 @@ static int AudioAutoMenuBuilder( vlc_object_t *p_object,
     return VLC_SUCCESS;
 }
 
-static int IntfAutoMenuBuilder( intf_thread_t *p_intf, vector<int> &ri_objects,
-                             vector<const char *> &rs_varnames, bool is_popup )
+/*****************************************************************************
+ * All normal menus
+ *****************************************************************************/
+
+void QVLCMenu::createMenuBar( QMenuBar *bar, intf_thread_t *p_intf )
+{
+#define BAR_ADD( func, title ) { \
+    QMenu *menu = func; menu->setTitle( title  ); bar->addMenu( menu ); }
+
+#define BAR_DADD( func, title, id ) { \
+    QMenu *menu = func; menu->setTitle( title  ); bar->addMenu( menu ); \
+    MenuFunc *f = new MenuFunc( menu, id ); \
+    connect( menu, SIGNAL( aboutToShow() ), \
+            THEDP->menusUpdateMapper, SLOT(map()) ); \
+    THEDP->menusUpdateMapper->setMapping( menu, f ); }
+
+    BAR_ADD( FileMenu(), _("File") );
+    BAR_ADD( ToolsMenu( p_intf ), _("Tools") );
+    BAR_DADD( VideoMenu( p_intf, NULL ), _("Video"), 1 );
+    BAR_DADD( AudioMenu( p_intf, NULL ), _("Audio"), 2 );
+    BAR_DADD( NavigMenu( p_intf, NULL ), _("Navigation"), 3 );
+
+    //    BAR_ADD( HelpMenu(), _("Help" ) );
+}
+
+QMenu *QVLCMenu::FileMenu()
+{
+    QMenu *menu = new QMenu();
+    DP_SADD( _("Quick &Open File...") , "", "", simpleOpenDialog() );
+    DP_SADD( _("&Advanced Open..." ), "", "", openDialog() );
+    menu->addSeparator();
+    DP_SADD( _("Streaming..."), "", "", streamingDialog() );
+    menu->addSeparator();
+    DP_SADD( _("&Quit") , "", "", quit() );
+    return menu;
+}
+
+QMenu *QVLCMenu::ToolsMenu( intf_thread_t *p_intf, bool with_intf )
+{
+    QMenu *menu = new QMenu();
+    if( with_intf )
+    {
+        QMenu *intfmenu = InterfacesMenu( p_intf, NULL );
+        intfmenu->setTitle( _("Interfaces" ) );
+        menu->addMenu( intfmenu );
+        /** \todo ADD EXT GUI HERE */
+        menu->addSeparator();
+    }
+    DP_SADD( _("Messages" ), "", "", messagesDialog() );
+    DP_SADD( _("Information") , "", "", streaminfoDialog() );
+    DP_SADD( _("Bookmarks"), "", "", bookmarksDialog() );
+    menu->addSeparator();
+    DP_SADD( _("Preferences"), "", "", prefsDialog() );
+    return menu;
+}
+
+QMenu *QVLCMenu::InterfacesMenu( intf_thread_t *p_intf, QMenu *current )
+{
+    vector<int> objects;
+    vector<const char *> varnames;
+    /** \todo add "switch to XXX" */
+    varnames.push_back( "intf-add" );
+    objects.push_back( p_intf->i_object_id );
+    
+    QMenu *menu = Populate( p_intf, current, varnames, objects );
+    connect( menu, SIGNAL( aboutToShow() ),
+             THEDP->menusUpdateMapper, SLOT(map()) );
+    THEDP->menusUpdateMapper->setMapping( menu, 4 );
+
+    return menu;
+}
+
+QMenu *QVLCMenu::AudioMenu( intf_thread_t *p_intf, QMenu * current )
+{
+    vector<int> objects;
+    vector<const char *> varnames;
+
+    vlc_object_t *p_object = (vlc_object_t *)vlc_object_find( p_intf,
+                                        VLC_OBJECT_INPUT, FIND_ANYWHERE );
+    if( p_object != NULL )
+    {
+        PUSH_VAR( "audio-es" );
+        vlc_object_release( p_object );
+    }
+
+    p_object = (vlc_object_t *)vlc_object_find( p_intf, VLC_OBJECT_AOUT,
+                                                FIND_ANYWHERE );
+    if( p_object )
+    {
+        AudioAutoMenuBuilder( p_object, objects, varnames );
+        vlc_object_release( p_object );
+    }
+    return Populate( p_intf, current, varnames, objects );
+}
+
+
+QMenu *QVLCMenu::VideoMenu( intf_thread_t *p_intf, QMenu *current )
 {
-    /* vlc_object_find is needed because of the dialogs provider case */
     vlc_object_t *p_object;
-    p_object = (vlc_object_t *)vlc_object_find( p_intf, VLC_OBJECT_INTF,
-                                                FIND_PARENT );
+    vector<int> objects;
+    vector<const char *> varnames;
+
+    p_object = (vlc_object_t *)vlc_object_find( p_intf, VLC_OBJECT_INPUT,
+                                                FIND_ANYWHERE );
     if( p_object != NULL )
     {
-        if( is_popup )
-        {
-            PUSH_VAR( "intf-switch" );
-        }
-        else
-        {
-            PUSH_VAR( "intf-switch" );
-        }
-        PUSH_VAR( "intf-add" );
-        PUSH_VAR( "intf-skins" );
+        PUSH_VAR( "video-es" );
+        PUSH_VAR( "spu-es" );
         vlc_object_release( p_object );
     }
-    return VLC_SUCCESS;
+
+    p_object = (vlc_object_t *)vlc_object_find( p_intf, VLC_OBJECT_VOUT,
+                                                FIND_ANYWHERE );
+    if( p_object != NULL )
+    {
+        VideoAutoMenuBuilder( p_object, objects, varnames );
+        vlc_object_release( p_object );
+    }
+    return Populate( p_intf, current, varnames, objects );
 }
 
-#undef PUSH_VAR
-/*****************************************************************************
- * Popup menus
- *****************************************************************************/
+QMenu *QVLCMenu::NavigMenu( intf_thread_t *p_intf, QMenu *current )
+{
+    vlc_object_t *p_object;
+    vector<int> objects;
+    vector<const char *> varnames;
 
-#define PUSH_VAR( var ) as_varnames.push_back( var ); \
-                        ai_objects.push_back( p_object->i_object_id )
+    /* FIXME */
+    p_object = (vlc_object_t *)vlc_object_find( p_intf, VLC_OBJECT_INPUT,
+                                                FIND_ANYWHERE );
+    if( p_object != NULL )
+    {
+        InputAutoMenuBuilder( p_object, objects, varnames );
+        PUSH_VAR( "prev-title"); PUSH_VAR ( "next-title" );
+        PUSH_VAR( "prev-chapter"); PUSH_VAR( "next-chapter" );
+        vlc_object_release( p_object );
+    }
+    return Populate( p_intf, current, varnames, objects );
+}
 
-#define PUSH_SEPARATOR if( ai_objects.size() != i_last_separator ) { \
-                            ai_objects.push_back( 0 ); \
-                            as_varnames.push_back( "" ); \
-                            i_last_separator = ai_objects.size(); }
 
+/*****************************************************************************
+ * Popup menus
+ *****************************************************************************/
 #define POPUP_BOILERPLATE \
     unsigned int i_last_separator = 0; \
-    vector<int> ai_objects; \
-    vector<const char *> as_varnames; \
-    playlist_t *p_playlist = (playlist_t *) vlc_object_find( p_intf, \
-                                          VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );\
-    if( !p_playlist ) \
-        return; \
-    input_thread_t *p_input = p_playlist->p_input
-
-#define CREATE_POPUP    \
-    QMenu *popupmenu = new QMenu(); \
-    QVLCMenu::Populate( popupmenu, as_varnames, ai_objects ); \
-    p_intf->p_sys->p_popup_menu = &popupmenu; \
+    vector<int> objects; \
+    vector<const char *> varnames; \
+    input_thread_t *p_input = THEMIM->getInput();
+
+#define CREATE_POPUP \
+    QMenu *menu = new QMenu(); \
+    Populate( p_intf, menu, varnames, objects ); \
+    p_intf->p_sys->p_popup_menu = menu; \
+    menu->popup( QCursor::pos() ); \
     p_intf->p_sys->p_popup_menu = NULL; \
-    i_last_separator = 0 // stop compiler warning 
-///    p_parent->PopupMenu( &popupmenu, pos.x, pos.y ); \ /// TODO
+    i_last_separator = 0;
 
 #define POPUP_STATIC_ENTRIES \
-    if( p_input != NULL ) \
+    vlc_value_t val; \
+    MIM_SADD( _("Stop"), "", "", stop() ); \
+    MIM_SADD( _("Previous"), "", "", prev() ); \
+    MIM_SADD( _("Next"), "", "", next() ); \
+    if( p_input ) \
     { \
-        vlc_value_t val; \
-        popupmenu.InsertSeparator( 0 ); \
-        popupmenu.Insert( 0, Stop_Event, wxU(_("Stop")) ); \
-        popupmenu.Insert( 0, Previous_Event, wxU(_("Previous")) ); \
-        popupmenu.Insert( 0, Next_Event, wxU(_("Next")) ); \
         var_Get( p_input, "state", &val ); \
         if( val.i_int == PAUSE_S ) \
-            popupmenu.Insert( 0, Play_Event, wxU(_("Play")) ); \
+            MIM_SADD( _("Play"), "", "", togglePlayPause() ) \
         else \
-            popupmenu.Insert( 0, Pause_Event, wxU(_("Pause")) ); \
-         \
-        vlc_object_release( p_input ); \
-    } \
-    else \
-    { \
-        if( p_playlist && p_playlist->i_size ) \
-        { \
-            popupmenu.InsertSeparator( 0 ); \
-            popupmenu.Insert( 0, Play_Event, wxU(_("Play")) ); \
-        } \
-        if( p_playlist ) vlc_object_release( p_playlist ); \
+            MIM_SADD( _("Pause"), "", "", togglePlayPause() ) \
     } \
+    else if( THEPL->i_size && THEPL->i_enabled ) \
+        MIM_SADD( _("Play"), "", "", togglePlayPause() ) \
     \
-    popupmenu.Append( MenuDummy_Event, wxU(_("Miscellaneous")), \
-                      MiscMenu( p_intf ), wxT("") )
-
-void QVLCMenu::VideoPopupMenu( intf_thread_t *p_intf, const QPoint &pos )
+    QMenu *intfmenu = InterfacesMenu( p_intf, NULL ); \
+    intfmenu->setTitle( _("Interfaces" ) ); \
+    menu->addMenu( intfmenu ); \
+    \
+    QMenu *toolsmenu = ToolsMenu( p_intf, false ); \
+    toolsmenu->setTitle( _("Tools" ) ); \
+    menu->addMenu( toolsmenu ); \
+     
+void QVLCMenu::VideoPopupMenu( intf_thread_t *p_intf )
 {
     POPUP_BOILERPLATE;
     if( p_input )
     {
         vlc_object_yield( p_input );
-        as_varnames.push_back( "video-es" );
-        ai_objects.push_back( p_input->i_object_id );
-        as_varnames.push_back( "spu-es" );
-        ai_objects.push_back( p_input->i_object_id );
+        varnames.push_back( "video-es" );
+        objects.push_back( p_input->i_object_id );
+        varnames.push_back( "spu-es" );
+        objects.push_back( p_input->i_object_id );
         vlc_object_t *p_vout = (vlc_object_t *)vlc_object_find( p_input,