]> git.sesse.net Git - vlc/blob - modules/gui/qt4/components/controller.cpp
Qt: allow loop/repeat button to be in a toolbar (part 1)
[vlc] / modules / gui / qt4 / components / controller.cpp
1 /*****************************************************************************
2  * Controller.cpp : Controller for the main interface
3  ****************************************************************************
4  * Copyright (C) 2006-2009 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Jean-Baptiste Kempf <jb@videolan.org>
8  *          Ilkka Ollakka <ileoo@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * ( at your option ) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #include <vlc_vout.h>
30 #include <vlc_keys.h>
31
32 #include "components/controller.hpp"
33 #include "components/controller_widget.hpp"
34 #include "components/interface_widgets.hpp"
35
36 #include "dialogs_provider.hpp" /* Opening Dialogs */
37 #include "input_manager.hpp"
38 #include "actions_manager.hpp"
39
40 #include "util/input_slider.hpp" /* InputSlider */
41 #include "util/customwidgets.hpp" /* qEventToKey */
42
43 #include <QSpacerItem>
44 #include <QToolButton>
45 #include <QHBoxLayout>
46 #include <QSignalMapper>
47 #include <QTimer>
48
49 /**********************************************************************
50  * TEH controls
51  **********************************************************************/
52
53 /******
54  * This is an abstract Toolbar/Controller
55  * This has helper to create any toolbar, any buttons and to manage the actions
56  *
57  *****/
58 AbstractController::AbstractController( intf_thread_t * _p_i, QWidget *_parent )
59                    : QFrame( _parent )
60 {
61     p_intf = _p_i;
62     advControls = NULL;
63
64     /* Main action provider */
65     toolbarActionsMapper = new QSignalMapper( this );
66     CONNECT( toolbarActionsMapper, mapped( int ),
67              ActionsManager::getInstance( p_intf  ), doAction( int ) );
68     CONNECT( THEMIM->getIM(), statusChanged( int ), this, setStatus( int ) );
69 }
70
71 /* Reemit some signals on status Change to activate some buttons */
72 void AbstractController::setStatus( int status )
73 {
74     bool b_hasInput = THEMIM->getIM()->hasInput();
75     /* Activate the interface buttons according to the presence of the input */
76     emit inputExists( b_hasInput );
77
78     emit inputPlaying( status == PLAYING_S );
79
80     emit inputIsRecordable( b_hasInput &&
81                             var_GetBool( THEMIM->getInput(), "can-record" ) );
82
83     emit inputIsTrickPlayable( b_hasInput &&
84                             var_GetBool( THEMIM->getInput(), "can-rewind" ) );
85 }
86
87 /* Generic button setup */
88 void AbstractController::setupButton( QAbstractButton *aButton )
89 {
90     static QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
91     sizePolicy.setHorizontalStretch( 0 );
92     sizePolicy.setVerticalStretch( 0 );
93
94     aButton->setSizePolicy( sizePolicy );
95     aButton->setFixedSize( QSize( 26, 26 ) );
96     aButton->setIconSize( QSize( 20, 20 ) );
97     aButton->setFocusPolicy( Qt::NoFocus );
98 }
99
100 /* Open the generic config line for the toolbar, parse it
101  * and create the widgets accordingly */
102 void AbstractController::parseAndCreate( const QString& config,
103                                          QBoxLayout *controlLayout )
104 {
105     QStringList list = config.split( ";", QString::SkipEmptyParts ) ;
106     for( int i = 0; i < list.size(); i++ )
107     {
108         QStringList list2 = list.at( i ).split( "-" );
109         if( list2.size() < 1 )
110         {
111             msg_Warn( p_intf, "Parsing error. Report this" );
112             continue;
113         }
114
115         bool ok;
116         int i_option = WIDGET_NORMAL;
117         buttonType_e i_type = (buttonType_e)list2.at( 0 ).toInt( &ok );
118         if( !ok )
119         {
120             msg_Warn( p_intf, "Parsing error 0. Please report this" );
121             continue;
122         }
123
124         if( list2.size() > 1 )
125         {
126             i_option = list2.at( 1 ).toInt( &ok );
127             if( !ok )
128             {
129                 msg_Warn( p_intf, "Parsing error 1. Please report this" );
130                 continue;
131             }
132         }
133
134         createAndAddWidget( controlLayout, -1, i_type, i_option );
135     }
136 }
137
138 void AbstractController::createAndAddWidget( QBoxLayout *controlLayout,
139                                              int i_index,
140                                              buttonType_e i_type,
141                                              int i_option )
142 {
143     /* Special case for SPACERS, who aren't QWidgets */
144     if( i_type == WIDGET_SPACER )
145     {
146         controlLayout->insertSpacing( i_index, 16 );
147         return;
148     }
149
150     if(  i_type == WIDGET_SPACER_EXTEND )
151     {
152         controlLayout->insertStretch( i_index, 16 );
153         return;
154     }
155
156     QWidget *widg = createWidget( i_type, i_option );
157     if( !widg ) return;
158
159     controlLayout->insertWidget( i_index, widg );
160 }
161
162
163 #define CONNECT_MAP( a ) CONNECT( a, clicked(),  toolbarActionsMapper, map() )
164 #define SET_MAPPING( a, b ) toolbarActionsMapper->setMapping( a , b )
165 #define CONNECT_MAP_SET( a, b ) \
166     CONNECT_MAP( a ); \
167     SET_MAPPING( a, b );
168 #define BUTTON_SET_BAR( a_button ) \
169     a_button->setToolTip( qtr( tooltipL[button] ) ); \
170     a_button->setIcon( QIcon( iconL[button] ) );
171 #define BUTTON_SET_BAR2( button, image, tooltip ) \
172     button->setToolTip( tooltip );          \
173     button->setIcon( QIcon( ":/"#image ) );
174
175 #define ENABLE_ON_VIDEO( a ) \
176     CONNECT( THEMIM->getIM(), voutChanged( bool ), a, setEnabled( bool ) ); \
177     a->setEnabled( THEMIM->getIM()->hasVideo() ); /* TODO: is this necessary? when input is started before the interface? */
178
179 #define ENABLE_ON_INPUT( a ) \
180     CONNECT( this, inputExists( bool ), a, setEnabled( bool ) ); \
181     a->setEnabled( THEMIM->getIM()->hasInput() ); /* TODO: is this necessary? when input is started before the interface? */
182
183 #define NORMAL_BUTTON( name )                           \
184     QToolButton * name ## Button = new QToolButton;     \
185     setupButton( name ## Button );                      \
186     CONNECT_MAP_SET( name ## Button, name ## _ACTION ); \
187     BUTTON_SET_BAR( name ## Button );                   \
188     widget = name ## Button;
189
190 QWidget *AbstractController::createWidget( buttonType_e button, int options )
191 {
192
193     bool b_flat  = options & WIDGET_FLAT;
194     bool b_big   = options & WIDGET_BIG;
195     bool b_shiny = options & WIDGET_SHINY;
196     bool b_special = false;
197
198     QWidget *widget = NULL;
199     switch( button )
200     {
201     case PLAY_BUTTON: {
202         PlayButton *playButton = new PlayButton;
203         setupButton( playButton );
204         BUTTON_SET_BAR(  playButton );
205         CONNECT_MAP_SET( playButton, PLAY_ACTION );
206         CONNECT( this, inputPlaying( bool ),
207                  playButton, updateButton( bool ));
208         widget = playButton;
209         }
210         break;
211     case STOP_BUTTON:{
212         NORMAL_BUTTON( STOP );
213         }
214         break;
215     case OPEN_BUTTON:{
216         NORMAL_BUTTON( OPEN );
217         }
218         break;
219     case PREVIOUS_BUTTON:{
220         NORMAL_BUTTON( PREVIOUS );
221         }
222         break;
223     case NEXT_BUTTON: {
224         NORMAL_BUTTON( NEXT );
225         }
226         break;
227     case SLOWER_BUTTON:{
228         NORMAL_BUTTON( SLOWER );
229         ENABLE_ON_INPUT( SLOWERButton );
230         }
231         break;
232     case FASTER_BUTTON:{
233         NORMAL_BUTTON( FASTER );
234         ENABLE_ON_INPUT( FASTERButton );
235         }
236         break;
237     case FRAME_BUTTON: {
238         NORMAL_BUTTON( FRAME );
239         ENABLE_ON_VIDEO( FRAMEButton );
240         }
241         break;
242     case FULLSCREEN_BUTTON:
243     case DEFULLSCREEN_BUTTON:
244         {
245         NORMAL_BUTTON( FULLSCREEN );
246         ENABLE_ON_VIDEO( FULLSCREENButton );
247         }
248         break;
249     case EXTENDED_BUTTON:{
250         NORMAL_BUTTON( EXTENDED );
251         }
252         break;
253     case PLAYLIST_BUTTON:{
254         NORMAL_BUTTON( PLAYLIST );
255         }
256         break;
257     case SNAPSHOT_BUTTON:{
258         NORMAL_BUTTON( SNAPSHOT );
259         ENABLE_ON_VIDEO( SNAPSHOTButton );
260         }
261         break;
262     case RECORD_BUTTON:{
263         QToolButton *recordButton = new QToolButton;
264         setupButton( recordButton );
265         CONNECT_MAP_SET( recordButton, RECORD_ACTION );
266         BUTTON_SET_BAR(  recordButton );
267         ENABLE_ON_INPUT( recordButton );
268         recordButton->setCheckable( true );
269         CONNECT( THEMIM->getIM(), recordingStateChanged( bool ),
270                  recordButton, setChecked( bool ) );
271         widget = recordButton;
272         }
273         break;
274     case ATOB_BUTTON: {
275         AtoB_Button *ABButton = new AtoB_Button;
276         setupButton( ABButton );
277         ABButton->setShortcut( qtr("Shift+L") );
278         BUTTON_SET_BAR( ABButton );
279         ENABLE_ON_INPUT( ABButton );
280         CONNECT_MAP_SET( ABButton, ATOB_ACTION );
281         CONNECT( THEMIM->getIM(), AtoBchanged( bool, bool),
282                  ABButton, setIcons( bool, bool ) );
283         widget = ABButton;
284         }
285         break;
286     case INPUT_SLIDER: {
287         InputSlider *slider = new InputSlider( Qt::Horizontal, NULL );
288
289         /* Update the position when the IM has changed */
290         CONNECT( THEMIM->getIM(), positionUpdated( float, int, int ),
291                 slider, setPosition( float, int, int ) );
292         /* And update the IM, when the position has changed */
293         CONNECT( slider, sliderDragged( float ),
294                  THEMIM->getIM(), sliderUpdate( float ) );
295         widget = slider;
296         }
297         break;
298     case MENU_BUTTONS:
299         widget = discFrame();
300         widget->hide();
301         break;
302     case TELETEXT_BUTTONS:
303         widget = telexFrame();
304         widget->hide();
305         break;
306     case VOLUME_SPECIAL:
307         b_special = true;
308     case VOLUME:
309         {
310             SoundWidget *snd = new SoundWidget( this, p_intf, b_shiny, b_special );
311             widget = snd;
312         }
313         break;
314     case TIME_LABEL:
315         {
316             TimeLabel *timeLabel = new TimeLabel( p_intf );
317             widget = timeLabel;
318         }
319         break;
320     case SPLITTER:
321         {
322             QFrame *line = new QFrame;
323             line->setFrameShape( QFrame::VLine );
324             line->setFrameShadow( QFrame::Raised );
325             line->setLineWidth( 0 );
326             line->setMidLineWidth( 1 );
327             widget = line;
328         }
329         break;
330     case ADVANCED_CONTROLLER:
331         {
332             advControls = new AdvControlsWidget( p_intf, this );
333             widget = advControls;
334         }
335         break;
336     case REVERSE_BUTTON:{
337         QToolButton *reverseButton = new QToolButton;
338         setupButton( reverseButton );
339         CONNECT_MAP_SET( reverseButton, REVERSE_ACTION );
340         BUTTON_SET_BAR(  reverseButton );
341         reverseButton->setCheckable( true );
342         /* You should, of COURSE change this to the correct event,
343            when/if we have one, that tells us if trickplay is possible . */
344         CONNECT( this, inputIsTrickPlayable( bool ), reverseButton, setVisible( bool ) );
345         reverseButton->setVisible( false );
346         widget = reverseButton;
347         }
348         break;
349     case SKIP_BACK_BUTTON: {
350         NORMAL_BUTTON( SKIP_BACK );
351         ENABLE_ON_INPUT( SKIP_BACKButton );
352         }
353         break;
354     case SKIP_FW_BUTTON: {
355         NORMAL_BUTTON( SKIP_FW );
356         ENABLE_ON_INPUT( SKIP_FWButton );
357         }
358         break;
359     case QUIT_BUTTON: {
360         NORMAL_BUTTON( QUIT );
361         }
362         break;
363     case RANDOM_BUTTON: {
364         NORMAL_BUTTON( RANDOM );
365         RANDOMButton->setCheckable( true );
366         CONNECT( THEMIM, randomChanged( bool ),
367                  RANDOMButton, setChecked( bool ) );
368         }
369         break;
370     case LOOP_BUTTON:{
371         LoopButton *loopButton = new LoopButton;
372         setupButton( loopButton );
373         loopButton->setToolTip( qtr( "Click to toggle between loop one, loop all" ) );
374         loopButton->setCheckable( true );
375         }
376         break;
377     default:
378         msg_Warn( p_intf, "This should not happen %i", button );
379         break;
380     }
381
382     /* Customize Buttons */
383     if( b_flat || b_big )
384     {
385         QFrame *frame = qobject_cast<QFrame *>(widget);
386         if( frame )
387         {
388             QList<QToolButton *> allTButtons = frame->findChildren<QToolButton *>();
389             for( int i = 0; i < allTButtons.size(); i++ )
390                 applyAttributes( allTButtons[i], b_flat, b_big );
391         }
392         else
393         {
394             QToolButton *tmpButton = qobject_cast<QToolButton *>(widget);
395             if( tmpButton )
396                 applyAttributes( tmpButton, b_flat, b_big );
397         }
398     }
399     return widget;
400 }
401 #undef NORMAL_BUTTON
402
403 void AbstractController::applyAttributes( QToolButton *tmpButton, bool b_flat, bool b_big )
404 {
405     if( tmpButton )
406     {
407         if( b_flat )
408             tmpButton->setAutoRaise( b_flat );
409         if( b_big )
410         {
411             tmpButton->setFixedSize( QSize( 32, 32 ) );
412             tmpButton->setIconSize( QSize( 26, 26 ) );
413         }
414     }
415 }
416
417 QFrame *AbstractController::discFrame()
418 {
419     /** Disc and Menus handling */
420     QFrame *discFrame = new QFrame( this );
421
422     QHBoxLayout *discLayout = new QHBoxLayout( discFrame );
423     discLayout->setSpacing( 0 ); discLayout->setMargin( 0 );
424
425     QToolButton *prevSectionButton = new QToolButton( discFrame );
426     setupButton( prevSectionButton );
427     BUTTON_SET_BAR2( prevSectionButton, toolbar/dvd_prev,
428             qtr("Previous Chapter/Title" ) );
429     discLayout->addWidget( prevSectionButton );
430
431     QToolButton *menuButton = new QToolButton( discFrame );
432     setupButton( menuButton );
433     discLayout->addWidget( menuButton );
434     BUTTON_SET_BAR2( menuButton, toolbar/dvd_menu, qtr( "Menu" ) );
435
436     QToolButton *nextSectionButton = new QToolButton( discFrame );
437     setupButton( nextSectionButton );
438     discLayout->addWidget( nextSectionButton );
439     BUTTON_SET_BAR2( nextSectionButton, toolbar/dvd_next,
440             qtr("Next Chapter/Title" ) );
441
442     /* Change the navigation button display when the IM
443        navigation changes */
444     CONNECT( THEMIM->getIM(), titleChanged( bool ),
445             discFrame, setVisible( bool ) );
446     CONNECT( THEMIM->getIM(), chapterChanged( bool ),
447             menuButton, setVisible( bool ) );
448     /* Changes the IM navigation when triggered on the nav buttons */
449     CONNECT( prevSectionButton, clicked(), THEMIM->getIM(),
450             sectionPrev() );
451     CONNECT( nextSectionButton, clicked(), THEMIM->getIM(),
452             sectionNext() );
453     CONNECT( menuButton, clicked(), THEMIM->getIM(),
454             sectionMenu() );
455     connect( THEMIM->getIM(), SIGNAL( titleChanged( bool ) ),
456              this, SIGNAL( sizeChanged() ) );
457
458     return discFrame;
459 }
460
461 QFrame *AbstractController::telexFrame()
462 {
463     /**
464      * Telextext QFrame
465      **/
466     QFrame *telexFrame = new QFrame;
467     QHBoxLayout *telexLayout = new QHBoxLayout( telexFrame );
468     telexLayout->setSpacing( 0 ); telexLayout->setMargin( 0 );
469     CONNECT( THEMIM->getIM(), teletextPossible( bool ),
470              telexFrame, setVisible( bool ) );
471     connect( THEMIM->getIM(), SIGNAL( teletextPossible( bool ) ),
472              this, SIGNAL( sizeChanged() ) );
473
474     /* On/Off button */
475     QToolButton *telexOn = new QToolButton;
476     setupButton( telexOn );
477     BUTTON_SET_BAR2( telexOn, toolbar/tv, qtr( "Teletext Activation" ) );
478     telexOn->setEnabled( false );
479     telexOn->setCheckable( true );
480
481     telexLayout->addWidget( telexOn );
482
483     /* Teletext Activation and set */
484     CONNECT( telexOn, clicked( bool ),
485              THEMIM->getIM(), activateTeletext( bool ) );
486     CONNECT( THEMIM->getIM(), teletextPossible( bool ),
487              telexOn, setEnabled( bool ) );
488
489     /* Transparency button */
490     QToolButton *telexTransparent = new QToolButton;
491     setupButton( telexTransparent );
492     BUTTON_SET_BAR2( telexTransparent, toolbar/tvtelx,
493                      qtr( "Toggle Transparency " ) );
494     telexTransparent->setEnabled( false );
495     telexTransparent->setCheckable( true );
496     telexLayout->addWidget( telexTransparent );
497
498     /* Transparency change and set */
499     CONNECT( telexTransparent, clicked( bool ),
500             THEMIM->getIM(), telexSetTransparency( bool ) );
501     CONNECT( THEMIM->getIM(), teletextTransparencyActivated( bool ),
502              telexTransparent, setChecked( bool ) );
503
504
505     /* Page setting */
506     QSpinBox *telexPage = new QSpinBox( telexFrame );
507     telexPage->setRange( 0, 999 );
508     telexPage->setValue( 100 );
509     telexPage->setAccelerated( true );
510     telexPage->setWrapping( true );
511     telexPage->setAlignment( Qt::AlignRight );
512     telexPage->setSizePolicy( QSizePolicy::Preferred, QSizePolicy::Minimum );
513     telexPage->setEnabled( false );
514     telexLayout->addWidget( telexPage );
515
516     /* Page change and set */
517     CONNECT( telexPage, valueChanged( int ),
518             THEMIM->getIM(), telexSetPage( int ) );
519     CONNECT( THEMIM->getIM(), newTelexPageSet( int ),
520             telexPage, setValue( int ) );
521
522     CONNECT( THEMIM->getIM(), teletextActivated( bool ), telexPage, setEnabled( bool ) );
523     CONNECT( THEMIM->getIM(), teletextActivated( bool ), telexTransparent, setEnabled( bool ) );
524     CONNECT( THEMIM->getIM(), teletextActivated( bool ), telexOn, setChecked( bool ) );
525     return telexFrame;
526 }
527 #undef CONNECT_MAP
528 #undef SET_MAPPING
529 #undef CONNECT_MAP_SET
530 #undef BUTTON_SET_BAR
531 #undef BUTTON_SET_BAR2
532 #undef ENABLE_ON_VIDEO
533 #undef ENABLE_ON_INPUT
534
535 #include <QHBoxLayout>
536 /*****************************
537  * DA Control Widget !
538  *****************************/
539 ControlsWidget::ControlsWidget( intf_thread_t *_p_i,
540                                 bool b_advControls,
541                                 QWidget *_parent ) :
542                                 AbstractController( _p_i, _parent )
543 {
544     /* advanced Controls handling */
545     b_advancedVisible = b_advControls;
546
547     QVBoxLayout *controlLayout = new QVBoxLayout( this );
548     controlLayout->setLayoutMargins( 6, 4, 6, 2, 5 );
549     controlLayout->setSpacing( 0 );
550     QHBoxLayout *controlLayout1 = new QHBoxLayout;
551     controlLayout1->setSpacing( 0 );
552
553     QString line1 = getSettings()->value( "MainToolbar1", MAIN_TB1_DEFAULT )
554                                         .toString();
555     parseAndCreate( line1, controlLayout1 );
556
557     QHBoxLayout *controlLayout2 = new QHBoxLayout;
558     controlLayout2->setSpacing( 0 );
559     QString line2 = getSettings()->value( "MainToolbar2", MAIN_TB2_DEFAULT )
560                                         .toString();
561     parseAndCreate( line2, controlLayout2 );
562
563     if( !b_advancedVisible && advControls ) advControls->hide();
564
565     controlLayout->addLayout( controlLayout1 );
566     controlLayout->addLayout( controlLayout2 );
567 }
568
569 ControlsWidget::~ControlsWidget()
570 {}
571
572 void ControlsWidget::toggleAdvanced()
573 {
574     if( !advControls ) return;
575
576     if( !b_advancedVisible )
577     {
578         advControls->show();
579         b_advancedVisible = true;
580     }
581     else
582     {
583         advControls->hide();
584         b_advancedVisible = false;
585     }
586     emit advancedControlsToggled( b_advancedVisible );
587 }
588
589 AdvControlsWidget::AdvControlsWidget( intf_thread_t *_p_i, QWidget *_parent ) :
590                                      AbstractController( _p_i, _parent )
591 {
592     controlLayout = new QHBoxLayout( this );
593     controlLayout->setMargin( 0 );
594     controlLayout->setSpacing( 0 );
595
596     QString line = getSettings()->value( "AdvToolbar", ADV_TB_DEFAULT )
597         .toString();
598     parseAndCreate( line, controlLayout );
599 }
600
601 InputControlsWidget::InputControlsWidget( intf_thread_t *_p_i, QWidget *_parent ) :
602                                      AbstractController( _p_i, _parent )
603 {
604     controlLayout = new QHBoxLayout( this );
605     controlLayout->setMargin( 0 );
606     controlLayout->setSpacing( 0 );
607
608     QString line = getSettings()->value( "InputToolbar", INPT_TB_DEFAULT ).toString();
609     parseAndCreate( line, controlLayout );
610 }
611 /**********************************************************************
612  * Fullscrenn control widget
613  **********************************************************************/
614 FullscreenControllerWidget::FullscreenControllerWidget( intf_thread_t *_p_i, QWidget *_parent )
615                            : AbstractController( _p_i, _parent )
616 {
617     i_mouse_last_x      = -1;
618     i_mouse_last_y      = -1;
619     b_mouse_over        = false;
620     i_mouse_last_move_x = -1;
621     i_mouse_last_move_y = -1;
622 #if HAVE_TRANSPARENCY
623     b_slow_hide_begin   = false;
624     i_slow_hide_timeout = 1;
625 #endif
626     b_fullscreen        = false;
627     i_hide_timeout      = 1;
628     i_screennumber      = -1;
629
630     vout.clear();
631
632     setWindowFlags( Qt::ToolTip );
633     setMinimumWidth( 600 );
634
635     setFrameShape( QFrame::StyledPanel );
636     setFrameStyle( QFrame::Sunken );
637     setSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
638
639     QVBoxLayout *controlLayout2 = new QVBoxLayout( this );
640     controlLayout2->setLayoutMargins( 4, 6, 4, 2, 5 );
641
642     /* First line */
643     InputControlsWidget *inputC = new InputControlsWidget( p_intf, this );
644     controlLayout2->addWidget( inputC );
645
646     controlLayout = new QHBoxLayout;
647     QString line = getSettings()->value( "MainWindow/FSCtoolbar", FSC_TB_DEFAULT ).toString();
648     parseAndCreate( line, controlLayout );
649     controlLayout2->addLayout( controlLayout );
650
651     /* hiding timer */
652     p_hideTimer = new QTimer( this );
653     CONNECT( p_hideTimer, timeout(), this, hideFSC() );
654     p_hideTimer->setSingleShot( true );
655
656     /* slow hiding timer */
657 #if HAVE_TRANSPARENCY
658     p_slowHideTimer = new QTimer( this );
659     CONNECT( p_slowHideTimer, timeout(), this, slowHideFSC() );
660 #endif
661
662     vlc_mutex_init_recursive( &lock );
663
664     CONNECT( THEMIM->getIM(), voutListChanged( vout_thread_t **, int ),
665              this, setVoutList( vout_thread_t **, int ) );
666
667     /* First Move */
668     QRect rect1 = getSettings()->value( "FullScreen/screen" ).toRect();
669     QPoint pos1 = getSettings()->value( "FullScreen/pos" ).toPoint();
670     int number =  config_GetInt( p_intf, "qt-fullscreen-screennumber" );
671     if( number == -1 || number > QApplication::desktop()->numScreens() )
672         number = QApplication::desktop()->screenNumber( p_intf->p_sys->p_mi );
673
674     QRect rect = QApplication::desktop()->screenGeometry( number );
675     if( rect == rect1 && rect.contains( pos1, true ) )
676     {
677         move( pos1 );
678         i_screennumber = number;
679         screenRes = QApplication::desktop()->screenGeometry(number);
680     }
681     else
682     {
683         centerFSC( number );
684     }
685
686 }
687
688 FullscreenControllerWidget::~FullscreenControllerWidget()
689 {
690     QPoint pos1 = pos();
691     QRect rect1 = QApplication::desktop()->screenGeometry( pos1 );
692     getSettings()->setValue( "FullScreen/pos", pos1 );
693     getSettings()->setValue( "FullScreen/screen", rect1 );
694
695     setVoutList( NULL, 0 );
696     vlc_mutex_destroy( &lock );
697 }
698
699 void FullscreenControllerWidget::centerFSC( int number )
700 {
701     screenRes = QApplication::desktop()->screenGeometry(number);
702
703     /* screen has changed, calculate new position */
704     QPoint pos = QPoint( screenRes.x() + (screenRes.width() / 2) - (sizeHint().width() / 2),
705             screenRes.y() + screenRes.height() - sizeHint().height());
706     move( pos );
707
708     i_screennumber = number;
709 }
710
711 /**
712  * Show fullscreen controller
713  */
714 void FullscreenControllerWidget::showFSC()
715 {
716     adjustSize();
717
718     int number = QApplication::desktop()->screenNumber( p_intf->p_sys->p_mi );
719
720     if( number != i_screennumber ||
721         screenRes != QApplication::desktop()->screenGeometry(number) )
722     {
723         centerFSC( number );
724         msg_Dbg( p_intf, "Recentering the Fullscreen Controller" );
725     }
726
727 #if HAVE_TRANSPARENCY
728     setWindowOpacity( config_GetFloat( p_intf, "qt-fs-opacity" )  );
729 #endif
730
731     show();
732 }
733
734 /**
735  * Plane to hide fullscreen controller
736  */
737 void FullscreenControllerWidget::planHideFSC()
738 {
739     vlc_mutex_lock( &lock );
740     int i_timeout = i_hide_timeout;
741     vlc_mutex_unlock( &lock );
742
743     p_hideTimer->start( i_timeout );
744
745 #if HAVE_TRANSPARENCY
746     b_slow_hide_begin = true;
747     i_slow_hide_timeout = i_timeout;
748     p_slowHideTimer->start( i_slow_hide_timeout / 2 );
749 #endif
750 }
751
752 /**
753  * Hidding fullscreen controller slowly
754  * Linux: need composite manager
755  * Windows: it is blinking, so it can be enabled by define TRASPARENCY
756  */
757 void FullscreenControllerWidget::slowHideFSC()
758 {
759 #if HAVE_TRANSPARENCY
760     if( b_slow_hide_begin )
761     {
762         b_slow_hide_begin = false;
763
764         p_slowHideTimer->stop();
765         /* the last part of time divided to 100 pieces */
766         p_slowHideTimer->start( (int)( i_slow_hide_timeout / 2 / ( windowOpacity() * 100 ) ) );
767
768     }
769     else
770     {
771          if ( windowOpacity() > 0.0 )
772          {
773              /* we should use 0.01 because of 100 pieces ^^^
774                 but than it cannt be done in time */
775              setWindowOpacity( windowOpacity() - 0.02 );
776          }
777
778          if ( windowOpacity() <= 0.0 )
779              p_slowHideTimer->stop();
780     }
781 #endif
782 }
783
784 /**
785  * event handling
786  * events: show, hide, start timer for hidding
787  */
788 void FullscreenControllerWidget::customEvent( QEvent *event )
789 {
790     bool b_fs;
791
792     switch( event->type() )
793     {
794         /* This is used when the 'i' hotkey is used, to force quick toggle */
795         case FullscreenControlToggle_Type:
796             vlc_mutex_lock( &lock );
797             b_fs = b_fullscreen;
798             vlc_mutex_unlock( &lock );
799
800             if( b_fs )
801             {
802                 if( isHidden() )
803                 {
804                     p_hideTimer->stop();
805                     showFSC();
806                 }
807                 else
808                     hideFSC();
809             }
810             break;
811         /* Event called to Show the FSC on mouseChanged() */
812         case FullscreenControlShow_Type:
813             vlc_mutex_lock( &lock );
814             b_fs = b_fullscreen;
815             vlc_mutex_unlock( &lock );
816
817             if( b_fs )
818                 showFSC();
819
820             break;
821         /* Start the timer to hide later, called usually with above case */
822         case FullscreenControlPlanHide_Type:
823             if( !b_mouse_over ) // Only if the mouse is not over FSC
824                 planHideFSC();
825             break;
826         /* Hide */
827         case FullscreenControlHide_Type:
828             hideFSC();
829             break;
830         default:
831             break;
832     }
833 }
834
835 /**
836  * On mouse move
837  * moving with FSC
838  */
839 void FullscreenControllerWidget::mouseMoveEvent( QMouseEvent *event )
840 {
841     if( event->buttons() == Qt::LeftButton )
842     {
843         if( i_mouse_last_x == -1 || i_mouse_last_y == -1 )
844             return;
845
846         int i_moveX = event->globalX() - i_mouse_last_x;
847         int i_moveY = event->globalY() - i_mouse_last_y;
848
849         move( x() + i_moveX, y() + i_moveY );
850
851         i_mouse_last_x = event->globalX();
852         i_mouse_last_y = event->globalY();
853     }
854 }
855
856 /**
857  * On mouse press
858  * store position of cursor
859  */
860 void FullscreenControllerWidget::mousePressEvent( QMouseEvent *event )
861 {
862     i_mouse_last_x = event->globalX();
863     i_mouse_last_y = event->globalY();
864     event->accept();
865 }
866
867 void FullscreenControllerWidget::mouseReleaseEvent( QMouseEvent *event )
868 {
869     i_mouse_last_x = -1;
870     i_mouse_last_y = -1;
871     event->accept();
872 }
873
874 /**
875  * On mouse go above FSC
876  */
877 void FullscreenControllerWidget::enterEvent( QEvent *event )
878 {
879     b_mouse_over = true;
880
881     p_hideTimer->stop();
882 #if HAVE_TRANSPARENCY
883     p_slowHideTimer->stop();
884     setWindowOpacity( DEFAULT_OPACITY );
885 #endif
886     event->accept();
887 }
888
889 /**
890  * On mouse go out from FSC
891  */
892 void FullscreenControllerWidget::leaveEvent( QEvent *event )
893 {
894     planHideFSC();
895
896     b_mouse_over = false;
897     event->accept();
898 }
899
900 /**
901  * When you get pressed key, send it to video output
902  */
903 void FullscreenControllerWidget::keyPressEvent( QKeyEvent *event )
904 {
905     emit keyPressed( event );
906 }
907
908 /* */
909 static int FullscreenControllerWidgetFullscreenChanged( vlc_object_t *vlc_object,
910                 const char *variable, vlc_value_t old_val,
911                 vlc_value_t new_val,  void *data )
912 {
913     vout_thread_t *p_vout = (vout_thread_t *) vlc_object;
914
915     msg_Dbg( p_vout, "Qt4: Fullscreen state changed" );
916     FullscreenControllerWidget *p_fs = (FullscreenControllerWidget *)data;
917
918     p_fs->fullscreenChanged( p_vout, new_val.b_bool, var_GetInteger( p_vout, "mouse-hide-timeout" ) );
919
920     return VLC_SUCCESS;
921 }
922 /* */
923 static int FullscreenControllerWidgetMouseMoved( vlc_object_t *vlc_object, const char *variable,
924                                                  vlc_value_t old_val, vlc_value_t new_val,
925                                                  void *data )
926 {
927     vout_thread_t *p_vout = (vout_thread_t *)vlc_object;
928     FullscreenControllerWidget *p_fs = (FullscreenControllerWidget *)data;
929
930     /* Get the value from the Vout - Trust the vout more than Qt */
931     const int i_mousex = var_GetInteger( p_vout, "mouse-x" );
932     const int i_mousey = var_GetInteger( p_vout, "mouse-y" );
933
934     p_fs->mouseChanged( p_vout, i_mousex, i_mousey );
935
936     return VLC_SUCCESS;
937 }
938
939 /**
940  * It is call to update the list of vout handled by the fullscreen controller
941  */
942 void FullscreenControllerWidget::setVoutList( vout_thread_t **pp_vout, int i_vout )
943 {
944     QList<vout_thread_t*> del;
945     QList<vout_thread_t*> add;
946
947     QList<vout_thread_t*> set;
948
949     /* */
950     for( int i = 0; i < i_vout; i++ )
951         set += pp_vout[i];
952
953     /* Vout to remove */
954     vlc_mutex_lock( &lock );
955     foreach( vout_thread_t *p_vout, vout )
956     {
957         if( !set.contains( p_vout ) )
958             del += p_vout;
959     }
960     vlc_mutex_unlock( &lock );
961
962     foreach( vout_thread_t *p_vout, del )
963     {
964         var_DelCallback( p_vout, "fullscreen",
965                          FullscreenControllerWidgetFullscreenChanged, this );
966         vlc_mutex_lock( &lock );
967         fullscreenChanged( p_vout, false, 0 );
968         vout.removeAll( p_vout );
969         vlc_mutex_unlock( &lock );
970
971         vlc_object_release( VLC_OBJECT(p_vout) );
972     }
973
974     /* Vout to track */
975     vlc_mutex_lock( &lock );
976     foreach( vout_thread_t *p_vout, set )
977     {
978         if( !vout.contains( p_vout ) )
979             add += p_vout;
980     }
981     vlc_mutex_unlock( &lock );
982
983     foreach( vout_thread_t *p_vout, add )
984     {
985         vlc_object_hold( VLC_OBJECT(p_vout) );
986
987         vlc_mutex_lock( &lock );
988         vout.append( p_vout );
989         var_AddCallback( p_vout, "fullscreen",
990                          FullscreenControllerWidgetFullscreenChanged, this );
991         /* I miss a add and fire */
992         fullscreenChanged( p_vout, var_GetBool( p_vout, "fullscreen" ),
993                            var_GetInteger( p_vout, "mouse-hide-timeout" ) );
994         vlc_mutex_unlock( &lock );
995     }
996 }
997 /**
998  * Register and unregister callback for mouse moving
999  */
1000 void FullscreenControllerWidget::fullscreenChanged( vout_thread_t *p_vout,
1001         bool b_fs, int i_timeout )
1002 {
1003     /* FIXME - multiple vout (ie multiple mouse position ?) and thread safety if multiple vout ? */
1004     msg_Dbg( p_vout, "Qt: Entering Fullscreen" );
1005
1006     vlc_mutex_lock( &lock );
1007     /* Entering fullscreen, register callback */
1008     if( b_fs && !b_fullscreen )
1009     {
1010         b_fullscreen = true;
1011         i_hide_timeout = i_timeout;
1012         var_AddCallback( p_vout, "mouse-moved",
1013                 FullscreenControllerWidgetMouseMoved, this );
1014     }
1015     /* Quitting fullscreen, unregistering callback */
1016     else if( !b_fs && b_fullscreen )
1017     {
1018         b_fullscreen = false;
1019         i_hide_timeout = i_timeout;
1020         var_DelCallback( p_vout, "mouse-moved",
1021                 FullscreenControllerWidgetMouseMoved, this );
1022
1023         /* Force fs hidding */
1024         IMEvent *eHide = new IMEvent( FullscreenControlHide_Type, 0 );
1025         QApplication::postEvent( this, eHide );
1026     }
1027     vlc_mutex_unlock( &lock );
1028 }
1029
1030 /**
1031  * Mouse change callback (show/hide the controller on mouse movement)
1032  */
1033 void FullscreenControllerWidget::mouseChanged( vout_thread_t *p_vout, int i_mousex, int i_mousey )
1034 {
1035     bool b_toShow;
1036
1037     /* FIXME - multiple vout (ie multiple mouse position ?) and thread safety if multiple vout ? */
1038
1039     b_toShow = false;
1040     if( ( i_mouse_last_move_x == -1 || i_mouse_last_move_y == -1 ) ||
1041         ( abs( i_mouse_last_move_x - i_mousex ) > 2 ||
1042           abs( i_mouse_last_move_y - i_mousey ) > 2 ) )
1043     {
1044         i_mouse_last_move_x = i_mousex;
1045         i_mouse_last_move_y = i_mousey;
1046         b_toShow = true;
1047     }
1048
1049     if( b_toShow )
1050     {
1051         /* Show event */
1052         IMEvent *eShow = new IMEvent( FullscreenControlShow_Type, 0 );
1053         QApplication::postEvent( this, eShow );
1054
1055         /* Plan hide event */
1056         IMEvent *eHide = new IMEvent( FullscreenControlPlanHide_Type, 0 );
1057         QApplication::postEvent( this, eHide );
1058     }
1059 }
1060