git.sesse.net Git - vlc/blob - modules/gui/qt4/components/interface_widgets.cpp

   1 /*****************************************************************************
   2  * interface_widgets.cpp : Custom widgets for the main interface
   3  ****************************************************************************
   4  * Copyright (C) 2006-2008 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Clément Stenac <zorglub@videolan.org>
   8  *          Jean-Baptiste Kempf <jb@videolan.org>
   9  *          Rafaël Carré <funman@videolanorg>
  10  *          Ilkka Ollakka <ileoo@videolan.org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * ( at your option ) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include "components/interface_widgets.hpp"
  32
  33 #include "menus.hpp"             /* Popup menu on bgWidget */
  34
  35 #include <vlc_vout.h>
  36
  37 #include <QLabel>
  38 #include <QToolButton>
  39 #include <QPalette>
  40 #include <QResizeEvent>
  41 #include <QDate>
  42 #include <QMenu>
  43 #include <QWidgetAction>
  44 #include <QDesktopWidget>
  45
  46 #ifdef Q_WS_X11
  47 # include <X11/Xlib.h>
  48 # include <qx11info_x11.h>
  49 static void videoSync( void )
  50 {
  51     /* Make sure the X server has processed all requests.
  52      * This protects other threads using distinct connections from getting
  53      * the video widget window in an inconsistent states. */
  54     XSync( QX11Info::display(), False );
  55 }
  56 #else
  57 # define videoSync() (void)0
  58 #endif
  59
  60 #include <math.h>
  61
  62 class ReparentableWidget : public QWidget
  63 {
  64 private:
  65     VideoWidget *owner;
  66 public:
  67     ReparentableWidget( VideoWidget *owner ) : owner( owner )
  68     {
  69     }
  70
  71 protected:
  72     void keyPressEvent( QKeyEvent *e )
  73     {
  74         emit owner->keyPressed( e );
  75     }
  76 };
  77
  78 /**********************************************************************
  79  * Video Widget. A simple frame on which video is drawn
  80  * This class handles resize issues
  81  **********************************************************************/
  82
  83 VideoWidget::VideoWidget( intf_thread_t *_p_i ) : QFrame( NULL ), p_intf( _p_i )
  84 {
  85     /* Init */
  86     reparentable = NULL;
  87     videoSize.rwidth() = -1;
  88     videoSize.rheight() = -1;
  89
  90     hide();
  91
  92     /* Set the policy to expand in both directions */
  93 //    setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
  94
  95     layout = new QHBoxLayout( this );
  96     layout->setContentsMargins( 0, 0, 0, 0 );
  97     setLayout( layout );
  98 }
  99
 100 VideoWidget::~VideoWidget()
 101 {
 102     /* Ensure we are not leaking the video output. This would crash. */
 103     assert( reparentable == NULL );
 104 }
 105
 106 /**
 107  * Request the video to avoid the conflicts
 108  **/
 109 WId VideoWidget::request( int *pi_x, int *pi_y,
 110                           unsigned int *pi_width, unsigned int *pi_height,
 111                           bool b_keep_size )
 112 {
 113     msg_Dbg( p_intf, "Video was requested %i, %i", *pi_x, *pi_y );
 114
 115     if( reparentable != NULL )
 116     {
 117         msg_Dbg( p_intf, "embedded video already in use" );
 118         return NULL;
 119     }
 120     if( b_keep_size )
 121     {
 122         *pi_width  = size().width();
 123         *pi_height = size().height();
 124     }
 125
 126     /* The Qt4 UI needs a fixed a widget ("this"), so that the parent layout is
 127      * not messed up when we the video is reparented. Hence, we create an extra
 128      * reparentable widget, that will be within the VideoWidget in windowed
 129      * mode, and within the root window (NULL parent) in full-screen mode.
 130      */
 131     reparentable = new ReparentableWidget( this );
 132     QLayout *innerLayout = new QHBoxLayout( reparentable );
 133     innerLayout->setContentsMargins( 0, 0, 0, 0 );
 134
 135     /* The owner of the video window needs a stable handle (WinId). Reparenting
 136      * in Qt4-X11 changes the WinId of the widget, so we need to create another
 137      * dummy widget that stays within the reparentable widget. */
 138     QWidget *stable = new QWidget();
 139     QPalette plt = palette();
 140     plt.setColor( QPalette::Window, Qt::black );
 141     stable->setPalette( plt );
 142     stable->setAutoFillBackground(true);
 143     /* Indicates that the widget wants to draw directly onto the screen.
 144        Widgets with this attribute set do not participate in composition
 145        management */
 146     stable->setAttribute( Qt::WA_PaintOnScreen, true );
 147
 148     innerLayout->addWidget( stable );
 149
 150     reparentable->setLayout( innerLayout );
 151     layout->addWidget( reparentable );
 152
 153 #ifdef Q_WS_X11
 154     /* HACK: Only one X11 client can subscribe to mouse button press events.
 155      * VLC currently handles those in the video display.
 156      * Force Qt4 to unsubscribe from mouse press and release events. */
 157     Display *dpy = QX11Info::display();
 158     Window w = stable->winId();
 159     XWindowAttributes attr;
 160
 161     XGetWindowAttributes( dpy, w, &attr );
 162     attr.your_event_mask &= ~(ButtonPressMask|ButtonReleaseMask);
 163     XSelectInput( dpy, w, attr.your_event_mask );
 164 #endif
 165     videoSync();
 166 #ifndef NDEBUG
 167     msg_Dbg( p_intf, "embedded video ready (handle %p)",
 168              (void *)stable->winId() );
 169 #endif
 170     return stable->winId();
 171 }
 172
 173 /* Set the Widget to the correct Size */
 174 /* Function has to be called by the parent
 175    Parent has to care about resizing itself */
 176 void VideoWidget::SetSizing( unsigned int w, unsigned int h )
 177 {
 178     msg_Dbg( p_intf, "Video is resizing to: %i %i", w, h );
 179     videoSize.rwidth() = w;
 180     videoSize.rheight() = h;
 181     if( !isVisible() ) show();
 182     updateGeometry(); // Needed for deinterlace
 183     videoSync();
 184 }
 185
 186 void VideoWidget::SetFullScreen( bool b_fs )
 187 {
 188     const Qt::WindowStates curstate = reparentable->windowState();
 189     Qt::WindowStates newstate = curstate;
 190     Qt::WindowFlags  newflags = reparentable->windowFlags();
 191
 192
 193     if( b_fs )
 194     {
 195         newstate |= Qt::WindowFullScreen;
 196         newflags |= Qt::WindowStaysOnTopHint;
 197     }
 198     else
 199     {
 200         newstate &= ~Qt::WindowFullScreen;
 201         newflags &= ~Qt::WindowStaysOnTopHint;
 202     }
 203     if( newstate == curstate )
 204         return; /* no changes needed */
 205
 206     if( b_fs )
 207     {   /* Go full-screen */
 208         int numscreen = QApplication::desktop()->screenNumber( p_intf->p_sys->p_mi );
 209         QRect screenres = QApplication::desktop()->screenGeometry( numscreen );
 210
 211         reparentable->setWindowState( newstate );
 212         reparentable->setParent( NULL );
 213         reparentable->setWindowFlags( newflags );
 214         /* To be sure window is on proper-screen in xinerama */
 215         if( !screenres.contains( reparentable->pos() ) )
 216         {
 217             msg_Dbg( p_intf, "Moving video to correct screen");
 218             reparentable->move( QPoint( screenres.x(), screenres.y() ) );
 219         }
 220         reparentable->show();
 221     }
 222     else
 223     {   /* Go windowed */
 224         reparentable->setWindowFlags( newflags );
 225         layout->addWidget( reparentable );
 226         reparentable->setWindowState( newstate );
 227     }
 228     videoSync();
 229 }
 230
 231 void VideoWidget::release( void )
 232 {
 233     msg_Dbg( p_intf, "Video is not needed anymore" );
 234     //layout->removeWidget( reparentable );
 235     delete reparentable;
 236     reparentable = NULL;
 237     videoSize.rwidth() = 0;
 238     videoSize.rheight() = 0;
 239     updateGeometry();
 240     hide();
 241 }
 242
 243 QSize VideoWidget::sizeHint() const
 244 {
 245     return videoSize;
 246 }
 247
 248 /**********************************************************************
 249  * Background Widget. Show a simple image background. Currently,
 250  * it's album art if present or cone.
 251  **********************************************************************/
 252 #define ICON_SIZE 128
 253 #define MAX_BG_SIZE 400
 254 #define MIN_BG_SIZE 128
 255
 256 BackgroundWidget::BackgroundWidget( intf_thread_t *_p_i )
 257                  :QWidget( NULL ), p_intf( _p_i )
 258 {
 259     /* We should use that one to take the more size it can */
 260     setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding);
 261
 262     /* A dark background */
 263     setAutoFillBackground( true );
 264     plt = palette();
 265     plt.setColor( QPalette::Active, QPalette::Window , Qt::black );
 266     plt.setColor( QPalette::Inactive, QPalette::Window , Qt::black );
 267     setPalette( plt );
 268
 269     /* A cone in the middle */
 270     label = new QLabel;
 271     label->setMargin( 5 );
 272     label->setMaximumHeight( MAX_BG_SIZE );
 273     label->setMaximumWidth( MAX_BG_SIZE );
 274     label->setMinimumHeight( MIN_BG_SIZE );
 275     label->setMinimumWidth( MIN_BG_SIZE );
 276     label->setAlignment( Qt::AlignCenter );
 277     if( QDate::currentDate().dayOfYear() >= 354 )
 278         label->setPixmap( QPixmap( ":/logo/vlc128-christmas.png" ) );
 279     else
 280         label->setPixmap( QPixmap( ":/logo/vlc128.png" ) );
 281
 282     QGridLayout *backgroundLayout = new QGridLayout( this );
 283     backgroundLayout->addWidget( label, 0, 1 );
 284     backgroundLayout->setColumnStretch( 0, 1 );
 285     backgroundLayout->setColumnStretch( 2, 1 );
 286
 287     CONNECT( THEMIM->getIM(), artChanged( QString ),
 288              this, updateArt( const QString& ) );
 289 }
 290
 291 BackgroundWidget::~BackgroundWidget()
 292 {}
 293
 294 void BackgroundWidget::resizeEvent( QResizeEvent * event )
 295 {
 296     if( event->size().height() <= MIN_BG_SIZE )
 297         label->hide();
 298     else
 299         label->show();
 300 }
 301
 302 void BackgroundWidget::updateArt( const QString& url )
 303 {
 304     if( url.isEmpty() )
 305     {
 306         if( QDate::currentDate().dayOfYear() >= 354 )
 307             label->setPixmap( QPixmap( ":/logo/vlc128-christmas.png" ) );
 308         else
 309             label->setPixmap( QPixmap( ":/logo/vlc128.png" ) );
 310     }
 311     else
 312     {
 313         QPixmap pixmap( url );
 314         if( pixmap.width() > label->maximumWidth() ||
 315             pixmap.height() > label->maximumHeight() )
 316         {
 317             pixmap = pixmap.scaled( label->maximumWidth(),
 318                           label->maximumHeight(), Qt::KeepAspectRatio );
 319         }
 320
 321         label->setPixmap( pixmap );
 322     }
 323 }
 324
 325 void BackgroundWidget::contextMenuEvent( QContextMenuEvent *event )
 326 {
 327     QVLCMenu::PopupMenu( p_intf, true );
 328     event->accept();
 329 }
 330
 331 #if 0
 332 #include <QPushButton>
 333 #include <QHBoxLayout>
 334
 335 /**********************************************************************
 336  * Visualization selector panel
 337  **********************************************************************/
 338 VisualSelector::VisualSelector( intf_thread_t *_p_i ) :
 339                                 QFrame( NULL ), p_intf( _p_i )
 340 {
 341     QHBoxLayout *layout = new QHBoxLayout( this );
 342     layout->setMargin( 0 );
 343     QPushButton *prevButton = new QPushButton( "Prev" );
 344     QPushButton *nextButton = new QPushButton( "Next" );
 345     layout->addWidget( prevButton );
 346     layout->addWidget( nextButton );
 347
 348     layout->addStretch( 10 );
 349     layout->addWidget( new QLabel( qtr( "Current visualization" ) ) );
 350
 351     current = new QLabel( qtr( "None" ) );
 352     layout->addWidget( current );
 353
 354     BUTTONACT( prevButton, prev() );
 355     BUTTONACT( nextButton, next() );
 356
 357     setLayout( layout );
 358     setMaximumHeight( 35 );
 359 }
 360
 361 VisualSelector::~VisualSelector()
 362 {}
 363
 364 void VisualSelector::prev()
 365 {
 366     char *psz_new = aout_VisualPrev( p_intf );
 367     if( psz_new )
 368     {
 369         current->setText( qfu( psz_new ) );
 370         free( psz_new );
 371     }
 372 }
 373
 374 void VisualSelector::next()
 375 {
 376     char *psz_new = aout_VisualNext( p_intf );
 377     if( psz_new )
 378     {
 379         current->setText( qfu( psz_new ) );
 380         free( psz_new );
 381     }
 382 }
 383 #endif
 384
 385 SpeedLabel::SpeedLabel( intf_thread_t *_p_intf, const QString& text,
 386                         QWidget *parent )
 387            : QLabel( text, parent ), p_intf( _p_intf )
 388 {
 389     setToolTip( qtr( "Current playback speed.\nClick to adjust" ) );
 390
 391     /* Create the Speed Control Widget */
 392     speedControl = new SpeedControlWidget( p_intf, this );
 393     speedControlMenu = new QMenu( this );
 394
 395     QWidgetAction *widgetAction = new QWidgetAction( speedControl );
 396     widgetAction->setDefaultWidget( speedControl );
 397     speedControlMenu->addAction( widgetAction );
 398
 399     /* Change the SpeedRate in the Status Bar */
 400     CONNECT( THEMIM->getIM(), rateChanged( int ), this, setRate( int ) );
 401
 402     CONNECT( THEMIM, inputChanged( input_thread_t * ),
 403              speedControl, activateOnState() );
 404
 405 }
 406 SpeedLabel::~SpeedLabel()
 407 {
 408         delete speedControl;
 409         delete speedControlMenu;
 410 }
 411 /****************************************************************************
 412  * Small right-click menu for rate control
 413  ****************************************************************************/
 414 void SpeedLabel::showSpeedMenu( QPoint pos )
 415 {
 416     speedControlMenu->exec( QCursor::pos() - pos
 417                           + QPoint( 0, height() ) );
 418 }
 419
 420 void SpeedLabel::setRate( int rate )
 421 {
 422     QString str;
 423     str.setNum( ( 1000 / (double)rate ), 'f', 2 );
 424     str.append( "x" );
 425     setText( str );
 426     setToolTip( str );
 427     speedControl->updateControls( rate );
 428 }
 429
 430 /**********************************************************************
 431  * Speed control widget
 432  **********************************************************************/
 433 SpeedControlWidget::SpeedControlWidget( intf_thread_t *_p_i, QWidget *_parent )
 434                     : QFrame( _parent ), p_intf( _p_i )
 435 {
 436     QSizePolicy sizePolicy( QSizePolicy::Maximum, QSizePolicy::Fixed );
 437     sizePolicy.setHorizontalStretch( 0 );
 438     sizePolicy.setVerticalStretch( 0 );
 439
 440     speedSlider = new QSlider( this );
 441     speedSlider->setSizePolicy( sizePolicy );
 442     speedSlider->setMaximumSize( QSize( 80, 200 ) );
 443     speedSlider->setOrientation( Qt::Vertical );
 444     speedSlider->setTickPosition( QSlider::TicksRight );
 445
 446     speedSlider->setRange( -34, 34 );
 447     speedSlider->setSingleStep( 1 );
 448     speedSlider->setPageStep( 1 );
 449     speedSlider->setTickInterval( 17 );
 450
 451     CONNECT( speedSlider, valueChanged( int ), this, updateRate( int ) );
 452
 453     QToolButton *normalSpeedButton = new QToolButton( this );
 454     normalSpeedButton->setMaximumSize( QSize( 26, 20 ) );
 455     normalSpeedButton->setAutoRaise( true );
 456     normalSpeedButton->setText( "1x" );
 457     normalSpeedButton->setToolTip( qtr( "Revert to normal play speed" ) );
 458
 459     CONNECT( normalSpeedButton, clicked(), this, resetRate() );
 460
 461     QVBoxLayout *speedControlLayout = new QVBoxLayout( this );
 462     speedControlLayout->setLayoutMargins( 4, 4, 4, 4, 4 );
 463     speedControlLayout->setSpacing( 4 );
 464     speedControlLayout->addWidget( speedSlider );
 465     speedControlLayout->addWidget( normalSpeedButton );
 466
 467     activateOnState();
 468 }
 469
 470 void SpeedControlWidget::activateOnState()
 471 {
 472     speedSlider->setEnabled( THEMIM->getIM()->hasInput() );
 473 }
 474
 475 void SpeedControlWidget::updateControls( int rate )
 476 {
 477     if( speedSlider->isSliderDown() )
 478     {
 479         //We don't want to change anything if the user is using the slider
 480         return;
 481     }
 482
 483     double value = 17 * log( (double)INPUT_RATE_DEFAULT / rate ) / log( 2 );
 484     int sliderValue = (int) ( ( value > 0 ) ? value + .5 : value - .5 );
 485
 486     if( sliderValue < speedSlider->minimum() )
 487     {
 488         sliderValue = speedSlider->minimum();
 489     }
 490     else if( sliderValue > speedSlider->maximum() )
 491     {
 492         sliderValue = speedSlider->maximum();
 493     }
 494
 495     //Block signals to avoid feedback loop
 496     speedSlider->blockSignals( true );
 497     speedSlider->setValue( sliderValue );
 498     speedSlider->blockSignals( false );
 499 }
 500
 501 void SpeedControlWidget::updateRate( int sliderValue )
 502 {
 503     double speed = pow( 2, (double)sliderValue / 17 );
 504     int rate = INPUT_RATE_DEFAULT / speed;
 505
 506     THEMIM->getIM()->setRate(rate);
 507 }
 508
 509 void SpeedControlWidget::resetRate()
 510 {
 511     THEMIM->getIM()->setRate( INPUT_RATE_DEFAULT );
 512 }
 513
 514 CoverArtLabel::CoverArtLabel( QWidget *parent, intf_thread_t *_p_i )
 515               : QLabel( parent ), p_intf( _p_i )
 516 {
 517     setContextMenuPolicy( Qt::ActionsContextMenu );
 518     CONNECT( this, updateRequested(), this, askForUpdate() );
 519
 520     setMinimumHeight( 128 );
 521     setMinimumWidth( 128 );
 522     setMaximumHeight( 128 );
 523     setMaximumWidth( 128 );
 524     setScaledContents( false );
 525     setAlignment( Qt::AlignCenter );
 526
 527     QList< QAction* > artActions = actions();
 528     QAction *action = new QAction( qtr( "Download cover art" ), this );
 529     CONNECT( action, triggered(), this, askForUpdate() );
 530     addAction( action );
 531
 532     showArtUpdate( "" );
 533 }
 534
 535 CoverArtLabel::~CoverArtLabel()
 536 {
 537     QList< QAction* > artActions = actions();
 538     foreach( QAction *act, artActions )
 539         removeAction( act );
 540 }
 541
 542 void CoverArtLabel::showArtUpdate( const QString& url )
 543 {
 544     QPixmap pix;
 545     if( !url.isEmpty()  && pix.load( url ) )
 546     {
 547         pix = pix.scaled( maximumWidth(), maximumHeight(),
 548                           Qt::KeepAspectRatioByExpanding );
 549     }
 550     else
 551     {
 552         pix = QPixmap( ":/noart.png" );
 553     }
 554     setPixmap( pix );
 555 }
 556
 557 void CoverArtLabel::askForUpdate()
 558 {
 559     THEMIM->getIM()->requestArtUpdate();
 560 }
 561
 562 TimeLabel::TimeLabel( intf_thread_t *_p_intf  ) :QLabel(), p_intf( _p_intf )
 563 {
 564    b_remainingTime = false;
 565    setText( " --:--/--:-- " );
 566    setAlignment( Qt::AlignRight | Qt::AlignVCenter );
 567    setToolTip( qtr( "Toggle between elapsed and remaining time" ) );
 568
 569
 570    CONNECT( THEMIM->getIM(), cachingChanged( float ),
 571             this, setCaching( float ) );
 572    CONNECT( THEMIM->getIM(), positionUpdated( float, int, int ),
 573              this, setDisplayPosition( float, int, int ) );
 574 }
 575
 576 void TimeLabel::setDisplayPosition( float pos, int time, int length )
 577 {
 578     if( pos == -1.f )
 579     {
 580         setText( " --:--/--:-- " );
 581         return;
 582     }
 583
 584     char psz_length[MSTRTIME_MAX_SIZE], psz_time[MSTRTIME_MAX_SIZE];
 585     secstotimestr( psz_length, length );
 586     secstotimestr( psz_time, ( b_remainingTime && length ) ? length - time
 587                                                            : time );
 588
 589     QString timestr;
 590     timestr.sprintf( "%s/%s", psz_time,
 591                             ( !length && time ) ? "--:--" : psz_length );
 592
 593     /* Add a minus to remaining time*/
 594     if( b_remainingTime && length ) setText( " -"+timestr+" " );
 595     else setText( " "+timestr+" " );
 596 }
 597
 598 void TimeLabel::toggleTimeDisplay()
 599 {
 600     b_remainingTime = !b_remainingTime;
 601 }
 602
 603 void TimeLabel::setCaching( float f_cache )
 604 {
 605     QString amount;
 606     amount.setNum( (int)(100 * f_cache) );
 607     msg_Dbg( p_intf, "New caching: %d", (int)(100*f_cache));
 608     setText( "Buff: " + amount + "%" );
 609 }
 610
 611