X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fgui%2Fqt4%2Fmain_interface.cpp;h=89d4f62f6a66e5b3669fcbe60be9559e4b78a416;hb=f4c037efd2d3cde44daa1a58c7042fecc32b2177;hp=207916e417dd30b0450d738aaf3be2513d01d392;hpb=ff812d67b245618b8dd7f896e206909f16a6e565;p=vlc diff --git a/modules/gui/qt4/main_interface.cpp b/modules/gui/qt4/main_interface.cpp index 207916e417..89d4f62f6a 100644 --- a/modules/gui/qt4/main_interface.cpp +++ b/modules/gui/qt4/main_interface.cpp @@ -1,7 +1,7 @@ /***************************************************************************** * main_interface.cpp : Main interface **************************************************************************** - * Copyright (C) 2006-2010 VideoLAN and AUTHORS + * Copyright (C) 2006-2011 VideoLAN and AUTHORS * $Id$ * * Authors: Clément Stenac @@ -68,6 +68,11 @@ static int PopupMenuCB( vlc_object_t *p_this, const char *psz_variable, vlc_value_t old_val, vlc_value_t new_val, void *param ); static int IntfShowCB( vlc_object_t *p_this, const char *psz_variable, vlc_value_t old_val, vlc_value_t new_val, void *param ); +static int IntfBossCB( vlc_object_t *p_this, const char *psz_variable, + vlc_value_t old_val, vlc_value_t new_val, void *param ); +static int IntfRaiseMainCB( vlc_object_t *p_this, const char *psz_variable, + vlc_value_t old_val, vlc_value_t new_val, + void *param ); MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf ) { @@ -76,9 +81,7 @@ MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf ) videoWidget = NULL; playlistWidget = NULL; stackCentralOldWidget= NULL; -#ifndef HAVE_MAEMO sysTray = NULL; -#endif fullscreenControls = NULL; cryptedLabel = NULL; controls = NULL; @@ -87,6 +90,8 @@ MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf ) b_hideAfterCreation = false; // --qt-start-minimized playlistVisible = false; input_name = ""; + b_interfaceFullScreen= false; + b_hasPausedWhenMinimized = false; /* Ask for Privacy */ @@ -102,6 +107,10 @@ MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf ) setWindowRole( "vlc-main" ); setWindowIcon( QApplication::windowIcon() ); setWindowOpacity( var_InheritFloat( p_intf, "qt-opacity" ) ); +#ifdef Q_WS_MAC + setAttribute( Qt::WA_MacBrushedMetal ); +#endif + setAttribute( Qt::WA_QuitOnClose, false ); /* Is video in embedded in the UI or not */ b_videoEmbedded = var_InheritBool( p_intf, "embedded-video" ); @@ -110,42 +119,45 @@ MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf ) b_autoresize = var_InheritBool( p_intf, "qt-video-autoresize" ); /* Are we in the enhanced always-video mode or not ? */ - i_visualmode = var_InheritInteger( p_intf, "qt-minimal-view" ); + b_minimalView = var_InheritBool( p_intf, "qt-minimal-view" ); /* Do we want anoying popups or not */ b_notificationEnabled = var_InheritBool( p_intf, "qt-notification" ); + /* */ + b_pauseOnMinimize = var_InheritBool( p_intf, "qt-pause-minimized" ); + /* Set the other interface settings */ settings = getSettings(); - settings->beginGroup( "MainWindow" ); - /* */ - b_plDocked = getSettings()->value( "pl-dock-status", true ).toBool(); +#ifdef WIN32 + /* Volume keys */ + p_intf->p_sys->disable_volume_keys = var_InheritBool( p_intf, "qt-disable-volume-keys" ); +#endif - settings->endGroup( ); + /* */ + b_plDocked = getSettings()->value( "MainWindow/pl-dock-status", true ).toBool(); - /************** - * Status Bar * - **************/ - createStatusBar(); /************************** * UI and Widgets design **************************/ setVLCWindowsTitle(); - createMainWidget( settings ); /************ * Menu Bar * ************/ - QVLCMenu::createMenuBar( this, p_intf ); + VLCMenuBar::createMenuBar( this, p_intf ); CONNECT( THEMIM->getIM(), voutListChanged( vout_thread_t **, int ), this, destroyPopupMenu() ); - /********************************* - * Create the Systray Management * - *********************************/ - initSystray(); + createMainWidget( settings ); + + /************** + * Status Bar * + **************/ + createStatusBar(); + setStatusBarVisibility( getSettings()->value( "MainWindow/status-bar-visible", false ).toBool() ); /******************** * Input Manager * @@ -158,9 +170,15 @@ MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf ) taskbar_wmsg = RegisterWindowMessage("TaskbarButtonCreated"); #endif - /************************************************************ - * Connect the input manager to the GUI elements it manages * - ************************************************************/ + /********************************* + * Create the Systray Management * + *********************************/ + initSystray(); + + /************************************************************* + * Connect the input manager to the GUI elements it manages * + * Beware initSystray did some connects on input manager too * + *************************************************************/ /** * Connects on nameChanged() * Those connects are different because options can impeach them to trigger. @@ -168,89 +186,72 @@ MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf ) /* Main Interface statusbar */ CONNECT( THEMIM->getIM(), nameChanged( const QString& ), this, setName( const QString& ) ); - /* and systray */ -#ifndef HAVE_MAEMO - if( sysTray ) - { - CONNECT( THEMIM->getIM(), nameChanged( const QString& ), - this, updateSystrayTooltipName( const QString& ) ); - } -#endif /* and title of the Main Interface*/ if( var_InheritBool( p_intf, "qt-name-in-title" ) ) { CONNECT( THEMIM->getIM(), nameChanged( const QString& ), this, setVLCWindowsTitle( const QString& ) ); } - - /** - * CONNECTS on PLAY_STATUS - **/ - /* Status on the systray */ -#ifndef HAVE_MAEMO - if( sysTray ) - { - CONNECT( THEMIM->getIM(), statusChanged( int ), - this, updateSystrayTooltipStatus( int ) ); - } -#endif - /* END CONNECTS ON IM */ /* VideoWidget connects for asynchronous calls */ + b_videoFullScreen = false; connect( this, SIGNAL(askGetVideo(WId*,int*,int*,unsigned*,unsigned *)), this, SLOT(getVideoSlot(WId*,int*,int*,unsigned*,unsigned*)), Qt::BlockingQueuedConnection ); connect( this, SIGNAL(askReleaseVideo( void )), this, SLOT(releaseVideoSlot( void )), Qt::BlockingQueuedConnection ); + CONNECT( this, askVideoOnTop(bool), this, setVideoOnTop(bool)); if( videoWidget ) { if( b_autoresize ) { CONNECT( this, askVideoToResize( unsigned int, unsigned int ), - videoWidget, SetSizing( unsigned int, unsigned int ) ); + this, setVideoSize( unsigned int, unsigned int ) ); CONNECT( videoWidget, sizeChanged( int, int ), this, resizeStack( int, int ) ); } CONNECT( this, askVideoSetFullScreen( bool ), - videoWidget, SetFullScreen( bool ) ); - CONNECT( videoWidget, keyPressed( QKeyEvent * ), - this, handleKeyPress( QKeyEvent * ) ); + this, setVideoFullScreen( bool ) ); } CONNECT( THEDP, toolBarConfUpdated(), this, recreateToolbars() ); + CONNECT( this, askToQuit(), THEDP, quit() ); + + CONNECT( this, askBoss(), this, setBoss() ); + CONNECT( this, askRaise(), this, setRaise() ); + /** END of CONNECTS**/ /************ * Callbacks ************/ - var_AddCallback( p_intf->p_libvlc, "intf-show", IntfShowCB, p_intf ); + var_AddCallback( p_intf->p_libvlc, "intf-toggle-fscontrol", IntfShowCB, p_intf ); + var_AddCallback( p_intf->p_libvlc, "intf-boss", IntfBossCB, p_intf ); + var_AddCallback( p_intf->p_libvlc, "intf-show", IntfRaiseMainCB, p_intf ); /* Register callback for the intf-popupmenu variable */ var_AddCallback( p_intf->p_libvlc, "intf-popupmenu", PopupMenuCB, p_intf ); - /**** FINAL SIZING and placement of interface */ - settings->beginGroup( "MainWindow" ); - QVLCTools::restoreWidgetPosition( settings, this, QSize(400, 100) ); - /* Playlist */ - int i_plVis = settings->value( "playlist-visible", false ).toBool(); - settings->endGroup(); + /* Final Sizing, restoration and placement of the interface */ + if( settings->value( "MainWindow/playlist-visible", false ).toBool() ) + togglePlaylist(); + + QVLCTools::restoreWidgetPosition( settings, this, QSize(600, 420) ); - if( i_plVis ) togglePlaylist(); + b_interfaceFullScreen = isFullScreen(); - /* Final sizing and showing */ setVisible( !b_hideAfterCreation ); - setMinimumWidth( __MAX( controls->sizeHint().width(), - menuBar()->sizeHint().width() ) + 30 ); + computeMinimumSize(); /* Switch to minimal view if needed, must be called after the show() */ - if( i_visualmode ) + if( b_minimalView ) toggleMinimalView( true ); } @@ -260,6 +261,9 @@ MainInterface::~MainInterface() if( stackCentralOldWidget == videoWidget ) showTab( bgWidget ); + if( videoWidget ) + releaseVideoSlot(); + #ifdef WIN32 if( himl ) ImageList_Destroy( himl ); @@ -278,30 +282,25 @@ MainInterface::~MainInterface() delete fullscreenControls; /* Save states */ - settings->beginGroup( "MainWindow" ); + settings->beginGroup("MainWindow"); settings->setValue( "pl-dock-status", b_plDocked ); /* Save playlist state */ if( playlistWidget ) - { - settings->setValue( "playlist-visible", - isPlDocked() ? - playlistVisible : - playlistWidget->isVisible() /* FIXME */ ); - } + settings->setValue( "playlist-visible", playlistVisible ); settings->setValue( "adv-controls", getControlsVisibilityStatus() & CONTROLS_ADVANCED ); + settings->setValue( "status-bar-visible", b_statusbarVisible ); /* Save the stackCentralW sizes */ settings->setValue( "bgSize", stackWidgetsSizes[bgWidget] ); settings->setValue( "playlistSize", stackWidgetsSizes[playlistWidget] ); + settings->endGroup(); /* Save this size */ QVLCTools::saveWidgetPosition(settings, this); - settings->endGroup(); - /* Save undocked playlist size */ if( playlistWidget && !isPlDocked() ) QVLCTools::saveWidgetPosition( p_intf, "Playlist", playlistWidget ); @@ -311,12 +310,23 @@ MainInterface::~MainInterface() delete statusBar(); /* Unregister callbacks */ - var_DelCallback( p_intf->p_libvlc, "intf-show", IntfShowCB, p_intf ); + var_DelCallback( p_intf->p_libvlc, "intf-boss", IntfBossCB, p_intf ); + var_DelCallback( p_intf->p_libvlc, "intf-show", IntfRaiseMainCB, p_intf ); + var_DelCallback( p_intf->p_libvlc, "intf-toggle-fscontrol", IntfShowCB, p_intf ); var_DelCallback( p_intf->p_libvlc, "intf-popupmenu", PopupMenuCB, p_intf ); p_intf->p_sys->p_mi = NULL; } +void MainInterface::computeMinimumSize() +{ + int minWidth = 30; + if( menuBar()->isVisible() ) + minWidth += __MAX( controls->sizeHint().width(), menuBar()->sizeHint().width() ); + + setMinimumWidth( minWidth ); +} + /***************************** * Main UI handling * *****************************/ @@ -324,12 +334,14 @@ void MainInterface::recreateToolbars() { bool b_adv = getControlsVisibilityStatus() & CONTROLS_ADVANCED; - settings->beginGroup( "MainWindow" ); delete controls; delete inputC; controls = new ControlsWidget( p_intf, b_adv, this ); inputC = new InputControlsWidget( p_intf, this ); + mainLayout->insertWidget( 2, inputC ); + mainLayout->insertWidget( settings->value( "MainWindow/ToolbarPos", 0 ).toInt() ? 0: 3, + controls ); if( fullscreenControls ) { @@ -338,10 +350,20 @@ void MainInterface::recreateToolbars() CONNECT( fullscreenControls, keyPressed( QKeyEvent * ), this, handleKeyPress( QKeyEvent * ) ); } - mainLayout->insertWidget( 2, inputC ); - mainLayout->insertWidget( settings->value( "ToolbarPos", 0 ).toInt() ? 0: 3, - controls ); - settings->endGroup(); +} + +void MainInterface::reloadPrefs() +{ + b_notificationEnabled = var_InheritBool( p_intf, "qt-notification" ); + b_pauseOnMinimize = var_InheritBool( p_intf, "qt-pause-minimized" ); +#ifdef WIN32 + p_intf->p_sys->disable_volume_keys = var_InheritBool( p_intf, "qt-disable-volume-keys" ); +#endif + if( !var_InheritBool( p_intf, "qt-fs-controller" ) && fullscreenControls ) + { + delete fullscreenControls; + fullscreenControls = NULL; + } } void MainInterface::createMainWidget( QSettings *settings ) @@ -359,6 +381,11 @@ void MainInterface::createMainWidget( QSettings *settings ) /* Bg Cone */ bgWidget = new BackgroundWidget( p_intf ); stackCentralW->addWidget( bgWidget ); + if ( !var_InheritBool( p_intf, "qt-bgcone" ) ) + bgWidget->setWithArt( false ); + else + if ( var_InheritBool( p_intf, "qt-bgcone-expands" ) ) + bgWidget->setExpandstoHeight( true ); /* And video Outputs */ if( b_videoEmbedded ) @@ -368,14 +395,13 @@ void MainInterface::createMainWidget( QSettings *settings ) } mainLayout->insertWidget( 1, stackCentralW ); - settings->beginGroup( "MainWindow" ); - stackWidgetsSizes[bgWidget] = settings->value( "bgSize", QSize( 400, 0 ) ).toSize(); + stackWidgetsSizes[bgWidget] = settings->value( "MainWindow/bgSize", QSize( 600, 0 ) ).toSize(); /* Resize even if no-auto-resize, because we are at creation */ resizeStack( stackWidgetsSizes[bgWidget].width(), stackWidgetsSizes[bgWidget].height() ); /* Create the CONTROLS Widget */ controls = new ControlsWidget( p_intf, - settings->value( "adv-controls", false ).toBool(), this ); + settings->value( "MainWindow/adv-controls", false ).toBool(), this ); inputC = new InputControlsWidget( p_intf, this ); mainLayout->insertWidget( 2, inputC ); @@ -389,7 +415,6 @@ void MainInterface::createMainWidget( QSettings *settings ) visualSelector->hide(); #endif - settings->endGroup(); /* Enable the popup menu in the MI */ main->setContextMenuPolicy( Qt::CustomContextMenu ); @@ -408,7 +433,6 @@ void MainInterface::createMainWidget( QSettings *settings ) inline void MainInterface::initSystray() { -#ifndef HAVE_MAEMO bool b_systrayAvailable = QSystemTrayIcon::isSystemTrayAvailable(); bool b_systrayWanted = var_InheritBool( p_intf, "qt-system-tray" ); @@ -425,7 +449,6 @@ inline void MainInterface::initSystray() if( b_systrayAvailable && b_systrayWanted ) createSystray(); -#endif } inline void MainInterface::createStatusBar() @@ -450,6 +473,8 @@ inline void MainInterface::createStatusBar() "QLabel:hover { background-color: rgba(255, 255, 255, 50%) }" ); speedLabel->setStyleSheet( "QLabel:hover { background-color: rgba(255, 255, 255, 50%) }" ); + /* pad both label and its tooltip */ + nameLabel->setStyleSheet( "padding-left: 5px; padding-right: 5px;" ); /* and adding those */ statusBarr->addWidget( nameLabel, 8 ); @@ -467,6 +492,14 @@ inline void MainInterface::createStatusBar() CONNECT( THEMIM->getIM(), seekRequested( float ), timeLabel, setDisplayPosition( float ) ); + + /* This shouldn't be necessary, but for somehow reason, the statusBarr + starts at height of 20px and when a text is shown it needs more space. + But, as the QMainWindow policy doesn't allow statusBar to change QMW's + geometry, we need to force a height. If you have a better idea, please + tell me -- jb + */ + statusBarr->setFixedHeight( statusBarr->sizeHint().height() + 2 ); } /********************************************************************** @@ -499,6 +532,25 @@ inline void MainInterface::showTab( QWidget *widget ) stackCentralOldWidget = stackCentralW->currentWidget(); stackWidgetsSizes[stackCentralOldWidget] = stackCentralW->size(); + /* If we are playing video, embedded */ + if( videoWidget && THEMIM->getIM()->hasVideo() ) + { + /* Video -> Playlist */ + if( videoWidget == stackCentralOldWidget && widget == playlistWidget ) + { + stackCentralW->removeWidget( videoWidget ); + videoWidget->show(); videoWidget->raise(); + } + + /* Playlist -> Video */ + if( playlistWidget == stackCentralOldWidget && widget == videoWidget ) + { + playlistWidget->artContainer->removeWidget( videoWidget ); + videoWidget->show(); videoWidget->raise(); + stackCentralW->addWidget( videoWidget ); + } + } + stackCentralW->setCurrentWidget( widget ); if( b_autoresize ) resizeStack( stackWidgetsSizes[widget].width(), stackWidgetsSizes[widget].height() ); @@ -507,23 +559,31 @@ inline void MainInterface::showTab( QWidget *widget ) msg_Warn( p_intf, "State change %i", stackCentralW->currentIndex() ); msg_Warn( p_intf, "New stackCentralOldWidget %i", stackCentralW->indexOf( stackCentralOldWidget ) ); #endif + + /* This part is done later, to account for the new pl size */ + if( videoWidget && THEMIM->getIM()->hasVideo() && + videoWidget == stackCentralOldWidget && widget == playlistWidget ) + { + playlistWidget->artContainer->addWidget( videoWidget ); + playlistWidget->artContainer->setCurrentWidget( videoWidget ); + } } void MainInterface::destroyPopupMenu() { - QVLCMenu::PopupMenu( p_intf, false ); + VLCMenuBar::PopupMenu( p_intf, false ); } -void MainInterface::popupMenu( const QPoint &p ) +void MainInterface::popupMenu( const QPoint & ) { - QVLCMenu::PopupMenu( p_intf, true ); + VLCMenuBar::PopupMenu( p_intf, true ); } void MainInterface::toggleFSC() { if( !fullscreenControls ) return; - IMEvent *eShow = new IMEvent( FullscreenControlToggle_Type, 0 ); + IMEvent *eShow = new IMEvent( FullscreenControlToggle_Type ); QApplication::postEvent( fullscreenControls, eShow ); } @@ -531,21 +591,6 @@ void MainInterface::toggleFSC() * Video Handling ****************************************************************************/ -/* This event is used to deal with the fullscreen and always on top - issue conflict (bug in wx) */ -class SetVideoOnTopQtEvent : public QEvent -{ -public: - SetVideoOnTopQtEvent( bool _onTop ) : - QEvent( (QEvent::Type)SetVideoOnTopEvent_Type ), onTop( _onTop) - {} - - bool OnTop() const { return onTop; } - -private: - bool onTop; -}; - /** * NOTE: * You must not change the state of this object or other Qt4 UI objects, @@ -569,6 +614,10 @@ WId MainInterface::getVideo( int *pi_x, int *pi_y, void MainInterface::getVideoSlot( WId *p_id, int *pi_x, int *pi_y, unsigned *pi_width, unsigned *pi_height ) { + /* Hidden or minimized, activate */ + if( isHidden() || isMinimized() ) + toggleUpdateSystrayMenu(); + /* Request the videoWidget */ WId ret = videoWidget->request( pi_x, pi_y, pi_width, pi_height, !b_autoresize ); @@ -593,16 +642,93 @@ void MainInterface::releaseVideo( void ) /* Function that is CONNECTED to the previous emit */ void MainInterface::releaseVideoSlot( void ) { + /* This function is called when the embedded video window is destroyed, + * or in the rare case that the embedded window is still here but the + * Qt4 interface exits. */ + assert( videoWidget ); videoWidget->release(); + setVideoOnTop( false ); + setVideoFullScreen( false ); - msg_Warn( p_intf, "Here" ); if( stackCentralW->currentWidget() == videoWidget ) restoreStackOldWidget(); + else if( playlistWidget && + playlistWidget->artContainer->currentWidget() == videoWidget ) + { + playlistWidget->artContainer->setCurrentIndex( 0 ); + stackCentralW->addWidget( videoWidget ); + } /* We don't want to have a blank video to popup */ stackCentralOldWidget = bgWidget; } +void MainInterface::setVideoSize( unsigned int w, unsigned int h ) +{ + if( !isFullScreen() && !isMaximized() ) + videoWidget->SetSizing( w, h ); +} + +void MainInterface::setVideoFullScreen( bool fs ) +{ + b_videoFullScreen = fs; + if( fs ) + { + int numscreen = var_InheritInteger( p_intf, "qt-fullscreen-screennumber" ); + /* if user hasn't defined screennumber, or screennumber that is bigger + * than current number of screens, take screennumber where current interface + * is + */ + if( numscreen == -1 || numscreen > QApplication::desktop()->numScreens() ) + numscreen = QApplication::desktop()->screenNumber( p_intf->p_sys->p_mi ); + + QRect screenres = QApplication::desktop()->screenGeometry( numscreen ); + + /* To be sure window is on proper-screen in xinerama */ + if( !screenres.contains( pos() ) ) + { + msg_Dbg( p_intf, "Moving video to correct screen"); + move( QPoint( screenres.x(), screenres.y() ) ); + } + + /* */ + if( playlistWidget != NULL && playlistWidget->artContainer->currentWidget() == videoWidget ) + { + showTab( videoWidget ); + } + + /* */ + setMinimalView( true ); + setInterfaceFullScreen( true ); + } + else + { + /* TODO do we want to restore screen and position ? (when + * qt-fullscreen-screennumber is forced) */ + setMinimalView( b_minimalView ); + setInterfaceFullScreen( b_interfaceFullScreen ); + } + videoWidget->sync(); +} + +/* Slot to change the video always-on-top flag. + * Emit askVideoOnTop() to invoke this from other thread. */ +void MainInterface::setVideoOnTop( bool on_top ) +{ + Qt::WindowFlags oldflags = windowFlags(), newflags; + + if( on_top ) + newflags = oldflags | Qt::WindowStaysOnTopHint; + else + newflags = oldflags & ~Qt::WindowStaysOnTopHint; + if( newflags != oldflags && !b_videoFullScreen ) + + { + setWindowFlags( newflags ); + show(); /* necessary to apply window flags */ + } +} + /* Asynchronous call from WindowControl function */ int MainInterface::controlVideo( int i_query, va_list args ) { @@ -612,8 +738,7 @@ int MainInterface::controlVideo( int i_query, va_list args ) { unsigned int i_width = va_arg( args, unsigned int ); unsigned int i_height = va_arg( args, unsigned int ); - if( isFullScreen() || isMaximized() ) - showNormal(); + emit askVideoToResize( i_width, i_height ); return VLC_SUCCESS; } @@ -621,12 +746,14 @@ int MainInterface::controlVideo( int i_query, va_list args ) { unsigned i_arg = va_arg( args, unsigned ); unsigned on_top = i_arg & VOUT_WINDOW_STATE_ABOVE; - QApplication::postEvent( this, new SetVideoOnTopQtEvent( on_top ) ); + + emit askVideoOnTop( on_top != 0 ); return VLC_SUCCESS; } case VOUT_WINDOW_SET_FULLSCREEN: { bool b_fs = va_arg( args, int ); + emit askVideoSetFullScreen( b_fs ); return VLC_SUCCESS; } @@ -649,10 +776,13 @@ void MainInterface::createPlaylist() if( b_plDocked ) { stackCentralW->addWidget( playlistWidget ); - stackWidgetsSizes[playlistWidget] = settings->value( "playlistSize", QSize( 500, 250 ) ).toSize(); + stackWidgetsSizes[playlistWidget] = settings->value( "playlistSize", QSize( 600, 300 ) ).toSize(); } else { +#ifdef WIN32 + playlistWidget->setParent( NULL ); +#endif playlistWidget->setWindowFlags( Qt::Window ); /* This will restore the geometry but will not work for position, @@ -684,6 +814,9 @@ void MainInterface::togglePlaylist() } else { +#ifdef WIN32 + playlistWidget->setParent( NULL ); +#endif playlistWidget->setWindowFlags( Qt::Window ); playlistVisible = !playlistVisible; playlistWidget->setVisible( playlistVisible ); @@ -700,6 +833,9 @@ void MainInterface::dockPlaylist( bool p_docked ) if( !p_docked ) { stackCentralW->removeWidget( playlistWidget ); +#ifdef WIN32 + playlistWidget->setParent( NULL ); +#endif playlistWidget->setWindowFlags( Qt::Window ); QVLCTools::restoreWidgetPosition( p_intf, "Playlist", playlistWidget, QSize( 600, 300 ) ); @@ -718,11 +854,25 @@ void MainInterface::dockPlaylist( bool p_docked ) } /* - If b_switch is false, then we are normalView + * setMinimalView is the private function used by + * the SLOT toggleMinimalView and setVideoFullScreen + */ +void MainInterface::setMinimalView( bool b_minimal ) +{ + menuBar()->setVisible( !b_minimal ); + controls->setVisible( !b_minimal ); + statusBar()->setVisible( !b_minimal && b_statusbarVisible ); + inputC->setVisible( !b_minimal ); +} + +/* + * This public SLOT is used for moving to minimal View Mode + * + * If b_minimal is false, then we are normalView */ -void MainInterface::toggleMinimalView( bool b_switch ) +void MainInterface::toggleMinimalView( bool b_minimal ) { - if( i_visualmode == 0 && b_autoresize ) /* Normal mode */ + if( !b_minimalView && b_autoresize ) /* Normal mode */ { if( stackCentralW->currentWidget() == bgWidget ) { @@ -732,13 +882,14 @@ void MainInterface::toggleMinimalView( bool b_switch ) } } } + b_minimalView = b_minimal; + if( !b_videoFullScreen ) + { + setMinimalView( b_minimalView ); + computeMinimumSize(); + } - menuBar()->setVisible( !b_switch ); - controls->setVisible( !b_switch ); - statusBar()->setVisible( !b_switch ); - inputC->setVisible( !b_switch ); - - emit minimalViewToggled( b_switch ); + emit minimalViewToggled( b_minimalView ); } /* toggling advanced controls buttons */ @@ -756,6 +907,13 @@ int MainInterface::getControlsVisibilityStatus() + CONTROLS_ADVANCED * controls->b_advancedVisible ); } +void MainInterface::setStatusBarVisibility( bool b_visible ) +{ + statusBar()->setVisible( b_visible ); + b_statusbarVisible = b_visible; + if( controls ) controls->setGripVisible( !b_statusbarVisible ); +} + #if 0 void MainInterface::visual() { @@ -785,8 +943,8 @@ void MainInterface::setName( const QString& name ) input_name = name; /* store it for the QSystray use */ /* Display it in the status bar, but also as a Tooltip in case it doesn't fit in the label */ - nameLabel->setText( " " + name + " " ); - nameLabel->setToolTip( " " + name +" " ); + nameLabel->setText( name ); + nameLabel->setToolTip( name ); } /** @@ -828,7 +986,6 @@ void MainInterface::showBuffering( float f_cache ) /***************************************************************************** * Systray Icon and Systray Menu *****************************************************************************/ -#ifndef HAVE_MAEMO /** * Create a SystemTray icon and a menu that would go with it. * Connects to a click handler on the icon. @@ -836,8 +993,8 @@ void MainInterface::showBuffering( float f_cache ) void MainInterface::createSystray() { QIcon iconVLC; - if( QDate::currentDate().dayOfYear() >= 354 ) - iconVLC = QIcon( ":/logo/vlc128-christmas.png" ); + if( QDate::currentDate().dayOfYear() >= QT_XMAS_JOKE_DAY && var_InheritBool( p_intf, "qt-icon-change" ) ) + iconVLC = QIcon( ":/logo/vlc128-xmas.png" ); else iconVLC = QIcon( ":/logo/vlc128.png" ); sysTray = new QSystemTrayIcon( iconVLC, this ); @@ -846,11 +1003,18 @@ void MainInterface::createSystray() systrayMenu = new QMenu( qtr( "VLC media player" ), this ); systrayMenu->setIcon( iconVLC ); - QVLCMenu::updateSystrayMenu( this, p_intf, true ); + VLCMenuBar::updateSystrayMenu( this, p_intf, true ); sysTray->show(); CONNECT( sysTray, activated( QSystemTrayIcon::ActivationReason ), - this, handleSystrayClick( QSystemTrayIcon::ActivationReason ) ); + this, handleSystrayClick( QSystemTrayIcon::ActivationReason ) ); + + /* Connects on nameChanged() */ + CONNECT( THEMIM->getIM(), nameChanged( const QString& ), + this, updateSystrayTooltipName( const QString& ) ); + /* Connect PLAY_STATUS on the systray */ + CONNECT( THEMIM->getIM(), playingStatusChanged( int ), + this, updateSystrayTooltipStatus( int ) ); } /** @@ -898,9 +1062,30 @@ void MainInterface::toggleUpdateSystrayMenu() hide(); #endif } - QVLCMenu::updateSystrayMenu( this, p_intf ); + if( sysTray ) + VLCMenuBar::updateSystrayMenu( this, p_intf ); +} + +/* First Item of the systray menu */ +void MainInterface::showUpdateSystrayMenu() +{ + if( isHidden() ) + show(); + if( isMinimized() ) + showNormal(); + activateWindow(); + + VLCMenuBar::updateSystrayMenu( this, p_intf ); +} + +/* First Item of the systray menu */ +void MainInterface::hideUpdateSystrayMenu() +{ + hide(); + VLCMenuBar::updateSystrayMenu( this, p_intf ); } +/* Click on systray Icon */ void MainInterface::handleSystrayClick( QSystemTrayIcon::ActivationReason reason ) { @@ -908,7 +1093,11 @@ void MainInterface::handleSystrayClick( { case QSystemTrayIcon::Trigger: case QSystemTrayIcon::DoubleClick: +#ifdef Q_WS_MAC + VLCMenuBar::updateSystrayMenu( this, p_intf ); +#else toggleUpdateSystrayMenu(); +#endif break; case QSystemTrayIcon::MiddleClick: sysTray->showMessage( qtr( "VLC media player" ), @@ -940,7 +1129,7 @@ void MainInterface::updateSystrayTooltipName( const QString& name ) } } - QVLCMenu::updateSystrayMenu( this, p_intf ); + VLCMenuBar::updateSystrayMenu( this, p_intf ); } /** @@ -961,9 +1150,40 @@ void MainInterface::updateSystrayTooltipStatus( int i_status ) sysTray->setToolTip( qtr( "VLC media player" ) ); break; } - QVLCMenu::updateSystrayMenu( this, p_intf ); + VLCMenuBar::updateSystrayMenu( this, p_intf ); +} + +void MainInterface::changeEvent(QEvent *event) +{ + if( event->type() == QEvent::WindowStateChange ) + { + QWindowStateChangeEvent *windowStateChangeEvent = static_cast(event); + Qt::WindowStates newState = windowState(); + Qt::WindowStates oldState = windowStateChangeEvent->oldState(); + + if( newState & Qt::WindowMinimized ) + { + b_hasPausedWhenMinimized = false; + + if( THEMIM->getIM()->playingStatus() == PLAYING_S && + THEMIM->getIM()->hasVideo() && !THEMIM->getIM()->hasVisualisation() && + b_pauseOnMinimize ) + { + b_hasPausedWhenMinimized = true; + THEMIM->pause(); + } + } + else if( oldState & Qt::WindowMinimized && !( newState & Qt::WindowMinimized ) ) + { + if( b_hasPausedWhenMinimized ) + { + THEMIM->play(); + } + } + } + + QWidget::changeEvent(event); } -#endif /************************************************************************ * D&D Events @@ -975,14 +1195,15 @@ void MainInterface::dropEvent(QDropEvent *event) void MainInterface::dropEventPlay( QDropEvent *event, bool b_play ) { - event->setDropAction( Qt::CopyAction ); - if( !event->possibleActions() & Qt::CopyAction ) + if( event->possibleActions() & ( Qt::CopyAction | Qt::MoveAction ) ) + event->setDropAction( Qt::CopyAction ); + else return; const QMimeData *mimeData = event->mimeData(); /* D&D of a subtitles file, add it on the fly */ - if( mimeData->urls().size() == 1 && THEMIM->getIM()->hasInput() ) + if( mimeData->urls().count() == 1 && THEMIM->getIM()->hasInput() ) { if( !input_AddSubtitle( THEMIM->getInput(), qtu( toNativeSeparators( mimeData->urls()[0].toLocalFile() ) ), @@ -996,18 +1217,28 @@ void MainInterface::dropEventPlay( QDropEvent *event, bool b_play ) bool first = b_play; foreach( const QUrl &url, mimeData->urls() ) { - QString s = toNativeSeparators( url.toLocalFile() ); - - if( s.length() > 0 ) { - char* psz_uri = make_URI( qtu(s) ); - playlist_Add( THEPL, psz_uri, NULL, + if( url.isValid() ) + { + QString mrl = toURI( url.toEncoded().constData() ); + playlist_Add( THEPL, qtu(mrl), NULL, PLAYLIST_APPEND | (first ? PLAYLIST_GO: PLAYLIST_PREPARSE), PLAYLIST_END, true, pl_Unlocked ); - free( psz_uri ); first = false; - RecentsMRL::getInstance( p_intf )->addRecent( s ); + RecentsMRL::getInstance( p_intf )->addRecent( url.toString() ); } } + + /* Browsers give content as text if you dnd the addressbar, + so check if mimedata has valid url in text and use it + if we didn't get any normal Urls()*/ + if( !mimeData->hasUrls() && mimeData->hasText() && + QUrl(mimeData->text()).isValid() ) + { + QString mrl = toURI( mimeData->text() ); + playlist_Add( THEPL, qtu(mrl), NULL, + PLAYLIST_APPEND | (first ? PLAYLIST_GO: PLAYLIST_PREPARSE), + PLAYLIST_END, true, pl_Unlocked ); + } event->accept(); } void MainInterface::dragEnterEvent(QDragEnterEvent *event) @@ -1026,19 +1257,6 @@ void MainInterface::dragLeaveEvent(QDragLeaveEvent *event) /************************************************************************ * Events stuff ************************************************************************/ -void MainInterface::customEvent( QEvent *event ) -{ - if ( event->type() == (int)SetVideoOnTopEvent_Type ) - { - SetVideoOnTopQtEvent* p_event = (SetVideoOnTopQtEvent*)event; - if( p_event->OnTop() ) - setWindowFlags( windowFlags() | Qt::WindowStaysOnTopHint ); - else - setWindowFlags( windowFlags() & ~Qt::WindowStaysOnTopHint ); - show(); /* necessary to apply window flags */ - } -} - void MainInterface::keyPressEvent( QKeyEvent *e ) { handleKeyPress( e ); @@ -1046,10 +1264,9 @@ void MainInterface::keyPressEvent( QKeyEvent *e ) void MainInterface::handleKeyPress( QKeyEvent *e ) { - if( ( e->modifiers() & Qt::ControlModifier ) && ( e->key() == Qt::Key_H ) - && !menuBar()->isVisible() ) + if( ( e->modifiers() & Qt::ControlModifier ) && ( e->key() == Qt::Key_H ) ) { - toggleMinimalView( false ); + toggleMinimalView( !b_minimalView ); e->accept(); } @@ -1072,25 +1289,54 @@ void MainInterface::wheelEvent( QWheelEvent *e ) void MainInterface::closeEvent( QCloseEvent *e ) { +// hide(); + emit askToQuit(); /* ask THEDP to quit, so we have a unique method */ + /* Accept session quit. Otherwise we break the desktop mamager. */ e->accept(); - hide(); - THEDP->quit(); } -void MainInterface::toggleFullScreen() +void MainInterface::setInterfaceFullScreen( bool fs ) +{ + if( fs ) + setWindowState( windowState() | Qt::WindowFullScreen ); + else + setWindowState( windowState() & ~Qt::WindowFullScreen ); +} +void MainInterface::toggleInterfaceFullScreen() +{ + b_interfaceFullScreen = !b_interfaceFullScreen; + if( !b_videoFullScreen ) + setInterfaceFullScreen( b_interfaceFullScreen ); + emit fullscreenInterfaceToggled( b_interfaceFullScreen ); +} + +void MainInterface::emitBoss() { - if( isFullScreen() ) + emit askBoss(); +} +void MainInterface::setBoss() +{ + THEMIM->pause(); + if( sysTray ) { - showNormal(); - emit fullscreenInterfaceToggled( false ); + hide(); } else { - showFullScreen(); - emit fullscreenInterfaceToggled( true ); + showMinimized(); } } +void MainInterface::emitRaise() +{ + emit askRaise(); +} +void MainInterface::setRaise() +{ + activateWindow(); + raise(); +} + /***************************************************************************** * PopupMenuCB: callback triggered by the intf-popupmenu playlist variable. * We don't show the menu directly here because we don't want the @@ -1099,6 +1345,8 @@ void MainInterface::toggleFullScreen() static int PopupMenuCB( vlc_object_t *p_this, const char *psz_variable, vlc_value_t old_val, vlc_value_t new_val, void *param ) { + VLC_UNUSED( p_this ); VLC_UNUSED( psz_variable ); VLC_UNUSED( old_val ); + intf_thread_t *p_intf = (intf_thread_t *)param; if( p_intf->pf_show_dialog ) @@ -1111,14 +1359,47 @@ static int PopupMenuCB( vlc_object_t *p_this, const char *psz_variable, } /***************************************************************************** - * IntfShowCB: callback triggered by the intf-show libvlc variable. + * IntfShowCB: callback triggered by the intf-toggle-fscontrol libvlc variable. *****************************************************************************/ static int IntfShowCB( vlc_object_t *p_this, const char *psz_variable, vlc_value_t old_val, vlc_value_t new_val, void *param ) { + VLC_UNUSED( p_this ); VLC_UNUSED( psz_variable ); VLC_UNUSED( old_val ); + VLC_UNUSED( new_val ); + intf_thread_t *p_intf = (intf_thread_t *)param; p_intf->p_sys->p_mi->toggleFSC(); /* Show event */ return VLC_SUCCESS; } + +/***************************************************************************** + * IntfRaiseMainCB: callback triggered by the intf-show-main libvlc variable. + *****************************************************************************/ +static int IntfRaiseMainCB( vlc_object_t *p_this, const char *psz_variable, + vlc_value_t old_val, vlc_value_t new_val, void *param ) +{ + VLC_UNUSED( p_this ); VLC_UNUSED( psz_variable ); VLC_UNUSED( old_val ); + VLC_UNUSED( new_val ); + + intf_thread_t *p_intf = (intf_thread_t *)param; + p_intf->p_sys->p_mi->emitRaise(); + + return VLC_SUCCESS; +} + +/***************************************************************************** + * IntfBossCB: callback triggered by the intf-boss libvlc variable. + *****************************************************************************/ +static int IntfBossCB( vlc_object_t *p_this, const char *psz_variable, + vlc_value_t old_val, vlc_value_t new_val, void *param ) +{ + VLC_UNUSED( p_this ); VLC_UNUSED( psz_variable ); VLC_UNUSED( old_val ); + VLC_UNUSED( new_val ); + + intf_thread_t *p_intf = (intf_thread_t *)param; + p_intf->p_sys->p_mi->emitBoss(); + + return VLC_SUCCESS; +}