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