modules/gui/qt/actions_manager.cpp

   1 /*****************************************************************************
   2  * actions_manager.cpp : Controller for the main interface
   3  ****************************************************************************
   4  * Copyright © 2009-2014 VideoLAN and VLC authors
   5  * $Id$
   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
  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
  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
  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
 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  */
 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
 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
 163 void ActionsManager::playlist()
 164 {
 165     if( p_intf->p_sys->p_mi )
 166         p_intf->p_sys->p_mi->togglePlaylist();
 167 }
 168
 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
 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
 199 void ActionsManager::toggleMuteAudio()
 200 {
 201     playlist_MuteToggle( THEPL );
 202 }
 203
 204 void ActionsManager::AudioUp()
 205 {
 206     playlist_VolumeUp( THEPL, 1, NULL );
 207 }
 208
 209 void ActionsManager::AudioDown()
 210 {
 211     playlist_VolumeDown( THEPL, 1, NULL );
 212 }
 213
 214 void ActionsManager::skipForward()
 215 {
 216     input_thread_t *p_input = THEMIM->getInput();
 217     if( p_input )
 218         THEMIM->getIM()->jumpFwd();
 219 }
 220
 221 void ActionsManager::skipBackward()
 222 {
 223     input_thread_t *p_input = THEMIM->getInput();
 224     if( p_input )
 225         THEMIM->getIM()->jumpBwd();
 226 }
 227
 228 vlc_renderer_item_t* ActionsManager::getMatchingRenderer( 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
 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 (getMatchingRenderer( 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
 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 = getMatchingRenderer( 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
 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
 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
 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
 349 void ActionsManager::RendererMenuCountdown()
 350 {
 351     m_stop_scan_timer.start( 20000 );
 352 }
 353
 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
 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