1 /*****************************************************************************
2 * actions_manager.cpp : Controller for the main interface
3 ****************************************************************************
4 * Copyright © 2009-2014 VideoLAN and VLC authors
5 * $Id: efa3044df50d487f158003d9993be43aa1a6a2ad $
6 *
7 * Authors: Jean-Baptiste Kempf <jb@videolan.org>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * ( at your option ) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #include <vlc_vout.h>
29 #include <vlc_actions.h>
30 #include <vlc_renderer_discovery.h>
31
32 #include "actions_manager.hpp"
33
34 #include "dialogs_provider.hpp" /* Opening Dialogs */
35 #include "input_manager.hpp" /* THEMIM */
36 #include "main_interface.hpp" /* Show playlist */
37 #include "components/controller.hpp" /* Toggle FSC controller width */
38 #include "components/extended_panels.hpp"
39 #include "menus.hpp"
40
ActionsManager(intf_thread_t * _p_i)41 ActionsManager::ActionsManager( intf_thread_t * _p_i )
42 : p_intf( _p_i )
43 , m_scanning( false )
44 {
45 CONNECT( this, rendererItemAdded( vlc_renderer_item_t* ),
46 this, onRendererItemAdded( vlc_renderer_item_t* ) );
47 CONNECT( this, rendererItemRemoved( vlc_renderer_item_t* ),
48 this, onRendererItemRemoved( vlc_renderer_item_t* ) );
49 m_stop_scan_timer.setSingleShot( true );
50 CONNECT( &m_stop_scan_timer, timeout(), this, StopRendererScan() );
51 }
52
~ActionsManager()53 ActionsManager::~ActionsManager()
54 {
55 StopRendererScan();
56 /* reset the list of renderers */
57 foreach (QAction* action, VLCMenuBar::rendererMenu->actions())
58 {
59 QVariant data = action->data();
60 if (!data.canConvert<QVariantHash>())
61 continue;
62 VLCMenuBar::rendererMenu->removeAction(action);
63 VLCMenuBar::rendererGroup->removeAction(action);
64 }
65 }
66
doAction(int id_action)67 void ActionsManager::doAction( int id_action )
68 {
69 switch( id_action )
70 {
71 case PLAY_ACTION:
72 play(); break;
73 case STOP_ACTION:
74 THEMIM->stop(); break;
75 case OPEN_ACTION:
76 THEDP->openDialog(); break;
77 case PREVIOUS_ACTION:
78 THEMIM->prev(); break;
79 case NEXT_ACTION:
80 THEMIM->next(); break;
81 case SLOWER_ACTION:
82 THEMIM->getIM()->slower(); break;
83 case FASTER_ACTION:
84 THEMIM->getIM()->faster(); break;
85 case FULLSCREEN_ACTION:
86 fullscreen(); break;
87 case EXTENDED_ACTION:
88 THEDP->extendedDialog(); break;
89 case PLAYLIST_ACTION:
90 playlist(); break;
91 case SNAPSHOT_ACTION:
92 snapshot(); break;
93 case RECORD_ACTION:
94 record(); break;
95 case FRAME_ACTION:
96 frame(); break;
97 case ATOB_ACTION:
98 THEMIM->getIM()->setAtoB(); break;
99 case REVERSE_ACTION:
100 THEMIM->getIM()->reverse(); break;
101 case SKIP_BACK_ACTION:
102 skipBackward();
103 break;
104 case SKIP_FW_ACTION:
105 skipForward();
106 break;
107 case QUIT_ACTION:
108 THEDP->quit(); break;
109 case RANDOM_ACTION:
110 THEMIM->toggleRandom(); break;
111 case INFO_ACTION:
112 THEDP->mediaInfoDialog(); break;
113 case OPEN_SUB_ACTION:
114 THEDP->loadSubtitlesFile(); break;
115 case FULLWIDTH_ACTION:
116 if( p_intf->p_sys->p_mi )
117 p_intf->p_sys->p_mi->getFullscreenControllerWidget()->toggleFullwidth();
118 break;
119 default:
120 msg_Warn( p_intf, "Action not supported: %i", id_action );
121 break;
122 }
123 }
124
play()125 void ActionsManager::play()
126 {
127 if( THEPL->current.i_size == 0 && THEPL->items.i_size == 0 )
128 {
129 /* The playlist is empty, open a file requester */
130 THEDP->openFileDialog();
131 return;
132 }
133 THEMIM->togglePlayPause();
134 }
135
136 /**
137 * TODO
138 * This functions toggle the fullscreen mode
139 * If there is no video, it should first activate Visualisations...
140 * This has also to be fixed in enableVideo()
141 */
fullscreen()142 void ActionsManager::fullscreen()
143 {
144 bool fs = var_ToggleBool( THEPL, "fullscreen" );
145 vout_thread_t *p_vout = THEMIM->getVout();
146 if( p_vout)
147 {
148 var_SetBool( p_vout, "fullscreen", fs );
149 vlc_object_release( p_vout );
150 }
151 }
152
snapshot()153 void ActionsManager::snapshot()
154 {
155 vout_thread_t *p_vout = THEMIM->getVout();
156 if( p_vout )
157 {
158 var_TriggerCallback( p_vout, "video-snapshot" );
159 vlc_object_release( p_vout );
160 }
161 }
162
playlist()163 void ActionsManager::playlist()
164 {
165 if( p_intf->p_sys->p_mi )
166 p_intf->p_sys->p_mi->togglePlaylist();
167 }
168
record()169 void ActionsManager::record()
170 {
171 input_thread_t *p_input = THEMIM->getInput();
172 if( p_input )
173 {
174 /* This method won't work fine if the stream can't be cut anywhere */
175 var_ToggleBool( p_input, "record" );
176 #if 0
177 else
178 {
179 /* 'record' access-filter is not loaded, we open Save dialog */
180 input_item_t *p_item = input_GetItem( p_input );
181 if( !p_item )
182 return;
183
184 char *psz = input_item_GetURI( p_item );
185 if( psz )
186 THEDP->streamingDialog( NULL, qfu(psz), true );
187 }
188 #endif
189 }
190 }
191
frame()192 void ActionsManager::frame()
193 {
194 input_thread_t *p_input = THEMIM->getInput();
195 if( p_input )
196 var_TriggerCallback( p_input, "frame-next" );
197 }
198
toggleMuteAudio()199 void ActionsManager::toggleMuteAudio()
200 {
201 playlist_MuteToggle( THEPL );
202 }
203
AudioUp()204 void ActionsManager::AudioUp()
205 {
206 playlist_VolumeUp( THEPL, 1, NULL );
207 }
208
AudioDown()209 void ActionsManager::AudioDown()
210 {
211 playlist_VolumeDown( THEPL, 1, NULL );
212 }
213
skipForward()214 void ActionsManager::skipForward()
215 {
216 input_thread_t *p_input = THEMIM->getInput();
217 if( p_input )
218 THEMIM->getIM()->jumpFwd();
219 }
220
skipBackward()221 void ActionsManager::skipBackward()
222 {
223 input_thread_t *p_input = THEMIM->getInput();
224 if( p_input )
225 THEMIM->getIM()->jumpBwd();
226 }
227
compareRenderers(const QVariant & obj,vlc_renderer_item_t * p_item)228 vlc_renderer_item_t* ActionsManager::compareRenderers( const QVariant &obj, vlc_renderer_item_t* p_item )
229 {
230 if (!obj.canConvert<QVariantHash>())
231 return NULL;
232 QVariantHash qvh = obj.value<QVariantHash>();
233 if (!qvh.contains( "sout" ))
234 return NULL;
235 vlc_renderer_item_t* p_existing =
236 reinterpret_cast<vlc_renderer_item_t*>( qvh["sout"].value<void*>() );
237 if ( !strcasecmp(vlc_renderer_item_sout( p_existing ),
238 vlc_renderer_item_sout( p_item ) ) )
239 return p_existing;
240 return NULL;
241 }
242
onRendererItemAdded(vlc_renderer_item_t * p_item)243 void ActionsManager::onRendererItemAdded(vlc_renderer_item_t* p_item)
244 {
245 QAction *firstSeparator = NULL;
246
247 foreach (QAction* action, VLCMenuBar::rendererMenu->actions())
248 {
249 if (action->isSeparator())
250 {
251 firstSeparator = action;
252 break;
253 }
254 if (compareRenderers( action->data(), p_item ))
255 {
256 vlc_renderer_item_release( p_item );
257 return; /* we already have this item */
258 }
259 }
260
261 QAction *action = new QAction( vlc_renderer_item_flags(p_item) & VLC_RENDERER_CAN_VIDEO ? QIcon( ":/sidebar/movie.svg" ) : QIcon( ":/sidebar/music.svg" ),
262 vlc_renderer_item_name(p_item), VLCMenuBar::rendererMenu );
263 action->setCheckable(true);
264
265 QVariantHash data;
266 data.insert( "sout", QVariant::fromValue( reinterpret_cast<void*>( p_item ) ) );
267 action->setData( data );
268 if (firstSeparator != NULL)
269 {
270 VLCMenuBar::rendererMenu->insertAction( firstSeparator, action );
271 VLCMenuBar::rendererGroup->addAction(action);
272 }
273 else
274 {
275 vlc_renderer_item_release( p_item );
276 delete action;
277 }
278 }
279
onRendererItemRemoved(vlc_renderer_item_t * p_item)280 void ActionsManager::onRendererItemRemoved( vlc_renderer_item_t* p_item )
281 {
282 foreach (QAction* action, VLCMenuBar::rendererMenu->actions())
283 {
284 if (action->isSeparator())
285 continue;
286 vlc_renderer_item_t *p_existing = compareRenderers( action->data(), p_item );
287 if (p_existing)
288 {
289 VLCMenuBar::rendererMenu->removeAction( action );
290 VLCMenuBar::rendererGroup->removeAction( action );
291 vlc_renderer_item_release( p_existing );
292 break;
293 }
294 }
295 // Always release the item as we acquired it before emiting the signal
296 vlc_renderer_item_release( p_item );
297 }
298
renderer_event_item_added(vlc_renderer_discovery_t * p_rd,vlc_renderer_item_t * p_item)299 void ActionsManager::renderer_event_item_added( vlc_renderer_discovery_t* p_rd,
300 vlc_renderer_item_t *p_item )
301 {
302 ActionsManager *self = reinterpret_cast<ActionsManager*>( p_rd->owner.sys );
303 vlc_renderer_item_hold( p_item );
304 self->emit rendererItemAdded( p_item );
305 }
306
renderer_event_item_removed(vlc_renderer_discovery_t * p_rd,vlc_renderer_item_t * p_item)307 void ActionsManager::renderer_event_item_removed( vlc_renderer_discovery_t *p_rd,
308 vlc_renderer_item_t *p_item )
309 {
310 ActionsManager *self = reinterpret_cast<ActionsManager*>( p_rd->owner.sys );
311 vlc_renderer_item_hold( p_item );
312 self->emit rendererItemRemoved( p_item );
313 }
314
StartRendererScan()315 void ActionsManager::StartRendererScan()
316 {
317 m_stop_scan_timer.stop();
318 if( m_scanning )
319 return;
320
321 /* SD subnodes */
322 char **ppsz_longnames;
323 char **ppsz_names;
324 if( vlc_rd_get_names( THEPL, &ppsz_names, &ppsz_longnames ) != VLC_SUCCESS )
325 return;
326
327 struct vlc_renderer_discovery_owner owner =
328 {
329 this,
330 renderer_event_item_added,
331 renderer_event_item_removed,
332 };
333
334 char **ppsz_name = ppsz_names, **ppsz_longname = ppsz_longnames;
335 for( ; *ppsz_name; ppsz_name++, ppsz_longname++ )
336 {
337 msg_Dbg( p_intf, "starting renderer discovery service %s", *ppsz_longname );
338 vlc_renderer_discovery_t* p_rd = vlc_rd_new( VLC_OBJECT(p_intf), *ppsz_name, &owner );
339 if( p_rd != NULL )
340 m_rds.push_back( p_rd );
341 free( *ppsz_name );
342 free( *ppsz_longname );
343 }
344 free( ppsz_names );
345 free( ppsz_longnames );
346 m_scanning = true;
347 }
348
RendererMenuCountdown()349 void ActionsManager::RendererMenuCountdown()
350 {
351 m_stop_scan_timer.start( 20000 );
352 }
353
StopRendererScan()354 void ActionsManager::StopRendererScan()
355 {
356 foreach ( vlc_renderer_discovery_t* p_rd, m_rds )
357 vlc_rd_release( p_rd );
358 m_rds.clear();
359 m_scanning = false;
360 }
361
RendererSelected(QAction * selected)362 void ActionsManager::RendererSelected( QAction *selected )
363 {
364 QVariant data = selected->data();
365 vlc_renderer_item_t *p_item = NULL;
366 if (data.canConvert<QVariantHash>())
367 {
368 QVariantHash hash = data.value<QVariantHash>();
369 if ( hash.contains( "sout" ) )
370 p_item = reinterpret_cast<vlc_renderer_item_t*>(
371 hash["sout"].value<void*>() );
372 }
373 // If we failed to convert the action data to a vlc_renderer_item_t,
374 // assume the selected item was invalid, or most likely that "Local" was selected
375 playlist_SetRenderer( THEPL, p_item );
376 }
377
378