?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Qt: fix menu double action
[vlc.git] / modules / gui / qt / menus.cpp
blobede795a55c810ca2a24bf5f7ccd7c6ff310f1f09
1 /*****************************************************************************
2 * menus.cpp : Qt menus
3 *****************************************************************************
4 * Copyright © 2006-2011 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 #include <vlc_intf_strings.h>
36 #include <vlc_vout.h> /* vout_thread_t */
37 #include <vlc_aout.h> /* audio_output_t */
38
39 #include "menus.hpp"
40
41 #include "main_interface.hpp" /* View modifications */
42 #include "dialogs_provider.hpp" /* Dialogs display */
43 #include "input_manager.hpp" /* Input Management */
44 #include "recents.hpp" /* Recent Items */
45 #include "actions_manager.hpp" /* Actions Management: play+volume */
46 #include "extensions_manager.hpp" /* Extensions menu */
47 #include "util/qmenuview.hpp" /* Simple Playlist menu */
48 #include "components/playlist/playlist_model.hpp" /* PLModel getter */
49 #include "components/playlist/standardpanel.hpp" /* PLView getter */
50 #include "components/extended_panels.hpp"
51
52 #include <QMenu>
53 #include <QMenuBar>
54 #include <QAction>
55 #include <QActionGroup>
56 #include <QSignalMapper>
57 #include <QStatusBar>
58
59 /*
60 This file defines the main menus and the pop-up menu (right-click menu)
61 and the systray menu (in that order in the file)
62
63 There are 4 menus that have to be rebuilt everytime there are called:
64 Audio, Video, Navigation, view
65 4 functions are building those menus: AudioMenu, VideoMenu, NavigMenu, View
66 and 3 functions associated are collecting the objects :
67 InputAutoMenuBuilder, AudioAutoMenuBuilder, VideoAutoMenuBuilder.
68
69 A QSignalMapper decides when to rebuild those menus cf MenuFunc in the .hpp
70 Just before one of those menus are aboutToShow(), they are rebuild.
71 */
72
73 enum
74 {
75 ITEM_NORMAL, /* not a checkbox, nor a radio */
76 ITEM_CHECK, /* Checkbox */
77 ITEM_RADIO /* Radiobox */
78 };
79
80 static QActionGroup *currentGroup;
81
82 QMenu *VLCMenuBar::recentsMenu = NULL;
83 QMenu *VLCMenuBar::audioDeviceMenu = NULL;
84 QMenu *VLCMenuBar::rendererMenu = NULL;
85 QActionGroup *VLCMenuBar::rendererGroup = NULL;
86
87 /**
88 * @brief Add static entries to DP in menus
89 **/
90 QAction *addDPStaticEntry( QMenu *menu,
91 const QString& text,
92 const char *icon,
93 const char *member,
94 const char *shortcut = NULL,
95 QAction::MenuRole role = QAction::NoRole
96 )
97 {
98 QAction *action = NULL;
99 #ifndef __APPLE__ /* We don't set icons in menus in MacOS X */
100 if( !EMPTY_STR( icon ) )
101 {
102 if( !EMPTY_STR( shortcut ) )
103 action = menu->addAction( QIcon( icon ), text, THEDP,
104 member, qtr( shortcut ) );
105 else
106 action = menu->addAction( QIcon( icon ), text, THEDP, member );
107 }
108 else
109 #endif
110 {
111 if( !EMPTY_STR( shortcut ) )
112 action = menu->addAction( text, THEDP, member, qtr( shortcut ) );
113 else
114 action = menu->addAction( text, THEDP, member );
115 }
116 #ifdef __APPLE__
117 action->setMenuRole( role );
118 #else
119 Q_UNUSED( role );
120 #endif
121 action->setData( VLCMenuBar::ACTION_STATIC );
122 return action;
123 }
124
125 /**
126 * @brief Add static entries to MIM in menus
127 **/
128 QAction* addMIMStaticEntry( intf_thread_t *p_intf,
129 QMenu *menu,
130 const QString& text,
131 const char *icon,
132 const char *member,
133 bool bStatic = false )
134 {
135 QAction *action;
136 #ifndef __APPLE__ /* We don't set icons in menus in MacOS X */
137 if( !EMPTY_STR( icon ) )
138 {
139 action = menu->addAction( text, THEMIM, member );
140 action->setIcon( QIcon( icon ) );
141 }
142 else
143 #endif
144 {
145 action = menu->addAction( text, THEMIM, member );
146 }
147 action->setData( VLCMenuBar::ACTION_STATIC |
148 ( bStatic ) ? VLCMenuBar::ACTION_ALWAYS_ENABLED
149 : VLCMenuBar::ACTION_NONE
150 );
151 return action;
152 }
153
154 /**
155 * @brief Enable all static entries of a menu, disable the others
156 * @param menu the menu in which the entries will be disabled
157 * @param enable if false, disable all entries
158 **/
159 void VLCMenuBar::EnableStaticEntries( QMenu *menu, bool enable = true )
160 {
161 if( !menu ) return;
162
163 QList< QAction* > actions = menu->actions();
164 for( int i = 0; i < actions.count(); ++i )
165 {
166 int actionflags = actions[i]->data().toInt();
167 if ( actionflags & ACTION_MANAGED )
168 actions[i]->setEnabled(
169 ( actionflags & ACTION_ALWAYS_ENABLED )
170 ||
171 enable
172 );
173 }
174 }
175
176 /**
177 * \return Number of static entries
178 **/
179 inline int DeleteNonStaticEntries( QMenu *menu )
180 {
181 if( !menu ) return VLC_EGENERIC;
182
183 int i_ret = 0;
184
185 QList< QAction* > actions = menu->actions();
186 for( int i = 0; i < actions.count(); ++i )
187 {
188 if( actions[i]->data().toInt() & VLCMenuBar::ACTION_NO_CLEANUP )
189 i_ret++;
190 else
191 delete actions[i];
192 }
193 return i_ret;
194 }
195
196 /**
197 * \return QAction associated to psz_var variable
198 **/
199 static QAction * FindActionWithVar( QMenu *menu, const char *psz_var )
200 {
201 QList< QAction* > actions = menu->actions();
202 for( int i = 0; i < actions.count(); ++i )
203 {
204 if( actions[i]->data().toString() == psz_var )
205 return actions[i];
206 }
207 return NULL;
208 }
209
210 /*****************************************************************************
211 * Definitions of variables for the dynamic menus
212 *****************************************************************************/
213 #define PUSH_OBJVAR(object,var) \
214 do { \
215 varnames.append(var); \
216 objects.append(VLC_OBJECT(object)); \
217 } while (0)
218
219 #define PUSH_VAR(var) PUSH_OBJVAR(p_object, var)
220 #define PUSH_INPUTVAR(var) PUSH_OBJVAR(p_input, var)
221 #define PUSH_PLVAR(var) PUSH_OBJVAR(pl, var)
222
223 static int InputAutoMenuBuilder( input_thread_t *p_input,
224 QVector<vlc_object_t *> &objects, QVector<const char *> &varnames )
225 {
226 PUSH_INPUTVAR( "bookmark" );
227 PUSH_INPUTVAR( "title" );
228 PUSH_INPUTVAR( "chapter" );
229 PUSH_INPUTVAR( "program" );
230
231 return VLC_SUCCESS;
232 }
233
234 static int VideoAutoMenuBuilder( playlist_t *pl, input_thread_t *p_input,
235 QVector<vlc_object_t *> &objects, QVector<const char *> &varnames )
236 {
237 vout_thread_t *p_object = p_input ? input_GetVout( p_input ) : NULL;
238
239 PUSH_INPUTVAR( "video-es" );
240 PUSH_PLVAR( "fullscreen" );
241 PUSH_PLVAR( "video-wallpaper" );
242 PUSH_VAR( "video-snapshot" );
243 PUSH_VAR( "zoom" );
244 PUSH_VAR( "autoscale" );
245 PUSH_VAR( "aspect-ratio" );
246 PUSH_VAR( "crop" );
247 PUSH_VAR( "deinterlace" );
248 PUSH_VAR( "deinterlace-mode" );
249
250 if( p_object )
251 vlc_object_release( p_object );
252 return VLC_SUCCESS;
253 }
254
255 static int SubsAutoMenuBuilder( input_thread_t *p_input,
256 QVector<vlc_object_t *> &objects, QVector<const char *> &varnames )
257 {
258 PUSH_INPUTVAR( "spu-es" );
259
260 return VLC_SUCCESS;
261 }
262
263 static int AudioAutoMenuBuilder( input_thread_t *p_input,
264 QVector<vlc_object_t *> &objects, QVector<const char *> &varnames )
265 {
266 audio_output_t *p_object = p_input ? input_GetAout( p_input ) : NULL;
267
268 PUSH_INPUTVAR( "audio-es" );
269 PUSH_VAR( "stereo-mode" );
270 PUSH_VAR( "visual" );
271
272 if( p_object )
273 vlc_object_release( p_object );
274 return VLC_SUCCESS;
275 }
276
277 /*****************************************************************************
278 * All normal menus
279 * Simple Code
280 *****************************************************************************/
281
282 // Static menu
283 static inline void addMenuToMainbar( QMenu *func, QString title, QMenuBar *bar ) {
284 func->setTitle( title );
285 bar->addMenu( func);
286 }
287
288 // Dynamic menu
289 #define BAR_DADD( func, title, id ) { \
290 QMenu *_menu = func; _menu->setTitle( title ); bar->addMenu( _menu ); \
291 MenuFunc *f = new MenuFunc( _menu, id ); \
292 CONNECT( _menu, aboutToShow(), THEDP->menusUpdateMapper, map() ); \
293 THEDP->menusUpdateMapper->setMapping( _menu, f ); }
294
295 // Add a simple action
296 static inline void addAction( QMenu *_menu, QVariant val, QString title ) {
297 QAction *_action = new QAction( title, _menu );
298 _action->setData( val );
299 _menu->addAction( _action );
300 }
301
302 // Add an action with a submenu
303 static inline QMenu *addActionWithSubmenu( QMenu *_menu, QVariant val, QString title ) {
304 QAction *_action = new QAction( title, _menu );
305 QMenu *_submenu = new QMenu( _menu );
306 _action->setData( val );
307 _action->setMenu( _submenu );
308 _menu->addAction( _action );
309 return _submenu;
310 }
311
312 // Add an action that is a checkbox
313 static inline void addActionWithCheckbox( QMenu *_menu, QVariant val, QString title ) {
314 QAction *_action = new QAction( title, _menu );
315 _action->setData( val );
316 _action->setCheckable( true );
317 _menu->addAction( _action );
318 }
319
320 /**
321 * Main Menu Bar Creation
322 **/
323 void VLCMenuBar::createMenuBar( MainInterface *mi,
324 intf_thread_t *p_intf )
325 {
326 /* QMainWindows->menuBar()
327 gives the QProcess::destroyed timeout issue on Cleanlooks style with
328 setDesktopAware set to false */
329 QMenuBar *bar = mi->menuBar();
330
331 addMenuToMainbar( FileMenu( p_intf, bar, mi ), qtr( "&Media" ), bar );
332
333 /* Dynamic menus, rebuilt before being showed */
334 BAR_DADD( NavigMenu( p_intf, bar ), qtr( "P&layback" ), 3 );
335 BAR_DADD( AudioMenu( p_intf, bar ), qtr( "&Audio" ), 1 );
336 BAR_DADD( VideoMenu( p_intf, bar ), qtr( "&Video" ), 2 );
337 BAR_DADD( SubtitleMenu( p_intf, bar ), qtr( "Subti&tle" ), 5 );
338
339 addMenuToMainbar( ToolsMenu( p_intf, bar ), qtr( "Tool&s" ), bar );
340
341 /* View menu, a bit different */
342 BAR_DADD( ViewMenu( p_intf, NULL, mi ), qtr( "V&iew" ), 4 );
343
344 addMenuToMainbar( HelpMenu( bar ), qtr( "&Help" ), bar );
345
346 }
347
348 /**
349 * Media ( File ) Menu
350 * Opening, streaming and quit
351 **/
352 QMenu *VLCMenuBar::FileMenu( intf_thread_t *p_intf, QWidget *parent, MainInterface *mi )
353 {
354 QMenu *menu = new QMenu( parent );
355 QAction *action;
356
357 addDPStaticEntry( menu, qtr( "Open &File..." ),
358 ":/type/file-asym.svg", SLOT( simpleOpenDialog() ), "Ctrl+O" );
359 addDPStaticEntry( menu, qtr( "&Open Multiple Files..." ),
360 ":/type/file-asym.svg", SLOT( openFileDialog() ), "Ctrl+Shift+O" );
361 addDPStaticEntry( menu, qtr( I_OP_OPDIR ),
362 ":/type/folder-grey.svg", SLOT( PLOpenDir() ), "Ctrl+F" );
363 addDPStaticEntry( menu, qtr( "Open &Disc..." ),
364 ":/type/disc.svg", SLOT( openDiscDialog() ), "Ctrl+D" );
365 addDPStaticEntry( menu, qtr( "Open &Network Stream..." ),
366 ":/type/network.svg", SLOT( openNetDialog() ), "Ctrl+N" );
367 addDPStaticEntry( menu, qtr( "Open &Capture Device..." ),
368 ":/type/capture-card.svg", SLOT( openCaptureDialog() ), "Ctrl+C" );
369
370 addDPStaticEntry( menu, qtr( "Open &Location from clipboard" ),
371 NULL, SLOT( openUrlDialog() ), "Ctrl+V" );
372
373 if( var_InheritBool( p_intf, "qt-recentplay" ) )
374 {
375 recentsMenu = new QMenu( qtr( "Open &Recent Media" ), menu );
376 updateRecents( p_intf );
377 menu->addMenu( recentsMenu );
378 }
379 menu->addSeparator();
380
381 addDPStaticEntry( menu, qtr( I_PL_SAVE ), "", SLOT( savePlayingToPlaylist() ),
382 "Ctrl+Y" );
383
384 #ifdef ENABLE_SOUT
385 addDPStaticEntry( menu, qtr( "Conve&rt / Save..." ), "",
386 SLOT( openAndTranscodingDialogs() ), "Ctrl+R" );
387 addDPStaticEntry( menu, qtr( "&Stream..." ),
388 ":/menu/stream.svg", SLOT( openAndStreamingDialogs() ), "Ctrl+S" );
389 menu->addSeparator();
390 #endif
391
392 action = addMIMStaticEntry( p_intf, menu, qtr( "Quit at the end of playlist" ), "",
393 SLOT( activatePlayQuit( bool ) ) );
394 action->setCheckable( true );
395 action->setChecked( THEMIM->getPlayExitState() );
396
397 if( mi && mi->getSysTray() )
398 {
399 action = menu->addAction( qtr( "Close to systray"), mi,
400 SLOT( toggleUpdateSystrayMenu() ) );
401 }
402
403 addDPStaticEntry( menu, qtr( "&Quit" ) ,
404 ":/menu/exit.svg", SLOT( quit() ), "Ctrl+Q" );
405 return menu;
406 }
407
408 /**
409 * Tools, like Media Information, Preferences or Messages
410 **/
411 QMenu *VLCMenuBar::ToolsMenu( intf_thread_t *p_intf, QMenu *menu )
412 {
413 addDPStaticEntry( menu, qtr( "&Effects and Filters"), ":/menu/settings.svg",
414 SLOT( extendedDialog() ), "Ctrl+E" );
415
416 addDPStaticEntry( menu, qtr( "&Track Synchronization"), ":/menu/setting.svgs",
417 SLOT( synchroDialog() ), "" );
418
419 addDPStaticEntry( menu, qtr( I_MENU_INFO ) , ":/menu/info.svg",
420 SLOT( mediaInfoDialog() ), "Ctrl+I" );
421 addDPStaticEntry( menu, qtr( I_MENU_CODECINFO ) ,
422 ":/menu/info.svg", SLOT( mediaCodecDialog() ), "Ctrl+J" );
423
424 #ifdef ENABLE_VLM
425 addDPStaticEntry( menu, qtr( I_MENU_VLM ), "", SLOT( vlmDialog() ),
426 "Ctrl+Shift+W" );
427 #endif
428
429 addDPStaticEntry( menu, qtr( "Program Guide" ), "", SLOT( epgDialog() ),
430 "" );
431
432 addDPStaticEntry( menu, qtr( I_MENU_MSG ),
433 ":/menu/messages.svg", SLOT( messagesDialog() ), "Ctrl+M" );
434
435 addDPStaticEntry( menu, qtr( "Plu&gins and extensions" ),
436 "", SLOT( pluginDialog() ) );
437 menu->addSeparator();
438
439 if( !p_intf->p_sys->b_isDialogProvider )
440 addDPStaticEntry( menu, qtr( "Customi&ze Interface..." ),
441 ":/menu/preferences.svg", SLOT( toolbarDialog() ) );
442
443 addDPStaticEntry( menu, qtr( "&Preferences" ),
444 ":/menu/preferences.svg", SLOT( prefsDialog() ), "Ctrl+P", QAction::PreferencesRole );
445
446 return menu;
447 }
448
449 /**
450 * View Menu
451 * Interface modification, load other interfaces, activate Extensions
452 * \param current, set to NULL for menu creation, else for menu update
453 **/
454 QMenu *VLCMenuBar::ViewMenu( intf_thread_t *p_intf, QMenu *current, MainInterface *_mi )
455 {
456 QAction *action;
457 QMenu *menu;
458
459 MainInterface *mi = _mi ? _mi : p_intf->p_sys->p_mi;
460 assert( mi );
461
462 if( !current )
463 {
464 menu = new QMenu( qtr( "&View" ), mi );
465 }
466 else
467 {
468 menu = current;
469 //menu->clear();
470 //HACK menu->clear() does not delete submenus
471 QList<QAction*> actions = menu->actions();
472 foreach( QAction *a, actions )
473 {
474 QMenu *m = a->menu();
475 if( a->parent() == menu ) delete a;
476 else menu->removeAction( a );
477 if( m && m->parent() == menu ) delete m;
478 }
479 }
480
481 menu->addAction(
482 #ifndef __APPLE__
483 QIcon( ":/menu/playlist_menu.svg" ),
484 #endif
485 qtr( "Play&list" ), mi,
486 SLOT( togglePlaylist() ), qtr( "Ctrl+L" ) );
487
488 /* Docked Playlist */
489 action = menu->addAction( qtr( "Docked Playlist" ) );
490 action->setCheckable( true );
491 action->setChecked( mi->isPlDocked() );
492 CONNECT( action, triggered( bool ), mi, dockPlaylist( bool ) );
493
494 if( mi->getPlaylistView() )
495 menu->addMenu( StandardPLPanel::viewSelectionMenu( mi->getPlaylistView() ) );
496
497 menu->addSeparator();
498
499 action = menu->addAction( qtr( "Always on &top" ) );
500 action->setCheckable( true );
501 action->setChecked( mi->isInterfaceAlwaysOnTop() );
502 CONNECT( action, triggered( bool ), mi, setInterfaceAlwaysOnTop( bool ) );
503
504 menu->addSeparator();
505
506 /* Minimal View */
507 action = menu->addAction( qtr( "Mi&nimal Interface" ) );
508 action->setShortcut( qtr( "Ctrl+H" ) );
509 action->setCheckable( true );
510 action->setChecked( (mi->getControlsVisibilityStatus()
511 & MainInterface::CONTROLS_HIDDEN ) );
512
513 CONNECT( action, triggered( bool ), mi, toggleMinimalView( bool ) );
514 CONNECT( mi, minimalViewToggled( bool ), action, setChecked( bool ) );
515
516 /* FullScreen View */
517 action = menu->addAction( qtr( "&Fullscreen Interface" ), mi,
518 SLOT( toggleInterfaceFullScreen() ), QString( "F11" ) );
519 action->setCheckable( true );
520 action->setChecked( mi->isInterfaceFullScreen() );
521 CONNECT( mi, fullscreenInterfaceToggled( bool ),
522 action, setChecked( bool ) );
523
524 /* Advanced Controls */
525 action = menu->addAction( qtr( "&Advanced Controls" ), mi,
526 SLOT( toggleAdvancedButtons() ) );
527 action->setCheckable( true );
528 if( mi->getControlsVisibilityStatus() & MainInterface::CONTROLS_ADVANCED )
529 action->setChecked( true );
530
531 action = menu->addAction( qtr( "Status Bar" ) );
532 action->setCheckable( true );
533 action->setChecked( mi->statusBar()->isVisible() );
534 CONNECT( action, triggered( bool ), mi, setStatusBarVisibility( bool) );
535 #if 0 /* For Visualisations. Not yet working */
536 adv = menu->addAction( qtr( "Visualizations selector" ), mi,
537 SLOT( visual() ) );
538 adv->setCheckable( true );
539 if( visual_selector_enabled ) adv->setChecked( true );
540 #endif
541
542 menu->addSeparator();
543
544 InterfacesMenu( p_intf, menu );
545 menu->addSeparator();
546
547 /* Extensions */
548 ExtensionsMenu( p_intf, menu );
549
550 return menu;
551 }
552
553 /**
554 * Interface Sub-Menu, to list extras interface and skins
555 **/
556 QMenu *VLCMenuBar::InterfacesMenu( intf_thread_t *p_intf, QMenu *current )
557 {
558 QVector<vlc_object_t *> objects;
559 QVector<const char *> varnames;
560 varnames.append( "intf-add" );
561 objects.append( VLC_OBJECT(p_intf) );
562
563 return Populate( p_intf, current, varnames, objects );
564 }
565
566 /**
567 * Extensions menu: populate the current menu with extensions
568 **/
569 void VLCMenuBar::ExtensionsMenu( intf_thread_t *p_intf, QMenu *extMenu )
570 {
571 /* Get ExtensionsManager and load extensions if needed */
572 ExtensionsManager *extMgr = ExtensionsManager::getInstance( p_intf );
573
574 if( !var_InheritBool( p_intf, "qt-autoload-extensions")
575 && !extMgr->isLoaded() )
576 {
577 return;
578 }
579
580 if( !extMgr->isLoaded() && !extMgr->cannotLoad() )
581 {
582 extMgr->loadExtensions();
583 }
584
585 /* Let the ExtensionsManager build itself the menu */
586 extMenu->addSeparator();
587 extMgr->menu( extMenu );
588 }
589
590 static inline void VolumeEntries( intf_thread_t *p_intf, QMenu *current )
591 {
592 current->addSeparator();
593
594 QAction *action = current->addAction( QIcon( ":/toolbar/volume-high.svg" ), qtr( "&Increase Volume" ),
595 ActionsManager::getInstance( p_intf ), SLOT( AudioUp() ) );
596 action->setData( VLCMenuBar::ACTION_STATIC );
597 action = current->addAction( QIcon( ":/toolbar/volume-low.svg" ), qtr( "D&ecrease Volume" ),
598 ActionsManager::getInstance( p_intf ), SLOT( AudioDown() ) );
599 action->setData( VLCMenuBar::ACTION_STATIC );
600 action = current->addAction( QIcon( ":/toolbar/volume-muted.svg" ), qtr( "&Mute" ),
601 ActionsManager::getInstance( p_intf ), SLOT( toggleMuteAudio() ) );
602 action->setData( VLCMenuBar::ACTION_STATIC );
603 }
604
605 /**
606 * Main Audio Menu
607 **/
608 QMenu *VLCMenuBar::AudioMenu( intf_thread_t *p_intf, QMenu * current )
609 {
610 QVector<vlc_object_t *> objects;
611 QVector<const char *> varnames;
612 audio_output_t *p_aout;
613 input_thread_t *p_input;
614
615 if (!audioDeviceMenu)
616 audioDeviceMenu = new QMenu( qtr( "Audio &Device" ) );
617
618 if( current->isEmpty() )
619 {
620 addActionWithSubmenu( current, "audio-es", qtr( "Audio &Track" ) );
621 current->addMenu( audioDeviceMenu );
622 addActionWithSubmenu( current, "stereo-mode", qtr( "&Stereo Mode" ) );
623 current->addSeparator();
624
625 addActionWithSubmenu( current, "visual", qtr( "&Visualizations" ) );
626 VolumeEntries( p_intf, current );
627 }
628
629 p_input = THEMIM->getInput();
630 p_aout = THEMIM->getAout();
631 EnableStaticEntries( current, ( p_aout != NULL ) );
632 AudioAutoMenuBuilder( p_input, objects, varnames );
633 updateAudioDevice( p_intf, p_aout, audioDeviceMenu );
634 if( p_aout )
635 {
636 vlc_object_release( p_aout );
637 }
638
639 return Populate( p_intf, current, varnames, objects );
640 }
641
642 /* Subtitles */
643 QMenu *VLCMenuBar::SubtitleMenu( intf_thread_t *p_intf, QMenu *current, bool b_popup )
644 {
645 input_thread_t *p_input;
646 QVector<vlc_object_t *> objects;
647 QVector<const char *> varnames;
648
649 if( current->isEmpty() || b_popup )
650 {
651 addDPStaticEntry( current, qtr( "Add &Subtitle File..." ), "",
652 SLOT( loadSubtitlesFile() ) );
653 addActionWithSubmenu( current, "spu-es", qtr( "Sub &Track" ) );
654 current->addSeparator();
655 }
656
657 p_input = THEMIM->getInput();
658 SubsAutoMenuBuilder( p_input, objects, varnames );
659
660 return Populate( p_intf, current, varnames, objects );
661 }
662
663 /**
664 * Main Video Menu
665 * Subtitles are part of Video.
666 **/
667 QMenu *VLCMenuBar::VideoMenu( intf_thread_t *p_intf, QMenu *current )
668 {
669 input_thread_t *p_input;
670 QVector<vlc_object_t *> objects;
671 QVector<const char *> varnames;
672
673 if ( !rendererMenu )
674 rendererMenu = RendererMenu( p_intf );
675
676 if( current->isEmpty() )
677 {
678 addActionWithSubmenu( current, "video-es", qtr( "Video &Track" ) );
679
680 current->addSeparator();
681 current->addMenu( rendererMenu );
682
683 current->addSeparator();
684 /* Surface modifiers */
685 addActionWithCheckbox( current, "fullscreen", qtr( "&Fullscreen" ) );
686 addActionWithCheckbox( current, "autoscale", qtr( "Always Fit &Window" ) );
687 addActionWithCheckbox( current, "video-wallpaper", qtr( "Set as Wall&paper" ) );
688
689 current->addSeparator();
690 /* Size modifiers */
691 addActionWithSubmenu( current, "zoom", qtr( "&Zoom" ) );
692 addActionWithSubmenu( current, "aspect-ratio", qtr( "&Aspect Ratio" ) );
693 addActionWithSubmenu( current, "crop", qtr( "&Crop" ) );
694
695 current->addSeparator();
696 /* Rendering modifiers */
697 addActionWithSubmenu( current, "deinterlace", qtr( "&Deinterlace" ) );
698 addActionWithSubmenu( current, "deinterlace-mode", qtr( "&Deinterlace mode" ) );
699
700 current->addSeparator();
701 /* Other actions */
702 addAction( current, "video-snapshot", qtr( "Take &Snapshot" ) );
703 }
704
705 p_input = THEMIM->getInput();
706
707 VideoAutoMenuBuilder( THEPL, p_input, objects, varnames );
708
709 return Populate( p_intf, current, varnames, objects );
710 }
711
712 /**
713 * Navigation Menu
714 * For DVD, MP4, MOV and other chapter based format
715 **/
716 QMenu *VLCMenuBar::NavigMenu( intf_thread_t *p_intf, QMenu *menu )
717 {
718 QAction *action;
719 QMenu *submenu;
720
721 addActionWithSubmenu( menu, "title", qtr( "T&itle" ) );
722 submenu = addActionWithSubmenu( menu, "chapter", qtr( "&Chapter" ) );
723 submenu->setTearOffEnabled( true );
724 addActionWithSubmenu( menu, "program", qtr( "&Program" ) );
725
726 submenu = new QMenu( qtr( I_MENU_BOOKMARK ), menu );
727 submenu->setTearOffEnabled( true );
728 addDPStaticEntry( submenu, qtr( "&Manage" ), "",
729 SLOT( bookmarksDialog() ), "Ctrl+B" );
730 submenu->addSeparator();
731 action = menu->addMenu( submenu );
732 action->setData( "bookmark" );
733
734 menu->addSeparator();
735
736 PopupMenuControlEntries( menu, p_intf );
737
738 EnableStaticEntries( menu, ( THEMIM->getInput() != NULL ) );
739 return RebuildNavigMenu( p_intf, menu, true );
740 }
741
742 QMenu *VLCMenuBar::RebuildNavigMenu( intf_thread_t *p_intf, QMenu *menu, bool b_keep )
743 {
744 /* */
745 input_thread_t *p_object;
746 QVector<vlc_object_t *> objects;
747 QVector<const char *> varnames;
748
749 /* Get the input and hold it */
750 p_object = THEMIM->getInput();
751
752 InputAutoMenuBuilder( p_object, objects, varnames );
753
754 /* Title and so on */
755 PUSH_VAR( "prev-title" );
756 PUSH_VAR( "next-title" );
757 PUSH_VAR( "prev-chapter" );
758 PUSH_VAR( "next-chapter" );
759
760 /* */
761 EnableStaticEntries( menu, (p_object != NULL ) );
762 Populate( p_intf, menu, varnames, objects );
763
764 /* Remove playback actions to recreate them */
765 if( !b_keep )
766 {
767 QList< QAction* > actions = menu->actions();
768 for( int i = 0; i < actions.count(); i++ )
769 if( actions[i]->data().toInt() & ACTION_DELETE_ON_REBUILD )
770 delete actions[i];
771 }
772
773 PopupMenuPlaylistEntries( menu, p_intf, p_object );
774
775 return menu;
776 }
777
778 /**
779 * Help/About Menu
780 **/
781 QMenu *VLCMenuBar::HelpMenu( QWidget *parent )
782 {
783 QMenu *menu = new QMenu( parent );
784 addDPStaticEntry( menu, qtr( "&Help" ) ,
785 ":/menu/help.svg", SLOT( helpDialog() ), "F1" );
786 #ifdef UPDATE_CHECK
787 addDPStaticEntry( menu, qtr( "Check for &Updates..." ) , "",
788 SLOT( updateDialog() ) );
789 #endif
790 menu->addSeparator();
791 addDPStaticEntry( menu, qtr( I_MENU_ABOUT ), ":/menu/info.svg",
792 SLOT( aboutDialog() ), "Shift+F1", QAction::AboutRole );
793 return menu;
794 }
795
796 /*****************************************************************************
797 * Popup menus - Right Click menus *
798 *****************************************************************************/
799 #define POPUP_BOILERPLATE \
800 QMenu* menu; \
801 QVector<vlc_object_t *> objects; \
802 QVector<const char *> varnames; \
803 input_thread_t *p_input = THEMIM->getInput();
804
805 #define CREATE_POPUP \
806 menu = new QMenu(); \
807 Populate( p_intf, menu, varnames, objects ); \
808 if( show ) \
809 menu->popup( QCursor::pos() ); \
810
811 void VLCMenuBar::PopupMenuPlaylistEntries( QMenu *menu,
812 intf_thread_t *p_intf,
813 input_thread_t *p_input )
814 {
815 QAction *action;
816
817 /* Play or Pause action and icon */
818 if( !p_input || var_GetInteger( p_input, "state" ) != PLAYING_S )
819 {
820 action = menu->addAction( qtr( "&Play" ),
821 ActionsManager::getInstance( p_intf ), SLOT( play() ) );
822 #ifndef __APPLE__ /* No icons in menus in Mac */
823 action->setIcon( QIcon( ":/toolbar/play_b.svg" ) );
824 #endif
825 }
826 else
827 {
828 action = addMIMStaticEntry( p_intf, menu, qtr( "Pause" ),
829 ":/toolbar/pause_b.svg", SLOT( togglePlayPause() ) );
830 }
831 action->setData( ACTION_DELETE_ON_REBUILD );
832
833 /* Stop */
834 action = addMIMStaticEntry( p_intf, menu, qtr( "&Stop" ),
835 ":/toolbar/stop_b.svg", SLOT( stop() ), true );
836 if( !p_input )
837 action->setEnabled( false );
838 action->setData( ACTION_DELETE_ON_REBUILD );
839
840 /* Next / Previous */
841 bool bPlaylistEmpty = THEMIM->hasEmptyPlaylist();
842 action = addMIMStaticEntry( p_intf, menu, qtr( "Pre&vious" ),
843 ":/toolbar/previous_b.svg", SLOT( prev() ), true );
844 action->setEnabled( !bPlaylistEmpty );
845 action->setData( ACTION_NO_CLEANUP + ACTION_DELETE_ON_REBUILD );
846 CONNECT( THEMIM, playlistNotEmpty(bool), action, setEnabled(bool) );
847
848 action = addMIMStaticEntry( p_intf, menu, qtr( "Ne&xt" ),
849 ":/toolbar/next_b.svg", SLOT( next() ), true );
850 action->setEnabled( !bPlaylistEmpty );
851 action->setData( ACTION_NO_CLEANUP + ACTION_DELETE_ON_REBUILD );
852 CONNECT( THEMIM, playlistNotEmpty(bool), action, setEnabled(bool) );
853
854 action = menu->addAction( qtr( "Record" ), THEAM, SLOT( record() ) );
855 action->setIcon( QIcon( ":/toolbar/record.svg" ) );
856 if( !p_input )
857 action->setEnabled( false );
858 action->setData( ACTION_NO_CLEANUP + ACTION_DELETE_ON_REBUILD );
859 menu->addSeparator();
860 }
861
862 void VLCMenuBar::PopupMenuControlEntries( QMenu *menu, intf_thread_t *p_intf,
863 bool b_normal )
864 {
865 QAction *action;
866 QMenu *rateMenu = new QMenu( qtr( "Sp&eed" ), menu );
867 rateMenu->setTearOffEnabled( true );
868
869 if( b_normal )
870 {
871 /* Faster/Slower */
872 action = rateMenu->addAction( qtr( "&Faster" ), THEMIM->getIM(),
873 SLOT( faster() ) );
874 #ifndef __APPLE__ /* No icons in menus in Mac */
875 action->setIcon( QIcon( ":/toolbar/faster2.svg") );
876 #endif
877 action->setData( ACTION_STATIC );
878 }
879
880 action = rateMenu->addAction( QIcon( ":/toolbar/faster2.svg" ), qtr( "Faster (fine)" ), THEMIM->getIM(),
881 SLOT( littlefaster() ) );
882 action->setData( ACTION_STATIC );
883
884 action = rateMenu->addAction( qtr( "N&ormal Speed" ), THEMIM->getIM(),
885 SLOT( normalRate() ) );
886 action->setData( ACTION_STATIC );
887
888 action = rateMenu->addAction( QIcon( ":/toolbar/slower2.svg" ), qtr( "Slower (fine)" ), THEMIM->getIM(),
889 SLOT( littleslower() ) );
890 action->setData( ACTION_STATIC );
891
892 if( b_normal )
893 {
894 action = rateMenu->addAction( qtr( "Slo&wer" ), THEMIM->getIM(),
895 SLOT( slower() ) );
896 #ifndef __APPLE__ /* No icons in menus in Mac */
897 action->setIcon( QIcon( ":/toolbar/slower2.svg") );
898 #endif
899 action->setData( ACTION_STATIC );
900 }
901
902 action = menu->addMenu( rateMenu );
903 action->setData( ACTION_STATIC );
904
905 menu->addSeparator();
906
907 if( !b_normal ) return;
908
909 action = menu->addAction( qtr( "&Jump Forward" ), THEMIM->getIM(),
910 SLOT( jumpFwd() ) );
911 #ifndef __APPLE__ /* No icons in menus in Mac */
912 action->setIcon( QIcon( ":/toolbar/skip_fw.svg") );
913 #endif
914 action->setData( ACTION_STATIC );
915
916 action = menu->addAction( qtr( "Jump Bac&kward" ), THEMIM->getIM(),
917 SLOT( jumpBwd() ) );
918 #ifndef __APPLE__ /* No icons in menus in Mac */
919 action->setIcon( QIcon( ":/toolbar/skip_back.svg") );
920 #endif
921 action->setData( ACTION_STATIC );
922
923 action = menu->addAction( qtr( I_MENU_GOTOTIME ), THEDP, SLOT( gotoTimeDialog() ), qtr( "Ctrl+T" ) );
924 action->setData( ACTION_ALWAYS_ENABLED );
925
926 menu->addSeparator();
927 }
928
929 void VLCMenuBar::PopupMenuStaticEntries( QMenu *menu )
930 {
931 QMenu *openmenu = new QMenu( qtr( "Open Media" ), menu );
932 addDPStaticEntry( openmenu, qtr( I_OP_OPF ),
933 ":/type/file-asym.svg", SLOT( openFileDialog() ) );
934 addDPStaticEntry( openmenu, qtr( I_OP_OPDIR ),
935 ":/type/folder-grey.svg", SLOT( PLOpenDir() ) );
936 addDPStaticEntry( openmenu, qtr( "Open &Disc..." ),
937 ":/type/disc.svg", SLOT( openDiscDialog() ) );
938 addDPStaticEntry( openmenu, qtr( "Open &Network..." ),
939 ":/type/network.svg", SLOT( openNetDialog() ) );
940 addDPStaticEntry( openmenu, qtr( "Open &Capture Device..." ),
941 ":/type/capture-card.svg", SLOT( openCaptureDialog() ) );
942 menu->addMenu( openmenu );
943
944 menu->addSeparator();
945 #if 0
946 QMenu *helpmenu = HelpMenu( menu );
947 helpmenu->setTitle( qtr( "Help" ) );
948 menu->addMenu( helpmenu );
949 #endif
950
951 addDPStaticEntry( menu, qtr( "Quit" ), ":/menu/exit.svg",
952 SLOT( quit() ), "Ctrl+Q", QAction::QuitRole );
953 }
954
955 /* Video Tracks and Subtitles tracks */
956 QMenu* VLCMenuBar::VideoPopupMenu( intf_thread_t *p_intf, bool show )
957 {
958 POPUP_BOILERPLATE
959 if( p_input )
960 VideoAutoMenuBuilder( THEPL, p_input, objects, varnames );
961 CREATE_POPUP
962 return menu;
963 }
964
965 /* Audio Tracks */
966 QMenu* VLCMenuBar::AudioPopupMenu( intf_thread_t *p_intf, bool show )
967 {
968 POPUP_BOILERPLATE
969 if( p_input )
970 AudioAutoMenuBuilder( p_input, objects, varnames );
971 CREATE_POPUP
972 return menu;
973 }
974
975 /* Navigation stuff, and general menus ( open ), used only for skins */
976 QMenu* VLCMenuBar::MiscPopupMenu( intf_thread_t *p_intf, bool show )
977 {
978 POPUP_BOILERPLATE
979
980 menu = new QMenu();
981 if( p_input )
982 {
983 InputAutoMenuBuilder( p_input, objects, varnames );
984 menu->addSeparator();
985 }
986
987 Populate( p_intf, menu, varnames, objects );
988
989 menu->addSeparator();
990 PopupMenuPlaylistEntries( menu, p_intf, p_input );
991
992 menu->addSeparator();
993 PopupMenuControlEntries( menu, p_intf );
994
995 menu->addSeparator();
996 PopupMenuStaticEntries( menu );
997
998 if( show )
999 menu->popup( QCursor::pos() );
1000 return menu;
1001 }
1002
1003 /* Main Menu that sticks everything together */
1004 QMenu* VLCMenuBar::PopupMenu( intf_thread_t *p_intf, bool show )
1005 {
1006 POPUP_BOILERPLATE
1007
1008 /* */
1009 menu = new QMenu();
1010 QAction *action;
1011 bool b_isFullscreen = false;
1012 MainInterface *mi = p_intf->p_sys->p_mi;
1013
1014 PopupMenuPlaylistEntries( menu, p_intf, p_input );
1015 menu->addSeparator();
1016
1017 if( p_input )
1018 {
1019 QMenu *submenu;
1020 vout_thread_t *p_vout = THEMIM->getVout();
1021
1022 /* Add a fullscreen switch button, since it is the most used function */
1023 if( p_vout )
1024 {
1025 vlc_value_t val; var_Get( p_vout, "fullscreen", &val );
1026
1027 b_isFullscreen = !( !val.b_bool );
1028 if( b_isFullscreen )
1029 {
1030 val.b_bool = false;
1031 CreateAndConnect( menu, "fullscreen",
1032 qtr( "Leave Fullscreen" ),"" , ITEM_NORMAL,
1033 VLC_OBJECT(THEPL), val, VLC_VAR_BOOL, b_isFullscreen );
1034 }
1035 vlc_object_release( p_vout );
1036
1037 menu->addSeparator();
1038 }
1039
1040 /* Input menu */
1041 InputAutoMenuBuilder( p_input, objects, varnames );
1042
1043 /* Audio menu */
1044 submenu = new QMenu( menu );
1045 action = menu->addMenu( AudioMenu( p_intf, submenu ) );
1046 action->setText( qtr( "&Audio" ) );
1047 if( action->menu()->isEmpty() )
1048 action->setEnabled( false );
1049
1050 /* Video menu */
1051 submenu = new QMenu( menu );
1052 action = menu->addMenu( VideoMenu( p_intf, submenu ) );
1053 action->setText( qtr( "&Video" ) );
1054 if( action->menu()->isEmpty() )
1055 action->setEnabled( false );
1056
1057 /* Subtitles menu */
1058 submenu = new QMenu( menu );
1059 action = menu->addMenu( SubtitleMenu( p_intf, submenu, true ) );
1060 action->setText( qtr( "Subti&tle") );
1061 UpdateItem( p_intf, submenu, "spu-es", VLC_OBJECT(p_input), true );
1062
1063 /* Playback menu for chapters */
1064 submenu = new QMenu( menu );
1065 action = menu->addMenu( NavigMenu( p_intf, submenu ) );
1066 action->setText( qtr( "&Playback" ) );
1067 if( action->menu()->isEmpty() )
1068 action->setEnabled( false );
1069 }
1070
1071 menu->addSeparator();
1072
1073 /* Add some special entries for windowed mode: Interface Menu */
1074 if( !b_isFullscreen )
1075 {
1076 QMenu *submenu = new QMenu( qtr( "Tool&s" ), menu );
1077 /*QMenu *tools =*/ ToolsMenu( p_intf, submenu );
1078 submenu->addSeparator();
1079
1080 if( mi )
1081 {
1082 QMenu *bar = menu; // Needed for next macro
1083 BAR_DADD( ViewMenu( p_intf, NULL, mi ), qtr( "V&iew" ), 4 );
1084 }
1085
1086 /* In skins interface, append some items */
1087 if( p_intf->p_sys->b_isDialogProvider )
1088 {
1089 vlc_object_t* p_object = p_intf->obj.parent;
1090 submenu->setTitle( qtr( "Interface" ) );
1091
1092 /* Open skin dialog box */
1093 objects.clear(); varnames.clear();
1094 objects.append( p_object );
1095 varnames.append( "intf-skins-interactive" );
1096 Populate( p_intf, submenu, varnames, objects );
1097 QAction* action = submenu->actions().back();
1098 action->setShortcut( QKeySequence( "Ctrl+Shift+S" ));
1099
1100 /* list of skins available */
1101 objects.clear(); varnames.clear();
1102 objects.append( p_object );
1103 varnames.append( "intf-skins" );
1104 Populate( p_intf, submenu, varnames, objects );
1105
1106 submenu->addSeparator();
1107
1108 /* list of extensions */
1109 ExtensionsMenu( p_intf, submenu );
1110 }
1111
1112 menu->addMenu( submenu );
1113 }
1114
1115 /* */
1116 QMenuView *plMenu = new QMenuView( menu, 25 );
1117 plMenu->setTitle( qtr("Playlist") );
1118 PLModel *model = PLModel::getPLModel( p_intf );
1119 plMenu->setModel( model );
1120 CONNECT( plMenu, activated(const QModelIndex&),
1121 model, activateItem(const QModelIndex&));
1122 menu->addMenu( plMenu );
1123
1124 /* Static entries for ending, like open */
1125 if( p_intf->p_sys->b_isDialogProvider )
1126 {
1127 QMenu *openmenu = FileMenu( p_intf, menu );
1128 openmenu->setTitle( qtr( "Open Media" ) );
1129 menu->addMenu( openmenu );
1130
1131 menu->addSeparator();
1132
1133 QMenu *helpmenu = HelpMenu( menu );
1134 helpmenu->setTitle( qtr( "Help" ) );
1135 menu->addMenu( helpmenu );
1136
1137 addDPStaticEntry( menu, qtr( "Quit" ), ":/menu/exit.svg",
1138 SLOT( quit() ), "Ctrl+Q", QAction::QuitRole );
1139 }
1140 else
1141 PopupMenuStaticEntries( menu );
1142
1143 if( show )
1144 menu->popup( QCursor::pos() );
1145 return menu;
1146 }
1147
1148 #undef CREATE_POPUP
1149 #undef POPUP_BOILERPLATE
1150 #undef BAR_DADD
1151
1152 /************************************************************************
1153 * Systray Menu *
1154 ************************************************************************/
1155
1156 void VLCMenuBar::updateSystrayMenu( MainInterface *mi,
1157 intf_thread_t *p_intf,
1158 bool b_force_visible )
1159 {
1160 input_thread_t *p_input = THEMIM->getInput();
1161
1162 /* Get the systray menu and clean it */
1163 QMenu *sysMenu = mi->getSysTrayMenu();
1164 sysMenu->clear();
1165
1166 #ifndef Q_OS_MAC
1167 /* Hide / Show VLC and cone */
1168 if( mi->isVisible() || b_force_visible )
1169 {
1170 sysMenu->addAction( QIcon( ":/logo/vlc16.png" ),
1171 qtr( "&Hide VLC media player in taskbar" ), mi,
1172 SLOT( hideUpdateSystrayMenu() ) );
1173 }
1174 else
1175 {
1176 sysMenu->addAction( QIcon( ":/logo/vlc16.png" ),
1177 qtr( "Sho&w VLC media player" ), mi,
1178 SLOT( showUpdateSystrayMenu() ) );
1179 }
1180 sysMenu->addSeparator();
1181 #endif
1182
1183 PopupMenuPlaylistEntries( sysMenu, p_intf, p_input );
1184 PopupMenuControlEntries( sysMenu, p_intf, false );
1185
1186 VolumeEntries( p_intf, sysMenu );
1187 sysMenu->addSeparator();
1188 addDPStaticEntry( sysMenu, qtr( "&Open Media" ),
1189 ":/type/file-wide.svg", SLOT( openFileDialog() ) );
1190 addDPStaticEntry( sysMenu, qtr( "&Quit" ) ,
1191 ":/menu/exit.svg", SLOT( quit() ) );
1192
1193 /* Set the menu */
1194 mi->getSysTray()->setContextMenu( sysMenu );
1195 }
1196
1197
1198 #undef PUSH_VAR
1199
1200 /*************************************************************************
1201 * Builders for automenus
1202 *************************************************************************/
1203 QMenu * VLCMenuBar::Populate( intf_thread_t *p_intf,
1204 QMenu *current,
1205 QVector< const char *> & varnames,
1206 QVector<vlc_object_t *> & objects )
1207 {
1208 QMenu *menu = current;
1209 assert( menu );
1210
1211 currentGroup = NULL;
1212
1213 for( int i = 0; i < (int)objects.count() ; i++ )
1214 {
1215 if( !varnames[i] || !*varnames[i] )
1216 {
1217 menu->addSeparator();
1218 continue;
1219 }
1220
1221 UpdateItem( p_intf, menu, varnames[i], objects[i], true );
1222 }
1223 return menu;
1224 }
1225
1226 /*****************************************************************************
1227 * Private methods.
1228 *****************************************************************************/
1229
1230 static bool IsMenuEmpty( const char *psz_var, vlc_object_t *p_object )
1231 {
1232 /* Check if we want to display the variable */
1233 if( !(var_Type( p_object, psz_var) & VLC_VAR_HASCHOICE) )
1234 return false;
1235
1236 vlc_value_t val;
1237 var_Change( p_object, psz_var, VLC_VAR_CHOICESCOUNT, &val, NULL );
1238 return val.i_int == 0 || val.i_int == 1;
1239 }
1240
1241 #define TEXT_OR_VAR qfue ( text.psz_string ? text.psz_string : psz_var )
1242
1243 void VLCMenuBar::UpdateItem( intf_thread_t *p_intf, QMenu *menu,
1244 const char *psz_var, vlc_object_t *p_object, bool b_submenu )
1245 {
1246 vlc_value_t val, text;
1247 int i_type;
1248
1249 QAction *action = FindActionWithVar( menu, psz_var );
1250 if( action )
1251 DeleteNonStaticEntries( action->menu() );
1252
1253 if( !p_object )
1254 {
1255 if( action )
1256 action->setEnabled( false );
1257 return;
1258 }
1259
1260 /* Check the type of the object variable */
1261 /* This HACK is needed so that we have:
1262 * - a radio button for audio/video tracks instread of a checkbox, and;
1263 * - an always enabled bookmark menu (even if there are no bookmarks)
1264 **/
1265 if( !strcmp( psz_var, "audio-es" )
1266 || !strcmp( psz_var, "video-es" )
1267 || !strcmp( psz_var, "bookmark" ) )
1268 i_type = VLC_VAR_INTEGER | VLC_VAR_HASCHOICE;
1269 else
1270 i_type = var_Type( p_object, psz_var );
1271
1272 switch( i_type & VLC_VAR_TYPE )
1273 {
1274 case VLC_VAR_VOID:
1275 case VLC_VAR_BOOL:
1276 case VLC_VAR_STRING:
1277 case VLC_VAR_INTEGER:
1278 case VLC_VAR_FLOAT:
1279 break;
1280 default:
1281 /* Variable doesn't exist or isn't handled */
1282 if( action )
1283 action->setEnabled( false );
1284 return;
1285 }
1286
1287 /* Make sure we want to display the variable */
1288 if( menu->isEmpty() && IsMenuEmpty( psz_var, p_object ) )
1289 {
1290 if( action )
1291 action->setEnabled( false );
1292 return;
1293 }
1294
1295 /* Get the descriptive name of the variable */
1296 int i_ret = var_Change( p_object, psz_var, VLC_VAR_GETTEXT, &text, NULL );
1297 if( i_ret != VLC_SUCCESS )
1298 {
1299 text.psz_string = NULL;
1300 }
1301
1302 if( !action )
1303 {
1304 action = new QAction( TEXT_OR_VAR, menu );
1305 menu->addAction( action );
1306 action->setData( psz_var );
1307 }
1308
1309 /* Some specific stuff */
1310 bool forceDisabled = false;
1311 if( !strcmp( psz_var, "spu-es" ) )
1312 {
1313 vout_thread_t *p_vout = THEMIM->getVout();
1314 forceDisabled = ( p_vout == NULL );
1315 if( p_vout )
1316 vlc_object_release( p_vout );
1317 }
1318
1319 if( i_type & VLC_VAR_HASCHOICE )
1320 {
1321 /* Append choices menu */
1322 if( b_submenu )
1323 {
1324 QMenu *submenu;
1325 submenu = action->menu();
1326 if( !submenu )
1327 {
1328 submenu = new QMenu( menu );
1329 action->setMenu( submenu );
1330 }
1331
1332 action->setEnabled(
1333 CreateChoicesMenu( submenu, psz_var, p_object ) == 0 );
1334 if( forceDisabled )
1335 action->setEnabled( false );
1336 }
1337 else
1338 {
1339 action->setEnabled(
1340 CreateChoicesMenu( menu, psz_var, p_object ) == 0 );
1341 }
1342 FREENULL( text.psz_string );
1343 return;
1344 }
1345
1346 switch( i_type & VLC_VAR_TYPE )
1347 {
1348 case VLC_VAR_VOID:
1349 val.i_int = 0; // Prevent the copy of an uninitialized value
1350 CreateAndConnect( menu, psz_var, TEXT_OR_VAR, "", ITEM_NORMAL,
1351 p_object, val, i_type );
1352 break;
1353
1354 case VLC_VAR_BOOL:
1355 var_Get( p_object, psz_var, &val );
1356 val.b_bool = !val.b_bool;
1357 CreateAndConnect( menu, psz_var, TEXT_OR_VAR, "", ITEM_CHECK,
1358 p_object, val, i_type, !val.b_bool );
1359 break;
1360 }
1361 FREENULL( text.psz_string );
1362 }
1363
1364 #undef TEXT_OR_VAR
1365
1366 /** HACK for the navigation submenu:
1367 * "title %2u" variables take the value 0 if not set
1368 */
1369 static bool CheckTitle( vlc_object_t *p_object, const char *psz_var )
1370 {
1371 unsigned i_title = 0;
1372 if( sscanf( psz_var, "title %2u", &i_title ) <= 0 )
1373 return true;
1374
1375 unsigned i_current_title = var_GetInteger( p_object, "title" );
1376 return ( i_title == i_current_title );
1377 }
1378
1379
1380 int VLCMenuBar::CreateChoicesMenu( QMenu *submenu, const char *psz_var,
1381 vlc_object_t *p_object )
1382 {
1383 vlc_value_t val, val_list, text_list;
1384 int i_type, i;
1385
1386 /* Check the type of the object variable */
1387 i_type = var_Type( p_object, psz_var );
1388
1389 /* Make sure we want to display the variable */
1390 if( submenu->isEmpty() && IsMenuEmpty( psz_var, p_object ) )
1391 return VLC_EGENERIC;
1392
1393 switch( i_type & VLC_VAR_TYPE )
1394 {
1395 case VLC_VAR_VOID:
1396 case VLC_VAR_BOOL:
1397 case VLC_VAR_STRING:
1398 case VLC_VAR_INTEGER:
1399 case VLC_VAR_FLOAT:
1400 break;
1401 default:
1402 /* Variable doesn't exist or isn't handled */
1403 return VLC_EGENERIC;
1404 }
1405
1406 if( var_Change( p_object, psz_var, VLC_VAR_GETCHOICES,
1407 &val_list, &text_list ) < 0 )
1408 {
1409 return VLC_EGENERIC;
1410 }
1411
1412 #define CURVAL val_list.p_list->p_values[i]
1413 #define CURTEXT text_list.p_list->p_values[i].psz_string
1414 #define RADIO_OR_COMMAND ( i_type & ( VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE ) ) ? ITEM_RADIO : ITEM_NORMAL
1415
1416 for( i = 0; i < val_list.p_list->i_count; i++ )
1417 {
1418 vlc_value_t another_val;
1419 QString menutext;
1420
1421 switch( i_type & VLC_VAR_TYPE )
1422 {
1423 case VLC_VAR_STRING:
1424 var_Get( p_object, psz_var, &val );
1425 another_val.psz_string = strdup( CURVAL.psz_string );
1426 menutext = qfue( CURTEXT ? CURTEXT : another_val.psz_string );
1427 CreateAndConnect( submenu, psz_var, menutext, "", RADIO_OR_COMMAND,
1428 p_object, another_val, i_type,
1429 val.psz_string && !strcmp( val.psz_string, CURVAL.psz_string ) );
1430
1431 free( val.psz_string );
1432 break;
1433
1434 case VLC_VAR_INTEGER:
1435 var_Get( p_object, psz_var, &val );
1436 if( CURTEXT ) menutext = qfue( CURTEXT );
1437 else menutext = QString::number( CURVAL.i_int );
1438 CreateAndConnect( submenu, psz_var, menutext, "", RADIO_OR_COMMAND,
1439 p_object, CURVAL, i_type,
1440 ( CURVAL.i_int == val.i_int )
1441 && CheckTitle( p_object, psz_var ) );
1442 break;
1443
1444 case VLC_VAR_FLOAT:
1445 var_Get( p_object, psz_var, &val );
1446 if( CURTEXT ) menutext = qfue( CURTEXT );
1447 else menutext.sprintf( "%.2f", CURVAL.f_float );
1448 CreateAndConnect( submenu, psz_var, menutext, "", RADIO_OR_COMMAND,
1449 p_object, CURVAL, i_type,
1450 CURVAL.f_float == val.f_float );
1451 break;
1452
1453 default:
1454 break;
1455 }
1456 }
1457 currentGroup = NULL;
1458
1459 /* clean up everything */
1460 var_FreeList( &val_list, &text_list );
1461
1462 #undef RADIO_OR_COMMAND
1463 #undef CURVAL
1464 #undef CURTEXT
1465
1466 return submenu->isEmpty() ? VLC_EGENERIC : VLC_SUCCESS;
1467 }
1468
1469 void VLCMenuBar::CreateAndConnect( QMenu *menu, const char *psz_var,
1470 const QString& text, const QString& help,
1471 int i_item_type, vlc_object_t *p_obj,
1472 vlc_value_t val, int i_val_type,
1473 bool checked )
1474 {
1475 QAction *action = FindActionWithVar( menu, psz_var );
1476
1477 bool b_new = false;
1478 if( !action )
1479 {
1480 action = new QAction( text, menu );
1481 menu->addAction( action );
1482 b_new = true;
1483 }
1484
1485 action->setToolTip( help );
1486 action->setEnabled( p_obj != NULL );
1487
1488 if( i_item_type == ITEM_CHECK )
1489 {
1490 action->setCheckable( true );
1491 }
1492 else if( i_item_type == ITEM_RADIO )
1493 {
1494 action->setCheckable( true );
1495 if( !currentGroup )
1496 currentGroup = new QActionGroup( menu );
1497 currentGroup->addAction( action );
1498 }
1499
1500 action->setChecked( checked );
1501
1502 MenuItemData *itemData = action->findChild<MenuItemData*>( QString() );
1503 delete itemData;
1504 itemData = new MenuItemData( action, p_obj, i_val_type, val, psz_var );
1505
1506 /* remove previous signal-slot connection(s) if any */
1507 action->disconnect( );
1508
1509 CONNECT( action, triggered(), THEDP->menusMapper, map() );
1510 THEDP->menusMapper->setMapping( action, itemData );
1511
1512 if( b_new )
1513 menu->addAction( action );
1514 }
1515
1516 void VLCMenuBar::DoAction( QObject *data )
1517 {
1518 MenuItemData *itemData = qobject_cast<MenuItemData *>( data );
1519 vlc_object_t *p_object = itemData->p_obj;
1520 if( p_object == NULL ) return;
1521 const char *var = itemData->psz_var;
1522 vlc_value_t val = itemData->val;
1523
1524 if ((var_Type( p_object, var) & VLC_VAR_CLASS) == VLC_VAR_VOID)
1525 var_TriggerCallback( p_object, var );
1526 else
1527 var_Set( p_object, var, val );
1528
1529 if( !strcmp( var, "fullscreen" )
1530 || !strcmp( var, "video-on-top" )
1531 || !strcmp( var, "video-wallpaper" ) ) /* FIXME: reverse abstraction */
1532 { /* Apply playlist variables to current existing vout too */
1533 input_thread_t *input = playlist_CurrentInput((playlist_t *)p_object);
1534 if( input != NULL )
1535 {
1536 vout_thread_t *vout = input_GetVout( input );
1537 vlc_object_release( input );
1538 if( vout != NULL )
1539 {
1540 var_Set( vout, var, val ); /* never void class */
1541 vlc_object_release( vout );
1542 }
1543 }
1544 }
1545 }
1546
1547 void VLCMenuBar::updateAudioDevice( intf_thread_t * p_intf, audio_output_t *p_aout, QMenu *current )
1548 {
1549 char **ids, **names;
1550 char *selected;
1551
1552 if( !p_aout || !current )
1553 return;
1554
1555 current->clear();
1556 int i_result = aout_DevicesList( p_aout, &ids, &names);
1557 if( i_result < 0 )
1558 return;
1559
1560 selected = aout_DeviceGet( p_aout );
1561
1562 QActionGroup *actionGroup = new QActionGroup(current);
1563 QAction *action;
1564
1565 for( int i = 0; i < i_result; i++ )
1566 {
1567 action = new QAction( qfue( names[i] ), actionGroup );
1568 action->setData( ids[i] );
1569 action->setCheckable( true );
1570 if( (selected && !strcmp( ids[i], selected ) ) ||
1571 (selected == NULL && ids[i] && ids[i][0] == '\0' ) )
1572 action->setChecked( true );
1573 actionGroup->addAction( action );
1574 current->addAction( action );
1575 CONNECT(action, triggered(), THEMIM->menusAudioMapper, map());
1576 THEMIM->menusAudioMapper->setMapping(action, ids[i]);
1577 free( ids[i] );
1578 free( names[i] );
1579 }
1580 free( ids );
1581 free( names );
1582 free( selected );
1583 }
1584
1585 void VLCMenuBar::updateRecents( intf_thread_t *p_intf )
1586 {
1587 if( recentsMenu )
1588 {
1589 QAction* action;
1590 RecentsMRL* rmrl = RecentsMRL::getInstance( p_intf );
1591 QStringList l = rmrl->recentList();
1592
1593 recentsMenu->clear();
1594
1595 if( !l.count() )
1596 {
1597 recentsMenu->setEnabled( false );
1598 }
1599 else
1600 {
1601 for( int i = 0; i < __MIN( l.count(), 10) ; ++i )
1602 {
1603 QString mrl = l.at( i );
1604 char *psz = vlc_uri_decode_duplicate( qtu( mrl ) );
1605 QString text = qfu( psz );
1606
1607 text.replace("&", "&&");
1608 #ifdef _WIN32
1609 # define FILE_SCHEME "file:///"
1610 #else
1611 # define FILE_SCHEME "file://"
1612 #endif
1613 if ( text.startsWith( FILE_SCHEME ) )
1614 text.remove( 0, strlen( FILE_SCHEME ) );
1615 #undef FILE_SCHEME
1616
1617 free( psz );
1618 action = recentsMenu->addAction(
1619 QString( i < 9 ? "&%1: ": "%1: " ).arg( i + 1 ) +
1620 QApplication::fontMetrics().elidedText( text,
1621 Qt::ElideLeft, 400 ),
1622 rmrl->signalMapper, SLOT( map() ),
1623 i < 9 ? QString( "Ctrl+%1" ).arg( i + 1 ) : "" );
1624 rmrl->signalMapper->setMapping( action, l.at( i ) );
1625 }
1626
1627 recentsMenu->addSeparator();
1628 recentsMenu->addAction( qtr("&Clear"), rmrl, SLOT( clear() ) );
1629 recentsMenu->setEnabled( true );
1630 }
1631 }
1632 }
1633
1634 QMenu *VLCMenuBar::RendererMenu(intf_thread_t *p_intf, QMenu *menu )
1635 {
1636 QMenu *submenu = new QMenu( qtr("&Renderer"), menu );
1637
1638 rendererGroup = new QActionGroup(submenu);
1639
1640 QAction *action = new QAction( qtr("<Local>"), submenu );
1641 action->setCheckable(true);
1642 submenu->addAction( action );
1643 rendererGroup->addAction(action);
1644
1645 char *psz_renderer = var_InheritString( THEPL, "sout" );
1646 if ( psz_renderer == NULL )
1647 action->setChecked( true );
1648 else
1649 free( psz_renderer );
1650
1651 submenu->addSeparator();
1652
1653 action = new QAction( qtr("Scan"), submenu );
1654 action->setCheckable(true);
1655 submenu->addAction( action );
1656
1657 CONNECT( action, triggered(bool), ActionsManager::getInstance( p_intf ), ScanRendererAction( bool ) );
1658 CONNECT( rendererGroup, triggered(QAction*), ActionsManager::getInstance( p_intf ), RendererSelected( QAction* ) );
1659
1660 return submenu;
1661 }
VLC Development tree mirror