/*****************************************************************************
* main_interface.cpp : Main interface
****************************************************************************
- * Copyright (C) 2006-2010 VideoLAN and AUTHORS
+ * Copyright (C) 2006-2011 VideoLAN and AUTHORS
* $Id$
*
* Authors: Clément Stenac <zorglub@videolan.org>
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 )
{
b_hideAfterCreation = false; // --qt-start-minimized
playlistVisible = false;
input_name = "";
+ b_interfaceFullScreen= false;
/* Ask for Privacy */
setWindowRole( "vlc-main" );
setWindowIcon( QApplication::windowIcon() );
setWindowOpacity( var_InheritFloat( p_intf, "qt-opacity" ) );
+#ifdef Q_WS_MAC
+ setAttribute( Qt::WA_MacBrushedMetal );
+#endif
/* Is video in embedded in the UI or not */
b_videoEmbedded = var_InheritBool( p_intf, "embedded-video" );
/* Does the interface resize to video size or the opposite */
- b_keep_size = !var_InheritBool( p_intf, "qt-video-autoresize" );
+ 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" );
+#ifdef WIN32
+ /* Volume keys */
+ p_intf->p_sys->disable_volume_keys = var_InheritBool( p_intf, "qt-disable-volume-keys" );
+#endif
+
/* */
b_plDocked = getSettings()->value( "pl-dock-status", true ).toBool();
-
- /**
- * Retrieve saved sizes for main window
- * mainBasedSize = based window size for normal mode
- * (no video, no background)
- * mainVideoSize = window size with video (all modes)
- **/
- mainBasedSize = settings->value( "mainBasedSize", QSize( 350, 120 ) ).toSize();
- mainVideoSize = settings->value( "mainVideoSize", QSize( 400, 300 ) ).toSize();
settings->endGroup( );
- /**************
- * Status Bar *
- **************/
- createStatusBar();
-
/**************************
* UI and Widgets design
**************************/
setVLCWindowsTitle();
- createMainWidget( settings );
/************
* Menu Bar *
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 *
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.
/* 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 )
{
- CONNECT( this, askVideoToResize( unsigned int, unsigned int ),
- videoWidget, SetSizing( unsigned int, unsigned int ) );
- CONNECT( videoWidget, sizeChanged( int, int ),
- this, resizeStack( int, int ) );
+ if( b_autoresize )
+ {
+ CONNECT( this, askVideoToResize( 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( "MainWindow/playlist-visible", false ).toBool();
- /* resize to previously saved main window size if appicable */
- //FIXME remove.
- if( b_keep_size )
- {
- if( i_visualmode )
- resize( mainVideoSize );
- else
- resize( mainBasedSize );
- }
+ if( i_plVis ) togglePlaylist();
- /* Playlist */
- int i_plVis = settings->value( "playlist-visible", false ).toBool();
+ /**** FINAL SIZING and placement of interface */
+ settings->beginGroup( "MainWindow" );
+ QVLCTools::restoreWidgetPosition( settings, this, QSize(600, 420) );
settings->endGroup();
- 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 );
+
+ b_hasPausedWhenMinimized = false;
}
MainInterface::~MainInterface()
{
/* Unsure we hide the videoWidget before destroying it */
if( stackCentralOldWidget == videoWidget )
- showBg();
+ showTab( bgWidget );
+
+ if( videoWidget )
+ releaseVideoSlot();
#ifdef WIN32
if( himl )
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 );
- settings->setValue( "mainBasedSize", mainBasedSize );
- settings->setValue( "mainVideoSize", mainVideoSize );
-
- settings->setValue( "backgroundSize", bgWidget->size() );
+ /* Save the stackCentralW sizes */
+ settings->setValue( "bgSize", stackWidgetsSizes[bgWidget] );
+ settings->setValue( "playlistSize", stackWidgetsSizes[playlistWidget] );
/* Save this size */
QVLCTools::saveWidgetPosition(settings, this);
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 *
*****************************/
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 )
{
/* Create the main Widget and the mainLayout */
/* 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 )
mainLayout->insertWidget( 1, stackCentralW );
settings->beginGroup( "MainWindow" );
+ stackWidgetsSizes[bgWidget] = settings->value( "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,
"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 );
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 );
}
/**********************************************************************
}
inline void MainInterface::showVideo() { showTab( videoWidget ); }
-inline void MainInterface::showBg() { showTab( bgWidget ); }
+inline void MainInterface::restoreStackOldWidget()
+ { showTab( stackCentralOldWidget ); }
inline void MainInterface::showTab( QWidget *widget )
{
#ifdef DEBUG_INTF
msg_Warn( p_intf, "Old stackCentralOldWidget %i", stackCentralW->indexOf( stackCentralOldWidget ) );
#endif
+
stackCentralOldWidget = stackCentralW->currentWidget();
+ stackWidgetsSizes[stackCentralOldWidget] = stackCentralW->size();
+
stackCentralW->setCurrentWidget( widget );
+ if( b_autoresize )
+ resizeStack( stackWidgetsSizes[widget].width(), stackWidgetsSizes[widget].height() );
#ifdef DEBUG_INTF
msg_Warn( p_intf, "State change %i", stackCentralW->currentIndex() );
#endif
}
-inline void MainInterface::restoreStackOldWidget()
-{
-#ifdef DEBUG_INTF
- msg_Warn( p_intf, "New stackCentralOldWidget %i", stackCentralW->indexOf( stackCentralOldWidget ) );
-#endif
- QWidget *wTemp = stackCentralW->currentWidget();
-
- stackCentralW->setCurrentWidget( stackCentralOldWidget );
-
- stackCentralOldWidget = wTemp;
-#ifdef DEBUG_INTF
- msg_Warn( p_intf, "Debug %i %i",stackCentralW->indexOf( wTemp ), stackCentralW->indexOf( stackCentralW->currentWidget() ) );
-#endif
-}
-
void MainInterface::destroyPopupMenu()
{
QVLCMenu::PopupMenu( p_intf, false );
}
-void MainInterface::popupMenu( const QPoint &p )
+void MainInterface::popupMenu( const QPoint & )
{
QVLCMenu::PopupMenu( p_intf, true );
}
{
if( !fullscreenControls ) return;
- IMEvent *eShow = new IMEvent( FullscreenControlToggle_Type, 0 );
+ IMEvent *eShow = new IMEvent( FullscreenControlToggle_Type );
QApplication::postEvent( fullscreenControls, eShow );
}
* 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,
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_keep_size );
+ pi_width, pi_height, !b_autoresize );
*p_id = ret;
if( ret ) /* The videoWidget is available */
{
- /* Ask videoWidget to resize correctly, if we are in normal mode */
- if( !isFullScreen() && !isMaximized() )
- videoWidget->SetSizing( *pi_width, *pi_height );
-
/* Consider the video active now */
showVideo();
+
+ /* Ask videoWidget to resize correctly, if we are in normal mode */
+ if( !isFullScreen() && !isMaximized() && b_autoresize )
+ videoWidget->SetSizing( *pi_width, *pi_height );
}
}
/* 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 );
if( stackCentralW->currentWidget() == videoWidget )
restoreStackOldWidget();
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() ) );
+ }
+ 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 )
{
{
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;
}
{
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;
}
{
playlistWidget = new PlaylistWidget( p_intf, this );
- if( !b_plDocked )
+ if( b_plDocked )
+ {
+ stackCentralW->addWidget( playlistWidget );
+ 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,
QVLCTools::restoreWidgetPosition( p_intf, "Playlist",
playlistWidget, QSize( 600, 300 ) );
}
- else
- {
- stackCentralW->addWidget( playlistWidget );
- }
}
void MainInterface::togglePlaylist()
{
if( !playlistWidget )
+ {
createPlaylist();
+ }
if( b_plDocked )
{
}
else
{
+#ifdef WIN32
+ playlistWidget->setParent( NULL );
+#endif
playlistWidget->setWindowFlags( Qt::Window );
playlistVisible = !playlistVisible;
playlistWidget->setVisible( playlistVisible );
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 ) );
}
/*
- 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 )
+ if( !b_minimalView && b_autoresize ) /* Normal mode */
{
if( stackCentralW->currentWidget() == bgWidget )
{
}
}
}
+ 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 */
+ 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()
{
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 );
}
/**
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 );
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 ) );
}
/**
hide();
#endif
}
+ if( sysTray )
+ QVLCMenu::updateSystrayMenu( this, p_intf );
+}
+
+/* First Item of the systray menu */
+void MainInterface::showUpdateSystrayMenu()
+{
+ if( isHidden() )
+ show();
+ if( isMinimized() )
+ showNormal();
+ activateWindow();
+
QVLCMenu::updateSystrayMenu( this, p_intf );
}
+/* First Item of the systray menu */
+void MainInterface::hideUpdateSystrayMenu()
+{
+ hide();
+ QVLCMenu::updateSystrayMenu( this, p_intf );
+}
+
+/* Click on systray Icon */
void MainInterface::handleSystrayClick(
QSystemTrayIcon::ActivationReason reason )
{
{
case QSystemTrayIcon::Trigger:
case QSystemTrayIcon::DoubleClick:
+#ifdef Q_WS_MAC
+ QVLCMenu::updateSystrayMenu( this, p_intf );
+#else
toggleUpdateSystrayMenu();
+#endif
break;
case QSystemTrayIcon::MiddleClick:
sysTray->showMessage( qtr( "VLC media player" ),
}
#endif
+void MainInterface::changeEvent(QEvent *event)
+{
+ if( event->type() == QEvent::WindowStateChange )
+ {
+ QWindowStateChangeEvent *windowStateChangeEvent = static_cast<QWindowStateChangeEvent*>(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);
+}
+
/************************************************************************
* D&D Events
************************************************************************/
void MainInterface::dropEventPlay( QDropEvent *event, bool b_play )
{
- event->setDropAction( Qt::CopyAction );
- if( !event->possibleActions() & Qt::CopyAction )
+ if( event->possibleActions() & Qt::CopyAction )
+ 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() ) ),
bool first = b_play;
foreach( const QUrl &url, mimeData->urls() )
{
- QString s = url.toString();
-
- if( s.length() > 0 ) {
- playlist_Add( THEPL, qtu(s), 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 );
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)
/************************************************************************
* 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 );
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();
}
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( isFullScreen() )
+ 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()
+{
+ emit askBoss();
+}
+void MainInterface::setBoss()
+{
+ THEMIM->pause();
+#ifndef HAVE_MAEMO
+ if( sysTray )
{
- showNormal();
- emit fullscreenInterfaceToggled( false );
+ hide();
}
else
+#endif
{
- 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
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 )
}
/*****************************************************************************
- * 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;
+}
projects / vlc / blobdiff