git.sesse.net Git - vlc/blob - modules/gui/qt4/menus.cpp

   1 /*****************************************************************************
   2  * menus.cpp : Qt menus
   3  *****************************************************************************
   4  * Copyright ( C ) 2006-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Clément Stenac <zorglub@videolan.org>
   8  *          Jean-Baptiste Kempf <jb@videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * ( at your option ) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /** \todo
  26  * - Remove static currentGroup
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <vlc_common.h>
  34
  35 #include <vlc_intf_strings.h>
  36
  37 #include "main_interface.hpp"
  38 #include "menus.hpp"
  39 #include "dialogs_provider.hpp"
  40 #include "input_manager.hpp"
  41
  42 #include <QMenu>
  43 #include <QMenuBar>
  44 #include <QAction>
  45 #include <QActionGroup>
  46 #include <QSignalMapper>
  47 #include <QSystemTrayIcon>
  48
  49 enum
  50 {
  51     ITEM_NORMAL,
  52     ITEM_CHECK,
  53     ITEM_RADIO
  54 };
  55
  56 static QActionGroup *currentGroup;
  57
  58 // Add static entries to menus
  59 void addDPStaticEntry( QMenu *menu,
  60                        const QString text,
  61                        const char *help,
  62                        const char *icon,
  63                        const char *member,
  64                        const char *shortcut )
  65 {
  66     if( !EMPTY_STR( icon ) > 0 )
  67     {
  68         if( !EMPTY_STR( shortcut ) > 0 )
  69             menu->addAction( QIcon( icon ), text, THEDP, member, qtr( shortcut ) );
  70         else
  71             menu->addAction( QIcon( icon ), text, THEDP, member );
  72     }
  73     else
  74     {
  75         if( !EMPTY_STR( shortcut ) > 0 )
  76             menu->addAction( text, THEDP, member, qtr( shortcut ) );
  77         else
  78             menu->addAction( text, THEDP, member );
  79     }
  80 }
  81
  82 void addMIMStaticEntry( intf_thread_t *p_intf,
  83                         QMenu *menu,
  84                         const QString text,
  85                         const char *help,
  86                         const char *icon,
  87                         const char *member )
  88 {
  89     if( strlen( icon ) > 0 )
  90     {
  91         QAction *action = menu->addAction( text, THEMIM,  member );
  92         action->setIcon( QIcon( icon ) );
  93     }
  94     else
  95     {
  96         menu->addAction( text, THEMIM, member );
  97     }
  98 }
  99
 100 /*****************************************************************************
 101  * Definitions of variables for the dynamic menus
 102  *****************************************************************************/
 103 #define PUSH_VAR( var ) varnames.push_back( var ); \
 104     objects.push_back( p_object ? p_object->i_object_id : 0 )
 105
 106 #define PUSH_INPUTVAR( var ) varnames.push_back( var ); \
 107     objects.push_back( p_input ? p_input->i_object_id : 0 );
 108
 109 #define PUSH_SEPARATOR if( objects.size() != i_last_separator ) { \
 110     objects.push_back( 0 ); varnames.push_back( "" ); \
 111     i_last_separator = objects.size(); }
 112
 113 static int InputAutoMenuBuilder( vlc_object_t *p_object,
 114         vector<int> &objects,
 115         vector<const char *> &varnames )
 116 {
 117     PUSH_VAR( "bookmark" );
 118     PUSH_VAR( "title" );
 119     PUSH_VAR( "chapter" );
 120     PUSH_VAR( "program" );
 121     PUSH_VAR( "navigation" );
 122     PUSH_VAR( "dvd_menus" );
 123     return VLC_SUCCESS;
 124 }
 125
 126 static int VideoAutoMenuBuilder( vlc_object_t *p_object,
 127         input_thread_t *p_input,
 128         vector<int> &objects,
 129         vector<const char *> &varnames )
 130 {
 131     PUSH_INPUTVAR( "video-es" );
 132     PUSH_INPUTVAR( "spu-es" );
 133     PUSH_VAR( "fullscreen" );
 134     PUSH_VAR( "zoom" );
 135     PUSH_VAR( "deinterlace" );
 136     PUSH_VAR( "aspect-ratio" );
 137     PUSH_VAR( "crop" );
 138     PUSH_VAR( "video-on-top" );
 139     PUSH_VAR( "directx-wallpaper" );
 140     PUSH_VAR( "video-snapshot" );
 141
 142     if( p_object )
 143     {
 144         vlc_object_t *p_dec_obj = ( vlc_object_t * )vlc_object_find( p_object,
 145                 VLC_OBJECT_DECODER,
 146                 FIND_PARENT );
 147         if( p_dec_obj )
 148         {
 149             vlc_object_t *p_object = p_dec_obj;
 150             PUSH_VAR( "ffmpeg-pp-q" );
 151             vlc_object_release( p_dec_obj );
 152         }
 153     }
 154     return VLC_SUCCESS;
 155 }
 156
 157 static int AudioAutoMenuBuilder( vlc_object_t *p_object,
 158         input_thread_t *p_input,
 159         vector<int> &objects,
 160         vector<const char *> &varnames )
 161 {
 162     PUSH_INPUTVAR( "audio-es" );
 163     PUSH_VAR( "audio-device" );
 164     PUSH_VAR( "audio-channels" );
 165     PUSH_VAR( "visual" );
 166     PUSH_VAR( "equalizer" );
 167     return VLC_SUCCESS;
 168 }
 169
 170 static QAction * FindActionWithVar( QMenu *menu, const char *psz_var )
 171 {
 172     QAction *action;
 173     Q_FOREACH( action, menu->actions() )
 174     {
 175         if( action->data().toString() == psz_var )
 176             return action;
 177     }
 178     return NULL;
 179 }
 180
 181 static QAction * FindActionWithText( QMenu *menu, QString &text )
 182 {
 183     QAction *action;
 184     Q_FOREACH( action, menu->actions() )
 185     {
 186         if( action->text() == text )
 187             return action;
 188     }
 189     return NULL;
 190 }
 191
 192 /*****************************************************************************
 193  * All normal menus
 194  * Simple Code
 195  *****************************************************************************/
 196
 197 #define BAR_ADD( func, title ) { \
 198     QMenu *_menu = func; _menu->setTitle( title ); bar->addMenu( _menu ); }
 199
 200 #define BAR_DADD( func, title, id ) { \
 201     QMenu *_menu = func; _menu->setTitle( title ); bar->addMenu( _menu ); \
 202     MenuFunc *f = new MenuFunc( _menu, id ); \
 203     CONNECT( _menu, aboutToShow(), THEDP->menusUpdateMapper, map() ); \
 204     THEDP->menusUpdateMapper->setMapping( _menu, f ); }
 205
 206 #define ACT_ADD( _menu, val, title ) { \
 207     QAction *_action = new QAction( title, _menu ); _action->setData( val ); \
 208     _menu->addAction( _action ); }
 209
 210 /**
 211  * Main Menu Bar Creation
 212  **/
 213 void QVLCMenu::createMenuBar( MainInterface *mi,
 214                               intf_thread_t *p_intf,
 215                               bool visual_selector_enabled )
 216 {
 217     /* QMainWindows->menuBar()
 218        gives the QProcess::destroyed timeout issue on Cleanlooks style with
 219        setDesktopAware set to false */
 220     QMenuBar *bar = mi->menuBar();
 221     BAR_ADD( FileMenu(), qtr( "&Media" ) );
 222     BAR_ADD( PlaylistMenu( p_intf, mi ), qtr( "&Playlist" ) );
 223     BAR_ADD( ToolsMenu( p_intf, NULL, mi, visual_selector_enabled, true ),
 224              qtr( "&Tools" ) );
 225     BAR_DADD( AudioMenu( p_intf, NULL ), qtr( "&Audio" ), 1 );
 226     BAR_DADD( VideoMenu( p_intf, NULL ), qtr( "&Video" ), 2 );
 227     BAR_DADD( NavigMenu( p_intf, NULL ), qtr( "&Playback" ), 3 );
 228     BAR_ADD( HelpMenu( NULL ), qtr( "&Help" ) );
 229 }
 230 #undef BAR_ADD
 231 #undef BAR_DADD
 232
 233 /**
 234  * Media ( File ) Menu
 235  * Opening, streaming and quit
 236  **/
 237 QMenu *QVLCMenu::FileMenu()
 238 {
 239     QMenu *menu = new QMenu();
 240
 241     addDPStaticEntry( menu, qtr( "&Open File..." ), "",
 242         ":/pixmaps/file-asym_16px.png", SLOT( openFileDialog() ), "Ctrl+O" );
 243     addDPStaticEntry( menu, qtr( I_OPEN_FOLDER ), "",
 244         ":/pixmaps/folder-grey_16px.png", SLOT( PLAppendDir() ), "Ctrl+F" );
 245     addDPStaticEntry( menu, qtr( "Open &Disc..." ), "",
 246         ":/pixmaps/disc_16px.png", SLOT( openDiscDialog() ), "Ctrl+D" );
 247     addDPStaticEntry( menu, qtr( "Open &Network..." ), "",
 248         ":/pixmaps/network_16px.png", SLOT( openNetDialog() ), "Ctrl+N" );
 249     addDPStaticEntry( menu, qtr( "Open &Capture Device..." ), "",
 250         ":/pixmaps/capture-card_16px.png", SLOT( openCaptureDialog() ),
 251         "Ctrl+C" );
 252     menu->addSeparator();
 253
 254     addDPStaticEntry( menu, qtr( "&Streaming..." ), "",
 255         ":/pixmaps/menus_stream_16px.png", SLOT( openThenStreamingDialogs() ),
 256         "Ctrl+S" );
 257     addDPStaticEntry( menu, qtr( "Conve&rt / Save..." ), "", "",
 258         SLOT( openThenTranscodingDialogs() ), "Ctrl+R" );
 259     menu->addSeparator();
 260
 261     addDPStaticEntry( menu, qtr( "&Quit" ) , "",
 262         ":/pixmaps/menus_quit_16px.png", SLOT( quit() ), "Ctrl+Q" );
 263     return menu;
 264 }
 265
 266 /* Playlist/MediaLibrary Control */
 267 QMenu *QVLCMenu::PlaylistMenu( intf_thread_t *p_intf, MainInterface *mi )
 268 {
 269     QMenu *menu = new QMenu();
 270     menu->addMenu( SDMenu( p_intf ) );
 271     menu->addAction( QIcon( ":/pixmaps/playlist_16px.png" ),
 272                      qtr( "Show Playlist" ), mi, SLOT( togglePlaylist() ) );
 273     menu->addSeparator();
 274
 275     addDPStaticEntry( menu, qtr( I_PL_LOAD ), "", "", SLOT( openAPlaylist() ),
 276         "Ctrl+X" );
 277     addDPStaticEntry( menu, qtr( I_PL_SAVE ), "", "", SLOT( saveAPlaylist() ),
 278         "Ctrl+Y" );
 279     menu->addSeparator();
 280     menu->addAction( qtr( "Undock from interface" ), mi,
 281                      SLOT( undockPlaylist() ), qtr( "Ctrl+U" ) );
 282     return menu;
 283 }
 284
 285 /**
 286  * Tools/View Menu
 287  * This is kept in the same menu for now, but could change if it gets much
 288  * longer.
 289  * This menu can be an interface menu but also a right click menu.
 290  **/
 291 QMenu *QVLCMenu::ToolsMenu( intf_thread_t *p_intf,
 292                             QMenu *current,
 293                             MainInterface *mi,
 294                             bool visual_selector_enabled,
 295                             bool with_intf )
 296 {
 297     QMenu *menu = new QMenu( current );
 298     if( mi )
 299     {
 300         menu->addAction( QIcon( ":/pixmaps/playlist_16px.png" ),
 301                          qtr( "Playlist..." ), mi, SLOT( togglePlaylist() ),
 302                          qtr( "Ctrl+L" ) );
 303     }
 304     addDPStaticEntry( menu, qtr( I_MENU_EXT ), "",
 305         ":/pixmaps/menus_settings_16px.png", SLOT( extendedDialog() ),
 306         "Ctrl+E" );
 307
 308     menu->addSeparator();
 309
 310     if( with_intf )
 311     {
 312         QMenu *intfmenu = InterfacesMenu( p_intf, menu );
 313         intfmenu->setTitle( qtr( "Add Interfaces" ) );
 314         menu->addMenu( intfmenu );
 315         menu->addSeparator();
 316     }
 317     if( mi )
 318     {
 319         /* Minimal View */
 320         QAction *action=menu->addAction( qtr( "Minimal View..." ), mi,
 321                 SLOT( toggleMinimalView() ), qtr( "Ctrl+H" ) );
 322         action->setCheckable( true );
 323         if( mi->getControlsVisibilityStatus() & CONTROLS_VISIBLE )
 324             action->setChecked( true );
 325
 326         /* FullScreen View */
 327         action = menu->addAction( qtr( "Toggle Fullscreen Interface" ), mi,
 328                 SLOT( toggleFullScreen() ), qtr( "F11" ) );
 329
 330         /* Advanced Controls */
 331         action = menu->addAction( qtr( "Advanced controls" ), mi,
 332                 SLOT( toggleAdvanced() ) );
 333         action->setCheckable( true );
 334         if( mi->getControlsVisibilityStatus() & CONTROLS_ADVANCED )
 335             action->setChecked( true );
 336 #if 0 /* For Visualisations. Not yet working */
 337         adv = menu->addAction( qtr( "Visualizations selector" ),
 338                 mi, SLOT( visual() ) );
 339         adv->setCheckable( true );
 340         if( visual_selector_enabled ) adv->setChecked( true );
 341 #endif
 342     }
 343
 344     menu->addSeparator();
 345
 346     addDPStaticEntry( menu, qtr( I_MENU_MSG ), "",
 347         ":/pixmaps/menus_messages_16px.png", SLOT( messagesDialog() ),
 348         "Ctrl+M" );
 349     addDPStaticEntry( menu, qtr( I_MENU_INFO ) , "", "",
 350         SLOT( mediaInfoDialog() ), "Ctrl+I" );
 351     addDPStaticEntry( menu, qtr( I_MENU_CODECINFO ) , "",
 352         ":/pixmaps/menus_info_16px.png", SLOT( mediaCodecDialog() ), "Ctrl+J" );
 353     addDPStaticEntry( menu, qtr( I_MENU_BOOKMARK ), "","",
 354                       SLOT( bookmarksDialog() ), "Ctrl+B" );
 355 #ifdef ENABLE_VLM
 356     addDPStaticEntry( menu, qtr( I_MENU_VLM ), "", "", SLOT( vlmDialog() ),
 357         "Ctrl+W" );
 358 #endif
 359
 360     menu->addSeparator();
 361     addDPStaticEntry( menu, qtr( "Preferences..." ), "",
 362         ":/pixmaps/menus_preferences_16px.png", SLOT( prefsDialog() ), "Ctrl+P" );
 363     return menu;
 364 }
 365
 366 /**
 367  * Interface Sub-Menu, to list extras interface and skins
 368  **/
 369 QMenu *QVLCMenu::InterfacesMenu( intf_thread_t *p_intf, QMenu *current )
 370 {
 371     vector<int> objects;
 372     vector<const char *> varnames;
 373     /** \todo add "switch to XXX" */
 374     varnames.push_back( "intf-add" );
 375     objects.push_back( p_intf->i_object_id );
 376
 377     QMenu *submenu = new QMenu( current );
 378     QMenu *menu = Populate( p_intf, submenu, varnames, objects );
 379
 380     CONNECT( menu, aboutToShow(), THEDP->menusUpdateMapper, map() );
 381     THEDP->menusUpdateMapper->setMapping( menu, 4 );
 382     return menu;
 383 }
 384
 385 /**
 386  * Main Audio Menu
 387  */
 388 QMenu *QVLCMenu::AudioMenu( intf_thread_t *p_intf, QMenu * current )
 389 {
 390     vector<int> objects;
 391     vector<const char *> varnames;
 392     vlc_object_t *p_object;
 393     input_thread_t *p_input;
 394
 395     if( !current )
 396         current = new QMenu();
 397
 398     if( current->isEmpty() )
 399     {
 400         ACT_ADD( current, "audio-es", qtr( "Audio &Track" ) );
 401         ACT_ADD( current, "audio-device", qtr( "Audio &Device" ) );
 402         ACT_ADD( current, "audio-channels", qtr( "Audio &Channels" ) );
 403         ACT_ADD( current, "visual", qtr( "&Visualizations" ) );
 404         ACT_ADD( current, "equalizer", qtr( "&Equalizer" ) );
 405     }
 406
 407     p_input = THEMIM->getInput();
 408     if( p_input )
 409         vlc_object_yield( p_input );
 410     p_object = ( vlc_object_t * ) vlc_object_find( p_intf,
 411                                                    VLC_OBJECT_AOUT,
 412                                                    FIND_ANYWHERE );
 413
 414     AudioAutoMenuBuilder( p_object, p_input, objects, varnames );
 415
 416     if( p_object )
 417         vlc_object_release( p_object );
 418     if( p_input )
 419         vlc_object_release( p_input );
 420
 421     return Populate( p_intf, current, varnames, objects );
 422 }
 423
 424 /**
 425  * Main Video Menu
 426  * Subtitles are part of Video.
 427  **/
 428 QMenu *QVLCMenu::VideoMenu( intf_thread_t *p_intf, QMenu *current )
 429 {
 430     vlc_object_t *p_object;
 431     input_thread_t *p_input;
 432     vector<int> objects;
 433     vector<const char *> varnames;
 434
 435     if( !current )
 436         current = new QMenu();
 437
 438     if( current->isEmpty() )
 439     {
 440         ACT_ADD( current, "video-es", qtr( "Video &Track" ) );
 441         ACT_ADD( current, "fullscreen", qtr( "&Fullscreen" ) );
 442         ACT_ADD( current, "zoom", qtr( "&Zoom" ) );
 443         ACT_ADD( current, "deinterlace", qtr( "&Deinterlace" ) );
 444         ACT_ADD( current, "aspect-ratio", qtr( "&Aspect Ratio" ) );
 445         ACT_ADD( current, "crop", qtr( "&Crop" ) );
 446         ACT_ADD( current, "video-on-top", qtr( "Always &On Top" ) );
 447         ACT_ADD( current, "directx-wallpaper", qtr( "&DirectX Wallpaper" ) ); /* FIXME */
 448         ACT_ADD( current, "video-snapshot", qtr( "&Snapshot" ) );
 449         ACT_ADD( current, "ffmpeg-pp-q", qtr( "D&ecoder" ) ); /* FIXME */
 450     }
 451
 452     p_input = THEMIM->getInput();
 453     if( p_input )
 454         vlc_object_yield( p_input );
 455     p_object = ( vlc_object_t * )vlc_object_find( p_intf, VLC_OBJECT_VOUT,
 456             FIND_ANYWHERE );
 457
 458     VideoAutoMenuBuilder( p_object, p_input, objects, varnames );
 459
 460     if( p_object )
 461         vlc_object_release( p_object );
 462     if( p_input )
 463         vlc_object_release( p_input );
 464
 465     return Populate( p_intf, current, varnames, objects );
 466 }
 467
 468 /**
 469  * Navigation Menu
 470  * For DVD, MP4, MOV and other chapter based format
 471  **/
 472 QMenu *QVLCMenu::NavigMenu( intf_thread_t *p_intf, QMenu *menu )
 473 {
 474     vlc_object_t *p_object;
 475     vector<int> objects;
 476     vector<const char *> varnames;
 477
 478     p_object = ( vlc_object_t * )vlc_object_find( p_intf, VLC_OBJECT_INPUT,
 479             FIND_ANYWHERE );
 480     InputAutoMenuBuilder(  p_object, objects, varnames );
 481     PUSH_VAR( "prev-title" );
 482     PUSH_VAR( "next-title" );
 483     PUSH_VAR( "prev-chapter" );
 484     PUSH_VAR( "next-chapter" );
 485     if( p_object )
 486         vlc_object_release( p_object );
 487     QMenu *navMenu = new QMenu( menu );
 488     addDPStaticEntry( navMenu, qtr( I_MENU_GOTOTIME ), "","",
 489         SLOT( gotoTimeDialog() ), "Ctrl+T" );
 490     navMenu->addSeparator();
 491     return Populate( p_intf, navMenu, varnames, objects, true );
 492 }
 493
 494 /**
 495  * Service Discovery SubMenu
 496  **/
 497 QMenu *QVLCMenu::SDMenu( intf_thread_t *p_intf )
 498 {
 499     QMenu *menu = new QMenu();
 500     menu->setTitle( qtr( I_PL_SD ) );
 501     char **ppsz_longnames;
 502     char **ppsz_names = services_discovery_GetServicesNames( p_intf,
 503                                                              &ppsz_longnames );
 504     if( !ppsz_names )
 505         return menu;
 506
 507     char **ppsz_name = ppsz_names, **ppsz_longname = ppsz_longnames;
 508     for( ; *ppsz_name; ppsz_name++, ppsz_longname++ )
 509     {
 510         QAction *a = new QAction( qfu( *ppsz_longname ), menu );
 511         a->setCheckable( true );
 512         if( playlist_IsServicesDiscoveryLoaded( THEPL, *ppsz_name ) )
 513             a->setChecked( true );
 514         CONNECT( a , triggered(), THEDP->SDMapper, map() );
 515         THEDP->SDMapper->setMapping( a, QString( *ppsz_name ) );
 516         menu->addAction( a );
 517
 518         if( !strcmp( *ppsz_name, "podcast" ) )
 519         {
 520             QAction *b = new QAction( qfu( "Configure podcasts..." ), menu );
 521             //b->setEnabled( a->isChecked() );
 522             menu->addAction( b );
 523             CONNECT( b, triggered(), THEDP, podcastConfigureDialog() );
 524         }
 525         free( *ppsz_name );
 526         free( *ppsz_longname );
 527     }
 528     free( ppsz_names );
 529     free( ppsz_longnames );
 530     return menu;
 531 }
 532 /**
 533  * Help/About Menu
 534 **/
 535 QMenu *QVLCMenu::HelpMenu( QMenu *current )
 536 {
 537     QMenu *menu = new QMenu( current );
 538     addDPStaticEntry( menu, qtr( "Help..." ) , "",
 539         ":/pixmaps/menus_help_16px.png", SLOT( helpDialog() ), "F1" );
 540 #ifdef UPDATE_CHECK
 541     addDPStaticEntry( menu, qtr( "Check for updates..." ) , "", "", SLOT( updateDialog() ), "");
 542 #endif
 543     menu->addSeparator();
 544     addDPStaticEntry( menu, qtr( I_MENU_ABOUT ), "", "", SLOT( aboutDialog() ),
 545         "Ctrl+F1" );
 546     return menu;
 547 }
 548
 549 #undef ACT_ADD
 550
 551 /*****************************************************************************
 552  * Popup menus - Right Click menus                                           *
 553  *****************************************************************************/
 554 #define POPUP_BOILERPLATE \
 555     unsigned int i_last_separator = 0; \
 556     vector<int> objects; \
 557     vector<const char *> varnames; \
 558     input_thread_t *p_input = THEMIM->getInput();
 559
 560 #define CREATE_POPUP \
 561     Populate( p_intf, menu, varnames, objects ); \
 562     p_intf->p_sys->p_popup_menu = menu; \
 563     menu->popup( QCursor::pos() ); \
 564     p_intf->p_sys->p_popup_menu = NULL; \
 565     i_last_separator = 0;
 566
 567 void QVLCMenu::PopupMenuControlEntries( QMenu *menu,
 568                                         intf_thread_t *p_intf,
 569                                         input_thread_t *p_input )
 570 {
 571     if( p_input )
 572     {
 573         vlc_value_t val;
 574         var_Get( p_input, "state", &val );
 575         if( val.i_int == PLAYING_S )
 576             addMIMStaticEntry( p_intf, menu, qtr( "Pause" ), "",
 577                     ":/pixmaps/pause_16px.png", SLOT( togglePlayPause() ) );
 578         else
 579             addMIMStaticEntry( p_intf, menu, qtr( "Play" ), "",
 580                     ":/pixmaps/play_16px.png", SLOT( togglePlayPause() ) );
 581     }
 582     else if( THEPL->items.i_size )
 583         addMIMStaticEntry( p_intf, menu, qtr( "Play" ), "",
 584                 ":/pixmaps/play_16px.png", SLOT( togglePlayPause() ) );
 585
 586     addMIMStaticEntry( p_intf, menu, qtr( "Stop" ), "",
 587             ":/pixmaps/stop_16px.png", SLOT( stop() ) );
 588     addMIMStaticEntry( p_intf, menu, qtr( "Previous" ), "",
 589             ":/pixmaps/previous_16px.png", SLOT( prev() ) );
 590     addMIMStaticEntry( p_intf, menu, qtr( "Next" ), "",
 591             ":/pixmaps/next_16px.png", SLOT( next() ) );
 592     }
 593
 594 void QVLCMenu::PopupMenuStaticEntries( intf_thread_t *p_intf, QMenu *menu )
 595 {
 596     QMenu *toolsmenu = ToolsMenu( p_intf, menu, false, true );
 597     toolsmenu->setTitle( qtr( "Tools" ) );
 598     menu->addMenu( toolsmenu );
 599
 600     QMenu *openmenu = new QMenu( qtr( "Open" ), menu );
 601     openmenu->addAction( qtr( "Open &File..." ), THEDP,
 602                          SLOT( openFileDialog() ) );
 603     openmenu->addAction( qtr( "Open &Disc..." ), THEDP,
 604                          SLOT( openDiscDialog() ) );
 605     openmenu->addAction( qtr( "Open &Network..." ), THEDP,
 606                          SLOT( openNetDialog() ) );
 607     openmenu->addAction( qtr( "Open &Capture Device..." ), THEDP,
 608                          SLOT( openCaptureDialog() ) );
 609     menu->addMenu( openmenu );
 610
 611     menu->addSeparator();
 612     QMenu *helpmenu = HelpMenu( menu );
 613     helpmenu->setTitle( qtr( "Help" ) );
 614     menu->addMenu( helpmenu );
 615
 616     addDPStaticEntry( menu, qtr( "Quit" ), "", "", SLOT( quit() ) , "Ctrl+Q" );
 617 }
 618
 619 /* Video Tracks and Subtitles tracks */
 620 void QVLCMenu::VideoPopupMenu( intf_thread_t *p_intf )
 621 {
 622     POPUP_BOILERPLATE;
 623     if( p_input )
 624     {
 625         vlc_object_yield( p_input );
 626         vlc_object_t *p_vout = ( vlc_object_t * )vlc_object_find( p_input,
 627                 VLC_OBJECT_VOUT, FIND_CHILD );
 628         if( p_vout )
 629         {
 630             VideoAutoMenuBuilder( p_vout, p_input, objects, varnames );
 631             vlc_object_release( p_vout );
 632         }
 633         vlc_object_release( p_input );
 634     }
 635     QMenu *menu = new QMenu();
 636     CREATE_POPUP;
 637 }
 638
 639 /* Audio Tracks */
 640 void QVLCMenu::AudioPopupMenu( intf_thread_t *p_intf )
 641 {
 642     POPUP_BOILERPLATE;
 643     if( p_input )
 644     {
 645         vlc_object_yield( p_input );
 646         vlc_object_t *p_aout = ( vlc_object_t * )vlc_object_find( p_input,
 647                 VLC_OBJECT_AOUT, FIND_ANYWHERE );
 648         AudioAutoMenuBuilder( p_aout, p_input, objects, varnames );
 649         if( p_aout )
 650             vlc_object_release( p_aout );
 651         vlc_object_release( p_input );
 652     }
 653     QMenu *menu = new QMenu();
 654     CREATE_POPUP;
 655 }
 656
 657 /* Navigation stuff, and general menus ( open ) */
 658 void QVLCMenu::MiscPopupMenu( intf_thread_t *p_intf )
 659 {
 660     vlc_value_t val;
 661     POPUP_BOILERPLATE;
 662
 663     if( p_input )
 664     {
 665         vlc_object_yield( p_input );
 666         varnames.push_back( "audio-es" );
 667         InputAutoMenuBuilder( VLC_OBJECT( p_input ), objects, varnames );
 668         PUSH_SEPARATOR;
 669     }
 670
 671     QMenu *menu = new QMenu();
 672     Populate( p_intf, menu, varnames, objects );
 673
 674     menu->addSeparator();
 675     PopupMenuControlEntries( menu, p_intf, p_input );
 676
 677     menu->addSeparator();
 678     PopupMenuStaticEntries( p_intf, menu );
 679
 680     p_intf->p_sys->p_popup_menu = menu;
 681     menu->popup( QCursor::pos() );
 682     p_intf->p_sys->p_popup_menu = NULL;
 683 }
 684
 685 /* Main Menu that sticks everything together  */
 686 void QVLCMenu::PopupMenu( intf_thread_t *p_intf, bool show )
 687 {
 688     if( show )
 689     {
 690         // create a  popup if there is none
 691         if( ! p_intf->p_sys->p_popup_menu )
 692         {
 693             POPUP_BOILERPLATE;
 694             if( p_input )
 695             {
 696                 vlc_object_yield( p_input );
 697                 InputAutoMenuBuilder( VLC_OBJECT( p_input ), objects, varnames );
 698
 699                 /* Audio menu */
 700                 PUSH_SEPARATOR;
 701                 vlc_object_t *p_aout = ( vlc_object_t * )
 702                     vlc_object_find( p_input, VLC_OBJECT_AOUT, FIND_ANYWHERE );
 703                 AudioAutoMenuBuilder( p_aout, p_input, objects, varnames );
 704                 if( p_aout )
 705                     vlc_object_release( p_aout );
 706
 707                 /* Video menu */
 708                 PUSH_SEPARATOR;
 709                 vlc_object_t *p_vout = ( vlc_object_t * )
 710                     vlc_object_find( p_input, VLC_OBJECT_VOUT, FIND_CHILD );
 711                     VideoAutoMenuBuilder( p_vout, p_input, objects, varnames );
 712                 if( p_vout )
 713                     vlc_object_release( p_vout );
 714
 715                 vlc_object_release( p_input );
 716             }
 717
 718             QMenu *menu = new QMenu();
 719             Populate( p_intf, menu, varnames, objects );
 720             menu->addSeparator();
 721             PopupMenuControlEntries( menu, p_intf, p_input );
 722             menu->addSeparator();
 723             PopupMenuStaticEntries( p_intf, menu );
 724
 725             p_intf->p_sys->p_popup_menu = menu;
 726         }
 727         p_intf->p_sys->p_popup_menu->popup( QCursor::pos() );
 728     }
 729     else
 730     {
 731         // destroy popup if there is one
 732         delete p_intf->p_sys->p_popup_menu;
 733         p_intf->p_sys->p_popup_menu = NULL;
 734     }
 735 }
 736
 737 /************************************************************************
 738  * Systray Menu                                                         *
 739  ************************************************************************/
 740
 741 void QVLCMenu::updateSystrayMenu( MainInterface *mi,
 742                                   intf_thread_t *p_intf,
 743                                   bool b_force_visible )
 744 {
 745     POPUP_BOILERPLATE;
 746
 747     /* Get the systray menu and clean it */
 748     QMenu *sysMenu = mi->getSysTrayMenu();
 749     sysMenu->clear();
 750
 751     /* Hide / Show VLC and cone */
 752     if( mi->isVisible() || b_force_visible )
 753     {
 754         sysMenu->addAction( QIcon( ":/vlc16.png" ),
 755                 qtr( "Hide VLC media player in taskbar" ), mi,
 756                 SLOT( toggleUpdateSystrayMenu() ) );
 757     }
 758     else
 759     {
 760         sysMenu->addAction( QIcon( ":/vlc16.png" ),
 761                 qtr( "Show VLC media player" ), mi,
 762                 SLOT( toggleUpdateSystrayMenu() ) );
 763     }
 764
 765     sysMenu->addSeparator();
 766     PopupMenuControlEntries( sysMenu, p_intf, p_input );
 767
 768     sysMenu->addSeparator();
 769     addDPStaticEntry( sysMenu, qtr( "&Open Media" ), "",
 770             ":/pixmaps/file-wide_16px.png", SLOT( openFileDialog() ), "" );
 771     addDPStaticEntry( sysMenu, qtr( "&Quit" ) , "",
 772         ":/pixmaps/menus_quit_16px.png", SLOT( quit() ), "" );
 773
 774     /* Set the menu */
 775     mi->getSysTray()->setContextMenu( sysMenu );
 776 }
 777
 778 #undef PUSH_VAR
 779 #undef PUSH_SEPARATOR
 780
 781 /*************************************************************************
 782  * Builders for automenus
 783  *************************************************************************/
 784 QMenu * QVLCMenu::Populate( intf_thread_t *p_intf,
 785                             QMenu *current,
 786                             vector< const char *> & varnames,
 787                             vector<int> & objects,
 788                             bool append )
 789 {
 790     QMenu *menu = current;
 791     if( !menu )
 792         menu = new QMenu();
 793
 794     QAction *p_action;
 795     Q_FOREACH( p_action, menu->actions() )
 796     {
 797         p_action->setEnabled( false );
 798     }
 799
 800     currentGroup = NULL;
 801
 802     vlc_object_t *p_object;
 803     int i;
 804
 805     for( i = 0; i < ( int )objects.size() ; i++ )
 806     {
 807         if( !varnames[i] || !*varnames[i] )
 808         {
 809             menu->addSeparator();
 810             continue;
 811         }
 812
 813         if( objects[i] == 0 )
 814         {
 815             continue;
 816         }
 817         else
 818         {
 819             p_object = ( vlc_object_t * )vlc_object_get( objects[i] );
 820             if( !p_object )
 821             {
 822                 msg_Dbg( p_intf, "object %d not found !", objects[i] );
 823                 continue;
 824             }
 825         }
 826
 827         /* Ugly specific stuff */
 828         if( strstr( varnames[i], "intf-add" ) )
 829             UpdateItem( p_intf, menu, varnames[i], p_object, false );
 830         else
 831             UpdateItem( p_intf, menu, varnames[i], p_object, true );
 832         if( p_object )
 833             vlc_object_release( p_object );
 834     }
 835     return menu;
 836 }
 837
 838 /*****************************************************************************
 839  * Private methods.
 840  *****************************************************************************/
 841
 842 static bool IsMenuEmpty( const char *psz_var,
 843                          vlc_object_t *p_object,
 844                          bool b_root = true )
 845 {
 846     vlc_value_t val, val_list;
 847     int i_type, i_result, i;
 848
 849     /* Check the type of the object variable */
 850     i_type = var_Type( p_object, psz_var );
 851
 852     /* Check if we want to display the variable */
 853     if( !( i_type & VLC_VAR_HASCHOICE ) ) return false;
 854
 855     var_Change( p_object, psz_var, VLC_VAR_CHOICESCOUNT, &val, NULL );
 856     if( val.i_int == 0 ) return true;
 857
 858     if( ( i_type & VLC_VAR_TYPE ) != VLC_VAR_VARIABLE )
 859     {
 860         if( val.i_int == 1 && b_root ) return true;
 861         else return false;
 862     }
 863
 864     /* Check children variables in case of VLC_VAR_VARIABLE */
 865     if( var_Change( p_object, psz_var, VLC_VAR_GETLIST, &val_list, NULL ) < 0 )
 866     {
 867         return true;
 868     }
 869
 870     for( i = 0, i_result = true; i < val_list.p_list->i_count; i++ )
 871     {
 872         if( !IsMenuEmpty( val_list.p_list->p_values[i].psz_string,
 873                     p_object, false ) )
 874         {
 875             i_result = false;
 876             break;
 877         }
 878     }
 879
 880     /* clean up everything */
 881     var_Change( p_object, psz_var, VLC_VAR_FREELIST, &val_list, NULL );
 882
 883     return i_result;
 884 }
 885
 886 #define TEXT_OR_VAR qfu ( text.psz_string ? text.psz_string : psz_var )
 887
 888 void QVLCMenu::UpdateItem( intf_thread_t *p_intf, QMenu *menu,
 889         const char *psz_var, vlc_object_t *p_object, bool b_submenu )
 890 {
 891     vlc_value_t val, text;
 892     int i_type;
 893
 894     if( !p_object )
 895     {
 896         /* Nothing to do */
 897         return;
 898     }
 899
 900     if( !strcmp( psz_var, "spu-es" ) )
 901     {
 902         /* TODO: add a static entry "Load File..." */
 903         return;
 904     }
 905
 906     /* Check the type of the object variable */
 907     if( !strcmp( psz_var, "audio-es" )
 908      || !strcmp( psz_var, "video-es" ) )
 909         i_type = VLC_VAR_INTEGER | VLC_VAR_HASCHOICE;
 910     else
 911         i_type = var_Type( p_object, psz_var );
 912
 913     switch( i_type & VLC_VAR_TYPE )
 914     {
 915         case VLC_VAR_VOID:
 916         case VLC_VAR_BOOL:
 917         case VLC_VAR_VARIABLE:
 918         case VLC_VAR_STRING:
 919         case VLC_VAR_INTEGER:
 920         case VLC_VAR_FLOAT:
 921             break;
 922         default:
 923             /* Variable doesn't exist or isn't handled */
 924             return;
 925     }
 926
 927     /* Make sure we want to display the variable */
 928     if( IsMenuEmpty( psz_var, p_object ) )  return;
 929
 930     /* Get the descriptive name of the variable */
 931     int i_ret = var_Change( p_object, psz_var, VLC_VAR_GETTEXT, &text, NULL );
 932     if( i_ret != VLC_SUCCESS )
 933     {
 934         text.psz_string = NULL;
 935     }
 936
 937     QAction *action = FindActionWithVar( menu, psz_var );
 938     if( !action )
 939     {
 940         action = new QAction( TEXT_OR_VAR, menu );
 941         menu->addAction( action );
 942     }
 943
 944     if( i_type & VLC_VAR_HASCHOICE )
 945     {
 946         /* Append choices menu */
 947         if( b_submenu )
 948         {
 949             QMenu *submenu;
 950             action->setEnabled( true );
 951             submenu = action->menu();
 952             if( !submenu )
 953             {
 954                 submenu = new QMenu( menu );
 955                 action->setMenu( submenu );
 956             }
 957             submenu->setEnabled( true );
 958
 959             if( CreateChoicesMenu( submenu, psz_var, p_object, true ) == 0 )
 960                 menu->addMenu( submenu );
 961         }
 962         else
 963             CreateChoicesMenu( menu, psz_var, p_object, true );
 964         FREENULL( text.psz_string );
 965         return;
 966     }
 967
 968     switch( i_type & VLC_VAR_TYPE )
 969     {
 970         case VLC_VAR_VOID:
 971             var_Get( p_object, psz_var, &val );
 972             CreateAndConnect( menu, psz_var, TEXT_OR_VAR, "", ITEM_NORMAL,
 973                     p_object->i_object_id, val, i_type );
 974             break;
 975
 976         case VLC_VAR_BOOL:
 977             var_Get( p_object, psz_var, &val );
 978             val.b_bool = !val.b_bool;
 979             CreateAndConnect( menu, psz_var, TEXT_OR_VAR, "", ITEM_CHECK,
 980                     p_object->i_object_id, val, i_type, !val.b_bool );
 981             break;
 982     }
 983     FREENULL( text.psz_string );
 984 }
 985
 986
 987 int QVLCMenu::CreateChoicesMenu( QMenu *submenu, const char *psz_var,
 988         vlc_object_t *p_object, bool b_root )
 989 {
 990     vlc_value_t val, val_list, text_list;
 991     int i_type, i;
 992
 993     /* Check the type of the object variable */
 994     i_type = var_Type( p_object, psz_var );
 995
 996     /* Make sure we want to display the variable */
 997     if( IsMenuEmpty( psz_var, p_object, b_root ) ) return VLC_EGENERIC;
 998
 999     switch( i_type & VLC_VAR_TYPE )
1000     {
1001         case VLC_VAR_VOID:
1002         case VLC_VAR_BOOL:
1003         case VLC_VAR_VARIABLE:
1004         case VLC_VAR_STRING:
1005         case VLC_VAR_INTEGER:
1006         case VLC_VAR_FLOAT:
1007             break;
1008         default:
1009             /* Variable doesn't exist or isn't handled */
1010             return VLC_EGENERIC;
1011     }
1012
1013     if( var_Change( p_object, psz_var, VLC_VAR_GETLIST,
1014                 &val_list, &text_list ) < 0 )
1015     {
1016         return VLC_EGENERIC;
1017     }
1018
1019 #define NORMAL_OR_RADIO i_type & VLC_VAR_ISCOMMAND ? ITEM_NORMAL: ITEM_RADIO
1020 #define NOTCOMMAND !( i_type & VLC_VAR_ISCOMMAND )
1021 #define CURVAL val_list.p_list->p_values[i]
1022 #define CURTEXT text_list.p_list->p_values[i].psz_string
1023
1024     for( i = 0; i < val_list.p_list->i_count; i++ )
1025     {
1026         vlc_value_t another_val;
1027         QString menutext;
1028         QMenu *subsubmenu = new QMenu( submenu );
1029
1030         switch( i_type & VLC_VAR_TYPE )
1031         {
1032             case VLC_VAR_VARIABLE:
1033                 CreateChoicesMenu( subsubmenu, CURVAL.psz_string, p_object, false );
1034                 subsubmenu->setTitle( qfu( CURTEXT ? CURTEXT :CURVAL.psz_string ) );
1035                 submenu->addMenu( subsubmenu );
1036                 break;
1037
1038             case VLC_VAR_STRING:
1039                 var_Get( p_object, psz_var, &val );
1040                 another_val.psz_string = strdup( CURVAL.psz_string );
1041                 menutext = qfu( CURTEXT ? CURTEXT : another_val.psz_string );
1042                 CreateAndConnect( submenu, psz_var, menutext, "", NORMAL_OR_RADIO,
1043                         p_object->i_object_id, another_val, i_type,
1044                         NOTCOMMAND && val.psz_string &&
1045                         !strcmp( val.psz_string, CURVAL.psz_string ) );
1046
1047                 free( val.psz_string );
1048                 break;
1049
1050             case VLC_VAR_INTEGER:
1051                 var_Get( p_object, psz_var, &val );
1052                 if( CURTEXT ) menutext = qfu( CURTEXT );
1053                 else menutext.sprintf( "%d", CURVAL.i_int );
1054                 CreateAndConnect( submenu, psz_var, menutext, "", NORMAL_OR_RADIO,
1055                         p_object->i_object_id, CURVAL, i_type,
1056                         NOTCOMMAND && CURVAL.i_int == val.i_int );
1057                 break;
1058
1059             case VLC_VAR_FLOAT:
1060                 var_Get( p_object, psz_var, &val );
1061                 if( CURTEXT ) menutext = qfu( CURTEXT );
1062                 else menutext.sprintf( "%.2f", CURVAL.f_float );
1063                 CreateAndConnect( submenu, psz_var, menutext, "", NORMAL_OR_RADIO,
1064                         p_object->i_object_id, CURVAL, i_type,
1065                         NOTCOMMAND && CURVAL.f_float == val.f_float );
1066                 break;
1067
1068             default:
1069                 break;
1070         }
1071     }
1072     currentGroup = NULL;
1073
1074     /* clean up everything */
1075     var_Change( p_object, psz_var, VLC_VAR_FREELIST, &val_list, &text_list );
1076
1077 #undef NORMAL_OR_RADIO
1078 #undef NOTCOMMAND
1079 #undef CURVAL
1080 #undef CURTEXT
1081     return VLC_SUCCESS;
1082 }
1083
1084 void QVLCMenu::CreateAndConnect( QMenu *menu, const char *psz_var,
1085         QString text, QString help,
1086         int i_item_type, int i_object_id,
1087         vlc_value_t val, int i_val_type,
1088         bool checked )
1089 {
1090     QAction *action = FindActionWithVar( menu, psz_var );
1091     if( !action )
1092     {
1093         /* This is a value */
1094         action = FindActionWithText( menu, text );
1095         if( !action )
1096         {
1097             action = new QAction( text, menu );
1098             menu->addAction( action );
1099         }
1100     }
1101
1102     action->setText( text );
1103     action->setToolTip( help );
1104
1105     action->setEnabled( i_object_id != 0 );
1106
1107     if( i_item_type == ITEM_CHECK )
1108     {
1109         action->setCheckable( true );
1110     }
1111     else if( i_item_type == ITEM_RADIO )
1112     {
1113         action->setCheckable( true );
1114         if( !currentGroup )
1115             currentGroup = new QActionGroup( menu );
1116         currentGroup->addAction( action );
1117     }
1118
1119     action->setChecked( checked );
1120
1121     MenuItemData *itemData = new MenuItemData( i_object_id, i_val_type,
1122             val, psz_var );
1123     CONNECT( action, triggered(), THEDP->menusMapper, map() );
1124     THEDP->menusMapper->setMapping( action, itemData );
1125     menu->addAction( action );
1126 }
1127
1128 void QVLCMenu::DoAction( intf_thread_t *p_intf, QObject *data )
1129 {
1130     MenuItemData *itemData = qobject_cast<MenuItemData *>( data );
1131     vlc_object_t *p_object = ( vlc_object_t * )vlc_object_get( itemData->i_object_id );
1132     if( p_object == NULL ) return;
1133
1134     var_Set( p_object, itemData->psz_var, itemData->val );
1135     vlc_object_release( p_object );
1136 }
1137