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         MenuFunc *f = new MenuFunc( intfmenu, 4 );
 315         CONNECT( intfmenu, aboutToShow(), THEDP->menusUpdateMapper, map() );
 316         THEDP->menusUpdateMapper->setMapping( intfmenu, f );
 317         menu->addMenu( intfmenu );
 318         menu->addSeparator();
 319     }
 320     if( mi )
 321     {
 322         /* Minimal View */
 323         QAction *action=menu->addAction( qtr( "Minimal View..." ), mi,
 324                 SLOT( toggleMinimalView() ), qtr( "Ctrl+H" ) );
 325         action->setCheckable( true );
 326         if( mi->getControlsVisibilityStatus() & CONTROLS_VISIBLE )
 327             action->setChecked( true );
 328
 329         /* FullScreen View */
 330         action = menu->addAction( qtr( "Toggle Fullscreen Interface" ), mi,
 331                 SLOT( toggleFullScreen() ), qtr( "F11" ) );
 332
 333         /* Advanced Controls */
 334         action = menu->addAction( qtr( "Advanced controls" ), mi,
 335                 SLOT( toggleAdvanced() ) );
 336         action->setCheckable( true );
 337         if( mi->getControlsVisibilityStatus() & CONTROLS_ADVANCED )
 338             action->setChecked( true );
 339 #if 0 /* For Visualisations. Not yet working */
 340         adv = menu->addAction( qtr( "Visualizations selector" ),
 341                 mi, SLOT( visual() ) );
 342         adv->setCheckable( true );
 343         if( visual_selector_enabled ) adv->setChecked( true );
 344 #endif
 345     }
 346
 347     menu->addSeparator();
 348
 349     addDPStaticEntry( menu, qtr( I_MENU_MSG ), "",
 350         ":/pixmaps/menus_messages_16px.png", SLOT( messagesDialog() ),
 351         "Ctrl+M" );
 352     addDPStaticEntry( menu, qtr( I_MENU_INFO ) , "", "",
 353         SLOT( mediaInfoDialog() ), "Ctrl+I" );
 354     addDPStaticEntry( menu, qtr( I_MENU_CODECINFO ) , "",
 355         ":/pixmaps/menus_info_16px.png", SLOT( mediaCodecDialog() ), "Ctrl+J" );
 356     addDPStaticEntry( menu, qtr( I_MENU_BOOKMARK ), "","",
 357                       SLOT( bookmarksDialog() ), "Ctrl+B" );
 358 #ifdef ENABLE_VLM
 359     addDPStaticEntry( menu, qtr( I_MENU_VLM ), "", "", SLOT( vlmDialog() ),
 360         "Ctrl+W" );
 361 #endif
 362
 363     menu->addSeparator();
 364     addDPStaticEntry( menu, qtr( "Preferences..." ), "",
 365         ":/pixmaps/menus_preferences_16px.png", SLOT( prefsDialog() ), "Ctrl+P" );
 366     return menu;
 367 }
 368
 369 /**
 370  * Interface Sub-Menu, to list extras interface and skins
 371  **/
 372 QMenu *QVLCMenu::InterfacesMenu( intf_thread_t *p_intf, QMenu *current )
 373 {
 374     vector<int> objects;
 375     vector<const char *> varnames;
 376     /** \todo add "switch to XXX" */
 377     varnames.push_back( "intf-add" );
 378     objects.push_back( p_intf->i_object_id );
 379
 380     QMenu *submenu = new QMenu( current );
 381     QMenu *menu = Populate( p_intf, submenu, varnames, objects );
 382
 383     return menu;
 384 }
 385
 386 /**
 387  * Main Audio Menu
 388  */
 389 QMenu *QVLCMenu::AudioMenu( intf_thread_t *p_intf, QMenu * current )
 390 {
 391     vector<int> objects;
 392     vector<const char *> varnames;
 393     vlc_object_t *p_object;
 394     input_thread_t *p_input;
 395
 396     if( !current )
 397         current = new QMenu();
 398
 399     if( current->isEmpty() )
 400     {
 401         ACT_ADD( current, "audio-es", qtr( "Audio &Track" ) );
 402         ACT_ADD( current, "audio-device", qtr( "Audio &Device" ) );
 403         ACT_ADD( current, "audio-channels", qtr( "Audio &Channels" ) );
 404         ACT_ADD( current, "visual", qtr( "&Visualizations" ) );
 405         ACT_ADD( current, "equalizer", qtr( "&Equalizer" ) );
 406     }
 407
 408     p_input = THEMIM->getInput();
 409     if( p_input )
 410         vlc_object_yield( p_input );
 411     p_object = ( vlc_object_t * ) vlc_object_find( p_intf,
 412                                                    VLC_OBJECT_AOUT,
 413                                                    FIND_ANYWHERE );
 414
 415     AudioAutoMenuBuilder( p_object, p_input, objects, varnames );
 416
 417     if( p_object )
 418         vlc_object_release( p_object );
 419     if( p_input )
 420         vlc_object_release( p_input );
 421
 422     return Populate( p_intf, current, varnames, objects );
 423 }
 424
 425 /**
 426  * Main Video Menu
 427  * Subtitles are part of Video.
 428  **/
 429 QMenu *QVLCMenu::VideoMenu( intf_thread_t *p_intf, QMenu *current )
 430 {
 431     vlc_object_t *p_object;
 432     input_thread_t *p_input;
 433     vector<int> objects;
 434     vector<const char *> varnames;
 435
 436     if( !current )
 437         current = new QMenu();
 438
 439     if( current->isEmpty() )
 440     {
 441         ACT_ADD( current, "video-es", qtr( "Video &Track" ) );
 442         ACT_ADD( current, "fullscreen", qtr( "&Fullscreen" ) );
 443         ACT_ADD( current, "zoom", qtr( "&Zoom" ) );
 444         ACT_ADD( current, "deinterlace", qtr( "&Deinterlace" ) );
 445         ACT_ADD( current, "aspect-ratio", qtr( "&Aspect Ratio" ) );
 446         ACT_ADD( current, "crop", qtr( "&Crop" ) );
 447         ACT_ADD( current, "video-on-top", qtr( "Always &On Top" ) );
 448         ACT_ADD( current, "directx-wallpaper", qtr( "&DirectX Wallpaper" ) ); /* FIXME */
 449         ACT_ADD( current, "video-snapshot", qtr( "&Snapshot" ) );
 450         ACT_ADD( current, "ffmpeg-pp-q", qtr( "D&ecoder" ) ); /* FIXME */
 451     }
 452
 453     p_input = THEMIM->getInput();
 454     if( p_input )
 455         vlc_object_yield( p_input );
 456     p_object = ( vlc_object_t * )vlc_object_find( p_intf, VLC_OBJECT_VOUT,
 457             FIND_ANYWHERE );
 458
 459     VideoAutoMenuBuilder( p_object, p_input, objects, varnames );
 460
 461     if( p_object )
 462         vlc_object_release( p_object );
 463     if( p_input )
 464         vlc_object_release( p_input );
 465
 466     return Populate( p_intf, current, varnames, objects );
 467 }
 468
 469 /**
 470  * Navigation Menu
 471  * For DVD, MP4, MOV and other chapter based format
 472  **/
 473 QMenu *QVLCMenu::NavigMenu( intf_thread_t *p_intf, QMenu *menu )
 474 {
 475     vlc_object_t *p_object;
 476     vector<int> objects;
 477     vector<const char *> varnames;
 478
 479     p_object = ( vlc_object_t * )vlc_object_find( p_intf, VLC_OBJECT_INPUT,
 480             FIND_ANYWHERE );
 481     InputAutoMenuBuilder(  p_object, objects, varnames );
 482     PUSH_VAR( "prev-title" );
 483     PUSH_VAR( "next-title" );
 484     PUSH_VAR( "prev-chapter" );
 485     PUSH_VAR( "next-chapter" );
 486     if( p_object )
 487         vlc_object_release( p_object );
 488     QMenu *navMenu = new QMenu( menu );
 489     addDPStaticEntry( navMenu, qtr( I_MENU_GOTOTIME ), "","",
 490         SLOT( gotoTimeDialog() ), "Ctrl+T" );
 491     navMenu->addSeparator();
 492     return Populate( p_intf, navMenu, varnames, objects, true );
 493 }
 494
 495 /**
 496  * Service Discovery SubMenu
 497  **/
 498 QMenu *QVLCMenu::SDMenu( intf_thread_t *p_intf )
 499 {
 500     QMenu *menu = new QMenu();
 501     menu->setTitle( qtr( I_PL_SD ) );
 502     char **ppsz_longnames;
 503     char **ppsz_names = services_discovery_GetServicesNames( p_intf,
 504                                                              &ppsz_longnames );
 505     if( !ppsz_names )
 506         return menu;
 507
 508     char **ppsz_name = ppsz_names, **ppsz_longname = ppsz_longnames;
 509     for( ; *ppsz_name; ppsz_name++, ppsz_longname++ )
 510     {
 511         QAction *a = new QAction( qfu( *ppsz_longname ), menu );
 512         a->setCheckable( true );
 513         if( playlist_IsServicesDiscoveryLoaded( THEPL, *ppsz_name ) )
 514             a->setChecked( true );
 515         CONNECT( a , triggered(), THEDP->SDMapper, map() );
 516         THEDP->SDMapper->setMapping( a, QString( *ppsz_name ) );
 517         menu->addAction( a );
 518
 519         if( !strcmp( *ppsz_name, "podcast" ) )
 520         {
 521             QAction *b = new QAction( qfu( "Configure podcasts..." ), menu );
 522             //b->setEnabled( a->isChecked() );
 523             menu->addAction( b );
 524             CONNECT( b, triggered(), THEDP, podcastConfigureDialog() );
 525         }
 526         free( *ppsz_name );
 527         free( *ppsz_longname );
 528     }
 529     free( ppsz_names );
 530     free( ppsz_longnames );
 531     return menu;
 532 }
 533 /**
 534  * Help/About Menu
 535 **/
 536 QMenu *QVLCMenu::HelpMenu( QMenu *current )
 537 {
 538     QMenu *menu = new QMenu( current );
 539     addDPStaticEntry( menu, qtr( "Help..." ) , "",
 540         ":/pixmaps/menus_help_16px.png", SLOT( helpDialog() ), "F1" );
 541 #ifdef UPDATE_CHECK
 542     addDPStaticEntry( menu, qtr( "Check for updates..." ) , "", "", SLOT( updateDialog() ), "");
 543 #endif
 544     menu->addSeparator();
 545     addDPStaticEntry( menu, qtr( I_MENU_ABOUT ), "", "", SLOT( aboutDialog() ),
 546         "Ctrl+F1" );
 547     return menu;
 548 }
 549
 550 #undef ACT_ADD
 551
 552 /*****************************************************************************
 553  * Popup menus - Right Click menus                                           *
 554  *****************************************************************************/
 555 #define POPUP_BOILERPLATE \
 556     unsigned int i_last_separator = 0; \
 557     vector<int> objects; \
 558     vector<const char *> varnames; \
 559     input_thread_t *p_input = THEMIM->getInput();
 560
 561 #define CREATE_POPUP \
 562     Populate( p_intf, menu, varnames, objects ); \
 563     p_intf->p_sys->p_popup_menu = menu; \
 564     menu->popup( QCursor::pos() ); \
 565     p_intf->p_sys->p_popup_menu = NULL; \
 566     i_last_separator = 0;
 567
 568 void QVLCMenu::PopupMenuControlEntries( QMenu *menu,
 569                                         intf_thread_t *p_intf,
 570                                         input_thread_t *p_input )
 571 {
 572     if( p_input )
 573     {
 574         vlc_value_t val;
 575         var_Get( p_input, "state", &val );
 576         if( val.i_int == PLAYING_S )
 577             addMIMStaticEntry( p_intf, menu, qtr( "Pause" ), "",
 578                     ":/pixmaps/pause_16px.png", SLOT( togglePlayPause() ) );
 579         else
 580             addMIMStaticEntry( p_intf, menu, qtr( "Play" ), "",
 581                     ":/pixmaps/play_16px.png", SLOT( togglePlayPause() ) );
 582     }
 583     else if( THEPL->items.i_size )
 584         addMIMStaticEntry( p_intf, menu, qtr( "Play" ), "",
 585                 ":/pixmaps/play_16px.png", SLOT( togglePlayPause() ) );
 586
 587     addMIMStaticEntry( p_intf, menu, qtr( "Stop" ), "",
 588             ":/pixmaps/stop_16px.png", SLOT( stop() ) );
 589     addMIMStaticEntry( p_intf, menu, qtr( "Previous" ), "",
 590             ":/pixmaps/previous_16px.png", SLOT( prev() ) );
 591     addMIMStaticEntry( p_intf, menu, qtr( "Next" ), "",
 592             ":/pixmaps/next_16px.png", SLOT( next() ) );
 593     }
 594
 595 void QVLCMenu::PopupMenuStaticEntries( intf_thread_t *p_intf, QMenu *menu )
 596 {
 597     QMenu *toolsmenu = ToolsMenu( p_intf, menu, false, true );
 598     toolsmenu->setTitle( qtr( "Tools" ) );
 599     menu->addMenu( toolsmenu );
 600
 601     QMenu *openmenu = new QMenu( qtr( "Open" ), menu );
 602     openmenu->addAction( qtr( "Open &File..." ), THEDP,
 603                          SLOT( openFileDialog() ) );
 604     openmenu->addAction( qtr( "Open &Disc..." ), THEDP,
 605                          SLOT( openDiscDialog() ) );
 606     openmenu->addAction( qtr( "Open &Network..." ), THEDP,
 607                          SLOT( openNetDialog() ) );
 608     openmenu->addAction( qtr( "Open &Capture Device..." ), THEDP,
 609                          SLOT( openCaptureDialog() ) );
 610     menu->addMenu( openmenu );
 611
 612     menu->addSeparator();
 613     QMenu *helpmenu = HelpMenu( menu );
 614     helpmenu->setTitle( qtr( "Help" ) );
 615     menu->addMenu( helpmenu );
 616
 617     addDPStaticEntry( menu, qtr( "Quit" ), "", "", SLOT( quit() ) , "Ctrl+Q" );
 618 }
 619
 620 /* Video Tracks and Subtitles tracks */
 621 void QVLCMenu::VideoPopupMenu( intf_thread_t *p_intf )
 622 {
 623     POPUP_BOILERPLATE;
 624     if( p_input )
 625     {
 626         vlc_object_yield( p_input );
 627         vlc_object_t *p_vout = ( vlc_object_t * )vlc_object_find( p_input,
 628                 VLC_OBJECT_VOUT, FIND_CHILD );
 629         if( p_vout )
 630         {
 631             VideoAutoMenuBuilder( p_vout, p_input, objects, varnames );
 632             vlc_object_release( p_vout );
 633         }
 634         vlc_object_release( p_input );
 635     }
 636     QMenu *menu = new QMenu();
 637     CREATE_POPUP;
 638 }
 639
 640 /* Audio Tracks */
 641 void QVLCMenu::AudioPopupMenu( intf_thread_t *p_intf )
 642 {
 643     POPUP_BOILERPLATE;
 644     if( p_input )
 645     {
 646         vlc_object_yield( p_input );
 647         vlc_object_t *p_aout = ( vlc_object_t * )vlc_object_find( p_input,
 648                 VLC_OBJECT_AOUT, FIND_ANYWHERE );
 649         AudioAutoMenuBuilder( p_aout, p_input, objects, varnames );
 650         if( p_aout )
 651             vlc_object_release( p_aout );
 652         vlc_object_release( p_input );
 653     }
 654     QMenu *menu = new QMenu();
 655     CREATE_POPUP;
 656 }
 657
 658 /* Navigation stuff, and general menus ( open ) */
 659 void QVLCMenu::MiscPopupMenu( intf_thread_t *p_intf )
 660 {
 661     vlc_value_t val;
 662     POPUP_BOILERPLATE;
 663
 664     if( p_input )
 665     {
 666         vlc_object_yield( p_input );
 667         varnames.push_back( "audio-es" );
 668         InputAutoMenuBuilder( VLC_OBJECT( p_input ), objects, varnames );
 669         PUSH_SEPARATOR;
 670     }
 671
 672     QMenu *menu = new QMenu();
 673     Populate( p_intf, menu, varnames, objects );
 674
 675     menu->addSeparator();
 676     PopupMenuControlEntries( menu, p_intf, p_input );
 677
 678     menu->addSeparator();
 679     PopupMenuStaticEntries( p_intf, menu );
 680
 681     p_intf->p_sys->p_popup_menu = menu;
 682     menu->popup( QCursor::pos() );
 683     p_intf->p_sys->p_popup_menu = NULL;
 684 }
 685
 686 /* Main Menu that sticks everything together  */
 687 void QVLCMenu::PopupMenu( intf_thread_t *p_intf, bool show )
 688 {
 689     if( show )
 690     {
 691         // create a  popup if there is none
 692         if( ! p_intf->p_sys->p_popup_menu )
 693         {
 694             POPUP_BOILERPLATE;
 695             if( p_input )
 696             {
 697                 vlc_object_yield( p_input );
 698                 InputAutoMenuBuilder( VLC_OBJECT( p_input ), objects, varnames );
 699
 700                 /* Audio menu */
 701                 PUSH_SEPARATOR;
 702                 vlc_object_t *p_aout = ( vlc_object_t * )
 703                     vlc_object_find( p_input, VLC_OBJECT_AOUT, FIND_ANYWHERE );
 704                 AudioAutoMenuBuilder( p_aout, p_input, objects, varnames );
 705                 if( p_aout )
 706                     vlc_object_release( p_aout );
 707
 708                 /* Video menu */
 709                 PUSH_SEPARATOR;
 710                 vlc_object_t *p_vout = ( vlc_object_t * )
 711                     vlc_object_find( p_input, VLC_OBJECT_VOUT, FIND_CHILD );
 712                     VideoAutoMenuBuilder( p_vout, p_input, objects, varnames );
 713                 if( p_vout )
 714                     vlc_object_release( p_vout );
 715
 716                 vlc_object_release( p_input );
 717             }
 718
 719             QMenu *menu = new QMenu();
 720             Populate( p_intf, menu, varnames, objects );
 721             menu->addSeparator();
 722             PopupMenuControlEntries( menu, p_intf, p_input );
 723             menu->addSeparator();
 724             PopupMenuStaticEntries( p_intf, menu );
 725
 726             p_intf->p_sys->p_popup_menu = menu;
 727         }
 728         p_intf->p_sys->p_popup_menu->popup( QCursor::pos() );
 729     }
 730     else
 731     {
 732         // destroy popup if there is one
 733         delete p_intf->p_sys->p_popup_menu;
 734         p_intf->p_sys->p_popup_menu = NULL;
 735     }
 736 }
 737
 738 /************************************************************************
 739  * Systray Menu                                                         *
 740  ************************************************************************/
 741
 742 void QVLCMenu::updateSystrayMenu( MainInterface *mi,
 743                                   intf_thread_t *p_intf,
 744                                   bool b_force_visible )
 745 {
 746     POPUP_BOILERPLATE;
 747
 748     /* Get the systray menu and clean it */
 749     QMenu *sysMenu = mi->getSysTrayMenu();
 750     sysMenu->clear();
 751
 752     /* Hide / Show VLC and cone */
 753     if( mi->isVisible() || b_force_visible )
 754     {
 755         sysMenu->addAction( QIcon( ":/vlc16.png" ),
 756                 qtr( "Hide VLC media player in taskbar" ), mi,
 757                 SLOT( toggleUpdateSystrayMenu() ) );
 758     }
 759     else
 760     {
 761         sysMenu->addAction( QIcon( ":/vlc16.png" ),
 762                 qtr( "Show VLC media player" ), mi,
 763                 SLOT( toggleUpdateSystrayMenu() ) );
 764     }
 765
 766     sysMenu->addSeparator();
 767     PopupMenuControlEntries( sysMenu, p_intf, p_input );
 768
 769     sysMenu->addSeparator();
 770     addDPStaticEntry( sysMenu, qtr( "&Open Media" ), "",
 771             ":/pixmaps/file-wide_16px.png", SLOT( openFileDialog() ), "" );
 772     addDPStaticEntry( sysMenu, qtr( "&Quit" ) , "",
 773         ":/pixmaps/menus_quit_16px.png", SLOT( quit() ), "" );
 774
 775     /* Set the menu */
 776     mi->getSysTray()->setContextMenu( sysMenu );
 777 }
 778
 779 #undef PUSH_VAR
 780 #undef PUSH_SEPARATOR
 781
 782 /*************************************************************************
 783  * Builders for automenus
 784  *************************************************************************/
 785 QMenu * QVLCMenu::Populate( intf_thread_t *p_intf,
 786                             QMenu *current,
 787                             vector< const char *> & varnames,
 788                             vector<int> & objects,
 789                             bool append )
 790 {
 791     QMenu *menu = current;
 792     if( !menu )
 793         menu = new QMenu();
 794
 795     QAction *p_action;
 796     Q_FOREACH( p_action, menu->actions() )
 797     {
 798         p_action->setEnabled( false );
 799     }
 800
 801     currentGroup = NULL;
 802
 803     vlc_object_t *p_object;
 804     int i;
 805
 806     for( i = 0; i < ( int )objects.size() ; i++ )
 807     {
 808         if( !varnames[i] || !*varnames[i] )
 809         {
 810             menu->addSeparator();
 811             continue;
 812         }
 813
 814         if( objects[i] == 0 )
 815         {
 816             continue;
 817         }
 818         else
 819         {
 820             p_object = ( vlc_object_t * )vlc_object_get( objects[i] );
 821             if( !p_object )
 822             {
 823                 msg_Dbg( p_intf, "object %d not found !", objects[i] );
 824                 continue;
 825             }
 826         }
 827
 828         /* Ugly specific stuff */
 829         if( strstr( varnames[i], "intf-add" ) )
 830             UpdateItem( p_intf, menu, varnames[i], p_object, false );
 831         else
 832             UpdateItem( p_intf, menu, varnames[i], p_object, true );
 833         if( p_object )
 834             vlc_object_release( p_object );
 835     }
 836     return menu;
 837 }
 838
 839 /*****************************************************************************
 840  * Private methods.
 841  *****************************************************************************/
 842
 843 static bool IsMenuEmpty( const char *psz_var,
 844                          vlc_object_t *p_object,
 845                          bool b_root = true )
 846 {
 847     vlc_value_t val, val_list;
 848     int i_type, i_result, i;
 849
 850     /* Check the type of the object variable */
 851     i_type = var_Type( p_object, psz_var );
 852
 853     /* Check if we want to display the variable */
 854     if( !( i_type & VLC_VAR_HASCHOICE ) ) return false;
 855
 856     var_Change( p_object, psz_var, VLC_VAR_CHOICESCOUNT, &val, NULL );
 857     if( val.i_int == 0 ) return true;
 858
 859     if( ( i_type & VLC_VAR_TYPE ) != VLC_VAR_VARIABLE )
 860     {
 861         if( val.i_int == 1 && b_root ) return true;
 862         else return false;
 863     }
 864
 865     /* Check children variables in case of VLC_VAR_VARIABLE */
 866     if( var_Change( p_object, psz_var, VLC_VAR_GETLIST, &val_list, NULL ) < 0 )
 867     {
 868         return true;
 869     }
 870
 871     for( i = 0, i_result = true; i < val_list.p_list->i_count; i++ )
 872     {
 873         if( !IsMenuEmpty( val_list.p_list->p_values[i].psz_string,
 874                     p_object, false ) )
 875         {
 876             i_result = false;
 877             break;
 878         }
 879     }
 880
 881     /* clean up everything */
 882     var_Change( p_object, psz_var, VLC_VAR_FREELIST, &val_list, NULL );
 883
 884     return i_result;
 885 }
 886
 887 #define TEXT_OR_VAR qfu ( text.psz_string ? text.psz_string : psz_var )
 888
 889 void QVLCMenu::UpdateItem( intf_thread_t *p_intf, QMenu *menu,
 890         const char *psz_var, vlc_object_t *p_object, bool b_submenu )
 891 {
 892     vlc_value_t val, text;
 893     int i_type;
 894
 895     if( !p_object )
 896     {
 897         /* Nothing to do */
 898         return;
 899     }
 900
 901     if( !strcmp( psz_var, "spu-es" ) )
 902     {
 903         /* TODO: add a static entry "Load File..." */
 904         return;
 905     }
 906
 907     /* Check the type of the object variable */
 908     if( !strcmp( psz_var, "audio-es" )
 909      || !strcmp( psz_var, "video-es" ) )
 910         i_type = VLC_VAR_INTEGER | VLC_VAR_HASCHOICE;
 911     else
 912         i_type = var_Type( p_object, psz_var );
 913
 914     switch( i_type & VLC_VAR_TYPE )
 915     {
 916         case VLC_VAR_VOID:
 917         case VLC_VAR_BOOL:
 918         case VLC_VAR_VARIABLE:
 919         case VLC_VAR_STRING:
 920         case VLC_VAR_INTEGER:
 921         case VLC_VAR_FLOAT:
 922             break;
 923         default:
 924             /* Variable doesn't exist or isn't handled */
 925             return;
 926     }
 927
 928     /* Make sure we want to display the variable */
 929     if( IsMenuEmpty( psz_var, p_object ) )  return;
 930
 931     /* Get the descriptive name of the variable */
 932     int i_ret = var_Change( p_object, psz_var, VLC_VAR_GETTEXT, &text, NULL );
 933     if( i_ret != VLC_SUCCESS )
 934     {
 935         text.psz_string = NULL;
 936     }
 937
 938     QAction *action = FindActionWithVar( menu, psz_var );
 939     if( !action )
 940     {
 941         action = new QAction( TEXT_OR_VAR, menu );
 942         menu->addAction( action );
 943     }
 944
 945     if( i_type & VLC_VAR_HASCHOICE )
 946     {
 947         /* Append choices menu */
 948         if( b_submenu )
 949         {
 950             QMenu *submenu;
 951             action->setEnabled( true );
 952             submenu = action->menu();
 953             if( !submenu )
 954             {
 955                 submenu = new QMenu( menu );
 956                 action->setMenu( submenu );
 957             }
 958             submenu->setEnabled( true );
 959
 960             if( CreateChoicesMenu( submenu, psz_var, p_object, true ) == 0 )
 961                 menu->addMenu( submenu );
 962         }
 963         else
 964             CreateChoicesMenu( menu, psz_var, p_object, true );
 965         FREENULL( text.psz_string );
 966         return;
 967     }
 968
 969     switch( i_type & VLC_VAR_TYPE )
 970     {
 971         case VLC_VAR_VOID:
 972             var_Get( p_object, psz_var, &val );
 973             CreateAndConnect( menu, psz_var, TEXT_OR_VAR, "", ITEM_NORMAL,
 974                     p_object->i_object_id, val, i_type );
 975             break;
 976
 977         case VLC_VAR_BOOL:
 978             var_Get( p_object, psz_var, &val );
 979             val.b_bool = !val.b_bool;
 980             CreateAndConnect( menu, psz_var, TEXT_OR_VAR, "", ITEM_CHECK,
 981                     p_object->i_object_id, val, i_type, !val.b_bool );
 982             break;
 983     }
 984     FREENULL( text.psz_string );
 985 }
 986
 987
 988 int QVLCMenu::CreateChoicesMenu( QMenu *submenu, const char *psz_var,
 989         vlc_object_t *p_object, bool b_root )
 990 {
 991     vlc_value_t val, val_list, text_list;
 992     int i_type, i;
 993
 994     /* Check the type of the object variable */
 995     i_type = var_Type( p_object, psz_var );
 996
 997     /* Make sure we want to display the variable */
 998     if( IsMenuEmpty( psz_var, p_object, b_root ) ) return VLC_EGENERIC;
 999
1000     switch( i_type & VLC_VAR_TYPE )
1001     {
1002         case VLC_VAR_VOID:
1003         case VLC_VAR_BOOL:
1004         case VLC_VAR_VARIABLE:
1005         case VLC_VAR_STRING:
1006         case VLC_VAR_INTEGER:
1007         case VLC_VAR_FLOAT:
1008             break;
1009         default:
1010             /* Variable doesn't exist or isn't handled */
1011             return VLC_EGENERIC;
1012     }
1013
1014     if( var_Change( p_object, psz_var, VLC_VAR_GETLIST,
1015                 &val_list, &text_list ) < 0 )
1016     {
1017         return VLC_EGENERIC;
1018     }
1019
1020 #define NORMAL_OR_RADIO i_type & VLC_VAR_ISCOMMAND ? ITEM_NORMAL: ITEM_RADIO
1021 #define NOTCOMMAND !( i_type & VLC_VAR_ISCOMMAND )
1022 #define CURVAL val_list.p_list->p_values[i]
1023 #define CURTEXT text_list.p_list->p_values[i].psz_string
1024
1025     for( i = 0; i < val_list.p_list->i_count; i++ )
1026     {
1027         vlc_value_t another_val;
1028         QString menutext;
1029         QMenu *subsubmenu = new QMenu( submenu );
1030
1031         switch( i_type & VLC_VAR_TYPE )
1032         {
1033             case VLC_VAR_VARIABLE:
1034                 CreateChoicesMenu( subsubmenu, CURVAL.psz_string, p_object, false );
1035                 subsubmenu->setTitle( qfu( CURTEXT ? CURTEXT :CURVAL.psz_string ) );
1036                 submenu->addMenu( subsubmenu );
1037                 break;
1038
1039             case VLC_VAR_STRING:
1040                 var_Get( p_object, psz_var, &val );
1041                 another_val.psz_string = strdup( CURVAL.psz_string );
1042                 menutext = qfu( CURTEXT ? CURTEXT : another_val.psz_string );
1043                 CreateAndConnect( submenu, psz_var, menutext, "", NORMAL_OR_RADIO,
1044                         p_object->i_object_id, another_val, i_type,
1045                         NOTCOMMAND && val.psz_string &&
1046                         !strcmp( val.psz_string, CURVAL.psz_string ) );
1047
1048                 free( val.psz_string );
1049                 break;
1050
1051             case VLC_VAR_INTEGER:
1052                 var_Get( p_object, psz_var, &val );
1053                 if( CURTEXT ) menutext = qfu( CURTEXT );
1054                 else menutext.sprintf( "%d", CURVAL.i_int );
1055                 CreateAndConnect( submenu, psz_var, menutext, "", NORMAL_OR_RADIO,
1056                         p_object->i_object_id, CURVAL, i_type,
1057                         NOTCOMMAND && CURVAL.i_int == val.i_int );
1058                 break;
1059
1060             case VLC_VAR_FLOAT:
1061                 var_Get( p_object, psz_var, &val );
1062                 if( CURTEXT ) menutext = qfu( CURTEXT );
1063                 else menutext.sprintf( "%.2f", CURVAL.f_float );
1064                 CreateAndConnect( submenu, psz_var, menutext, "", NORMAL_OR_RADIO,
1065                         p_object->i_object_id, CURVAL, i_type,
1066                         NOTCOMMAND && CURVAL.f_float == val.f_float );
1067                 break;
1068
1069             default:
1070                 break;
1071         }
1072     }
1073     currentGroup = NULL;
1074
1075     /* clean up everything */
1076     var_Change( p_object, psz_var, VLC_VAR_FREELIST, &val_list, &text_list );
1077
1078 #undef NORMAL_OR_RADIO
1079 #undef NOTCOMMAND
1080 #undef CURVAL
1081 #undef CURTEXT
1082     return VLC_SUCCESS;
1083 }
1084
1085 void QVLCMenu::CreateAndConnect( QMenu *menu, const char *psz_var,
1086         QString text, QString help,
1087         int i_item_type, int i_object_id,
1088         vlc_value_t val, int i_val_type,
1089         bool checked )
1090 {
1091     QAction *action = FindActionWithVar( menu, psz_var );
1092     if( !action )
1093     {
1094         /* This is a value */
1095         action = FindActionWithText( menu, text );
1096         if( !action )
1097         {
1098             action = new QAction( text, menu );
1099             menu->addAction( action );
1100         }
1101     }
1102
1103     action->setText( text );
1104     action->setToolTip( help );
1105
1106     action->setEnabled( i_object_id != 0 );
1107
1108     if( i_item_type == ITEM_CHECK )
1109     {
1110         action->setCheckable( true );
1111     }
1112     else if( i_item_type == ITEM_RADIO )
1113     {
1114         action->setCheckable( true );
1115         if( !currentGroup )
1116             currentGroup = new QActionGroup( menu );
1117         currentGroup->addAction( action );
1118     }
1119
1120     action->setChecked( checked );
1121
1122     MenuItemData *itemData = new MenuItemData( i_object_id, i_val_type,
1123             val, psz_var );
1124     CONNECT( action, triggered(), THEDP->menusMapper, map() );
1125     THEDP->menusMapper->setMapping( action, itemData );
1126     menu->addAction( action );
1127 }
1128
1129 void QVLCMenu::DoAction( intf_thread_t *p_intf, QObject *data )
1130 {
1131     MenuItemData *itemData = qobject_cast<MenuItemData *>( data );
1132     vlc_object_t *p_object = ( vlc_object_t * )vlc_object_get( itemData->i_object_id );
1133     if( p_object == NULL ) return;
1134
1135     var_Set( p_object, itemData->psz_var, itemData->val );
1136     vlc_object_release( p_object );
1137 }
1138