mediaplayer.cpp Example File
demos/mediaplayer/mediaplayer.cpp

 /****************************************************************************
 **
 ** Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
 **
 ** This file is part of the documentation of the Qt Toolkit.
 **
 ** Licensees holding a valid Qt License Agreement may use this file in
 ** accordance with the rights, responsibilities and obligations
 ** contained therein.  Please consult your licensing agreement or
 ** contact qt-sales@nokia.com if any conditions of this licensing
 ** agreement are not clear to you.
 **
 ** Further information about Qt licensing is available at:
 ** http://trolltech.com/products/appdev/licensing.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ***************************************************************************/

 #include <QtGui>

 #define SLIDER_RANGE 8
 #define TICKINTERVAL 4

 #include "mediaplayer.h"
 #include "ui_settings.h"

 class MediaVideoWidget : public Phonon::VideoWidget
 {
 public:
     MediaVideoWidget(MediaPlayer *player, QWidget *parent = 0) :
         Phonon::VideoWidget(parent), m_player(player), m_action(this)
     {
         m_action.setCheckable(true);
         m_action.setChecked(false);
         m_action.setShortcut(QKeySequence( Qt::AltModifier + Qt::Key_Return));
         m_action.setShortcutContext(Qt::WindowShortcut);
         connect(&m_action, SIGNAL(toggled(bool)), SLOT(setFullScreen(bool)));
         addAction(&m_action);
         setAcceptDrops(true);
     }

 protected:
     void mouseDoubleClickEvent(QMouseEvent *e)
     {
         Phonon::VideoWidget::mouseDoubleClickEvent(e);
         setFullScreen(!isFullScreen());
     }

     void keyPressEvent(QKeyEvent *e)
     {
         if (e->key() == Qt::Key_Space && !e->modifiers()) {
             m_player->playPause();
             e->accept();
             return;
         } else if (e->key() == Qt::Key_Escape && !e->modifiers()) {
             setFullScreen(false);
             e->accept();
             return;
         }
         Phonon::VideoWidget::keyPressEvent(e);
     }

     bool event(QEvent *e)
     {
         switch(e->type())
         {
         case QEvent::Close:
             //we just ignore the cose events on the video widget
             //this prevents ALT+F4 from having an effect in fullscreen mode
             e->ignore();
             return true;
         case QEvent::MouseMove:
             unsetCursor();
             //fall through
         case QEvent::WindowStateChange:
             {
                 //we just update the state of the checkbox, in case it wasn't already
                 m_action.setChecked(windowState() & Qt::WindowFullScreen);
                 const Qt::WindowFlags flags = m_player->windowFlags();
                 if (windowState() & Qt::WindowFullScreen) {
                     m_timer.start(1000, this);
                 } else {
                     m_timer.stop();
                     unsetCursor();
                 }
             }
             break;
         default:
             break;
         }

         return Phonon::VideoWidget::event(e);
     }

     void timerEvent(QTimerEvent *e)
     {
         if (e->timerId() == m_timer.timerId()) {
             //let's store the cursor shape
             setCursor(Qt::BlankCursor);
         }
         Phonon::VideoWidget::timerEvent(e);
     }

     void dropEvent(QDropEvent *e)
     {
         m_player->handleDrop(e);
     }

     void dragEnterEvent(QDragEnterEvent *e) {
         if (e->mimeData()->hasUrls())
             e->acceptProposedAction();
     }

 private:
     MediaPlayer *m_player;
     QBasicTimer m_timer;
     QAction m_action;
 };

 MediaPlayer::MediaPlayer(const QString &filePath) :
         playButton(0), volumeLabel(0), nextEffect(0), settingsDialog(0), ui(0),
             m_AudioOutput(Phonon::VideoCategory),
             m_videoWidget(new MediaVideoWidget(this))
 {
     setWindowTitle("Media Player");
     setContextMenuPolicy(Qt::CustomContextMenu);
     m_videoWidget->setContextMenuPolicy(Qt::CustomContextMenu);

     QSize buttonSize(34, 28);

     QPushButton *openButton = new QPushButton(this);

     openButton->setIcon(style()->standardIcon(QStyle::SP_DialogOpenButton));
     QPalette bpal;
     QColor arrowcolor = bpal.buttonText().color();
     if (arrowcolor == Qt::black)
         arrowcolor = QColor(80, 80, 80);
     bpal.setBrush(QPalette::ButtonText, arrowcolor);
     openButton->setPalette(bpal);

     rewindButton = new QPushButton(this);
     rewindButton->setIcon(style()->standardIcon(QStyle::SP_MediaSkipBackward));

     forwardButton = new QPushButton(this);
     forwardButton->setIcon(style()->standardIcon(QStyle::SP_MediaSkipForward));
     forwardButton->setEnabled(false);

     playButton = new QPushButton(this);
     playIcon = style()->standardIcon(QStyle::SP_MediaPlay);
     pauseIcon = style()->standardIcon(QStyle::SP_MediaPause);
     playButton->setIcon(playIcon);

     slider = new Phonon::SeekSlider(this);
     slider->setMediaObject(&m_MediaObject);
     volume = new QSlider(Qt::Horizontal, this);

     QVBoxLayout *vLayout = new QVBoxLayout(this);
     vLayout->setContentsMargins(8, 8, 8, 8);

     QHBoxLayout *layout = new QHBoxLayout();

     info = new QLabel(this);
     info->setMinimumHeight(70);
     info->setAcceptDrops(false);
     info->setMargin(2);
     info->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
     info->setLineWidth(2);
     info->setAutoFillBackground(true);

     QPalette palette;
     palette.setBrush(QPalette::WindowText, Qt::white);
 #ifndef Q_WS_MAC
     openButton->setMinimumSize(47, buttonSize.height());
     rewindButton->setMinimumSize(buttonSize);
     forwardButton->setMinimumSize(buttonSize);
     playButton->setMinimumSize(buttonSize);
 #endif
     info->setStyleSheet("border-image:url(:/images/screen.png) ; border-width:3px");
     info->setPalette(palette);
     info->setText("<center>No media</center>");

     volume->setRange(0, 100);
     volume->setValue(100);
     volume->setMinimumWidth(40);

     layout->addWidget(openButton);
     layout->addWidget(rewindButton);
     layout->addWidget(playButton);
     layout->addWidget(forwardButton);

     volumeLabel = new QLabel(this);
     volumeIcon = style()->standardPixmap(QStyle::SP_MediaVolume);
     mutedIcon = style()->standardPixmap(QStyle::SP_MediaVolumeMuted);
     volumeLabel->setPixmap(volumeIcon);
     volume->setFixedWidth(100);
     layout->addStretch();
     layout->addWidget(volumeLabel);
     layout->addWidget(volume);

     vLayout->addWidget(info);
     initVideoWindow();
     vLayout->addWidget(&m_videoWindow);
     QVBoxLayout *buttonPanelLayout = new QVBoxLayout();
     m_videoWindow.hide();
     buttonPanelLayout->addLayout(layout);

     timeLabel = new QLabel(this);
     progressLabel = new QLabel(this);
     QWidget *sliderPanel = new QWidget(this);
     QHBoxLayout *sliderLayout = new QHBoxLayout();
     sliderLayout->addWidget(slider);
     sliderLayout->addWidget(timeLabel);
     sliderLayout->addWidget(progressLabel);
     sliderLayout->setContentsMargins(0, 0, 0, 0);
     sliderPanel->setLayout(sliderLayout);

     buttonPanelLayout->addWidget(sliderPanel);
     buttonPanelLayout->setContentsMargins(0, 0, 0, 0);
 #ifdef Q_OS_MAC
     layout->setSpacing(4);
     buttonPanelLayout->setSpacing(0);
     info->setMinimumHeight(100);
     info->setFont(QFont("verdana", 15));
     // QStyle *flatButtonStyle = new QWindowsStyle;
     openButton->setFocusPolicy(Qt::NoFocus);
     // openButton->setStyle(flatButtonStyle);
     // playButton->setStyle(flatButtonStyle);
     // rewindButton->setStyle(flatButtonStyle);
     // forwardButton->setStyle(flatButtonStyle);
  #endif
     QWidget *buttonPanelWidget = new QWidget(this);
     buttonPanelWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
     buttonPanelWidget->setLayout(buttonPanelLayout);
     vLayout->addWidget(buttonPanelWidget);

     QHBoxLayout *labelLayout = new QHBoxLayout();

     vLayout->addLayout(labelLayout);
     setLayout(vLayout);

     // Create menu bar:
     fileMenu = new QMenu(this);
     QAction *openFileAction = fileMenu->addAction(tr("Open &File..."));
     QAction *openUrlAction = fileMenu->addAction(tr("Open &Location..."));

     fileMenu->addSeparator();
     QMenu *aspectMenu = fileMenu->addMenu(tr("&Aspect ratio"));
     QActionGroup *aspectGroup = new QActionGroup(aspectMenu);
     connect(aspectGroup, SIGNAL(triggered(QAction *)), this, SLOT(aspectChanged(QAction *)));
     aspectGroup->setExclusive(true);
     QAction *aspectActionAuto = aspectMenu->addAction("Auto");
     aspectActionAuto->setCheckable(true);
     aspectActionAuto->setChecked(true);
     aspectGroup->addAction(aspectActionAuto);
     QAction *aspectActionScale = aspectMenu->addAction("Scale");
     aspectActionScale->setCheckable(true);
     aspectGroup->addAction(aspectActionScale);
     QAction *aspectAction16_9 = aspectMenu->addAction("16/9");
     aspectAction16_9->setCheckable(true);
     aspectGroup->addAction(aspectAction16_9);
     QAction *aspectAction4_3 = aspectMenu->addAction("4/3");
     aspectAction4_3->setCheckable(true);
     aspectGroup->addAction(aspectAction4_3);

     QMenu *scaleMenu = fileMenu->addMenu(tr("&Scale mode"));
     QActionGroup *scaleGroup = new QActionGroup(scaleMenu);
     connect(scaleGroup, SIGNAL(triggered(QAction *)), this, SLOT(scaleChanged(QAction *)));
     scaleGroup->setExclusive(true);
     QAction *scaleActionFit = scaleMenu->addAction("Fit in view");
     scaleActionFit->setCheckable(true);
     scaleActionFit->setChecked(true);
     scaleGroup->addAction(scaleActionFit);
     QAction *scaleActionCrop = scaleMenu->addAction("Scale and crop");
     scaleActionCrop->setCheckable(true);
     scaleGroup->addAction(scaleActionCrop);

     fileMenu->addSeparator();
     QAction *settingsAction = fileMenu->addAction(tr("&Settings..."));

     // Setup signal connections:
     connect(rewindButton, SIGNAL(clicked()), this, SLOT(rewind()));
     //connect(openButton, SIGNAL(clicked()), this, SLOT(openFile()));
     openButton->setMenu(fileMenu);

     connect(playButton, SIGNAL(clicked()), this, SLOT(playPause()));
     connect(forwardButton, SIGNAL(clicked()), this, SLOT(forward()));
     connect(volume, SIGNAL(valueChanged(int)), this, SLOT(setVolume(int)));
     //connect(openButton, SIGNAL(clicked()), this, SLOT(openFile()));
     connect(settingsAction, SIGNAL(triggered(bool)), this, SLOT(showSettingsDialog()));
     connect(openUrlAction, SIGNAL(triggered(bool)), this, SLOT(openUrl()));
     connect(openFileAction, SIGNAL(triggered(bool)), this, SLOT(openFile()));

     connect(m_videoWidget, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(showContextMenu(const QPoint &)));
     connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(showContextMenu(const QPoint &)));
     connect(&m_MediaObject, SIGNAL(metaDataChanged()), this, SLOT(updateInfo()));
     connect(&m_MediaObject, SIGNAL(totalTimeChanged(qint64)), this, SLOT(updateTime()));
     connect(&m_MediaObject, SIGNAL(tick(qint64)), this, SLOT(updateTime()));
     connect(&m_MediaObject, SIGNAL(finished()), this, SLOT(finished()));
     connect(&m_MediaObject, SIGNAL(stateChanged(Phonon::State, Phonon::State)), this, SLOT(stateChanged(Phonon::State, Phonon::State)));
     connect(&m_MediaObject, SIGNAL(bufferStatus(int)), this, SLOT(bufferStatus(int)));

     rewindButton->setEnabled(false);
     playButton->setEnabled(false);
     setAcceptDrops(true);

     m_MediaObject.setTickInterval(250);

     m_audioOutputPath = Phonon::createPath(&m_MediaObject, &m_AudioOutput);
     Phonon::createPath(&m_MediaObject, m_videoWidget);

     if (!filePath.isEmpty())
         setFile(filePath);
     resize(minimumSizeHint());
 }

 void MediaPlayer::stateChanged(Phonon::State newstate, Phonon::State oldstate)
 {
     Q_UNUSED(oldstate);

     if (oldstate == Phonon::LoadingState) {
         m_videoWindow.setVisible(m_MediaObject.hasVideo());
         info->setVisible(!m_MediaObject.hasVideo());
         QRect videoHintRect = QRect(QPoint(0, 0), m_videoWindow.sizeHint());
         QRect newVideoRect = QApplication::desktop()->screenGeometry().intersected(videoHintRect);
         if (m_MediaObject.hasVideo()){
             // Flush event que so that sizeHint takes the
             // recently shown/hidden m_videoWindow into account:
             qApp->processEvents();
             resize(sizeHint());
         } else
             resize(minimumSize());
     }

     switch (newstate) {
         case Phonon::ErrorState:
             QMessageBox::warning(this, "Phonon Mediaplayer", m_MediaObject.errorString(), QMessageBox::Close);
             if (m_MediaObject.errorType() == Phonon::FatalError) {
                 playButton->setEnabled(false);
                 rewindButton->setEnabled(false);
             } else {
                 m_MediaObject.pause();
             }
             break;
         case Phonon::PausedState:
         case Phonon::StoppedState:
             playButton->setIcon(playIcon);
             if (m_MediaObject.currentSource().type() != Phonon::MediaSource::Invalid){
                 playButton->setEnabled(true);
                 rewindButton->setEnabled(true);
             } else {
                 playButton->setEnabled(false);
                 rewindButton->setEnabled(false);
             }
             break;
         case Phonon::PlayingState:
             playButton->setEnabled(true);
             playButton->setIcon(pauseIcon);
             if (m_MediaObject.hasVideo())
                 m_videoWindow.show();
             // Fall through
         case Phonon::BufferingState:
             rewindButton->setEnabled(true);
             break;
         case Phonon::LoadingState:
             rewindButton->setEnabled(false);
             break;
     }

 }

 void MediaPlayer::initSettingsDialog()
 {
     settingsDialog = new QDialog(this);
     ui = new Ui_settings();
     ui->setupUi(settingsDialog);

     connect(ui->brightnessSlider, SIGNAL(valueChanged(int)), this, SLOT(setBrightness(int)));
     connect(ui->hueSlider, SIGNAL(valueChanged(int)), this, SLOT(setHue(int)));
     connect(ui->saturationSlider, SIGNAL(valueChanged(int)), this, SLOT(setSaturation(int)));
     connect(ui->contrastSlider , SIGNAL(valueChanged(int)), this, SLOT(setContrast(int)));
     connect(ui->aspectCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(setAspect(int)));
     connect(ui->scalemodeCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(setScale(int)));

     ui->brightnessSlider->setValue(int(m_videoWidget->brightness() * SLIDER_RANGE));
     ui->hueSlider->setValue(int(m_videoWidget->hue() * SLIDER_RANGE));
     ui->saturationSlider->setValue(int(m_videoWidget->saturation() * SLIDER_RANGE));
     ui->contrastSlider->setValue(int(m_videoWidget->contrast() * SLIDER_RANGE));
     ui->aspectCombo->setCurrentIndex(m_videoWidget->aspectRatio());
     ui->scalemodeCombo->setCurrentIndex(m_videoWidget->scaleMode());
     connect(ui->effectButton, SIGNAL(clicked()), this, SLOT(configureEffect()));

 #ifdef Q_WS_X11
     //Cross fading is not currently implemented in the GStreamer backend
     ui->crossFadeSlider->setVisible(false);
     ui->crossFadeLabel->setVisible(false);
     ui->crossFadeLabel1->setVisible(false);
     ui->crossFadeLabel2->setVisible(false);
     ui->crossFadeLabel3->setVisible(false);
 #endif
     ui->crossFadeSlider->setValue((int)(2 * m_MediaObject.transitionTime() / 1000.0f));

     // Insert audio devices:
     QList<Phonon::AudioOutputDevice> devices = Phonon::BackendCapabilities::availableAudioOutputDevices();
     for (int i=0; i<devices.size(); i++){
         QString itemText = devices[i].name();
         if (!devices[i].description().isEmpty()) {
             itemText += QString::fromLatin1(" (%1)").arg(devices[i].description());
         }
         ui->deviceCombo->addItem(itemText);
         if (devices[i] == m_AudioOutput.outputDevice())
             ui->deviceCombo->setCurrentIndex(i);
     }

     // Insert audio effects:
     ui->audioEffectsCombo->addItem("<no effect>");
     QList<Phonon::Effect *> currEffects = m_audioOutputPath.effects();
     Phonon::Effect *currEffect = currEffects.size() ? currEffects[0] : 0;
     QList<Phonon::EffectDescription> availableEffects = Phonon::BackendCapabilities::availableAudioEffects();
     for (int i=0; i<availableEffects.size(); i++){
         ui->audioEffectsCombo->addItem(availableEffects[i].name());
         if (currEffect && availableEffects[i] == currEffect->description())
             ui->audioEffectsCombo->setCurrentIndex(i+1);
     }
     connect(ui->audioEffectsCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(effectChanged()));

 }

 void MediaPlayer::effectChanged()
 {
     int currentIndex = ui->audioEffectsCombo->currentIndex();
     if (ui->audioEffectsCombo->currentIndex()) {
         QList<Phonon::EffectDescription> availableEffects = Phonon::BackendCapabilities::availableAudioEffects();
         Phonon::EffectDescription chosenEffect = availableEffects[ui->audioEffectsCombo->currentIndex() - 1];

         QList<Phonon::Effect *> currEffects = m_audioOutputPath.effects();
         Phonon::Effect *currentEffect = currEffects.size() ? currEffects[0] : 0;

         // Deleting the running effect will stop playback, it is deleted when removed from path
         if (nextEffect && !(currentEffect && (currentEffect->description().name() == nextEffect->description().name())))
             delete nextEffect;

         nextEffect = new Phonon::Effect(chosenEffect);
     }
     ui->effectButton->setEnabled(currentIndex);
 }

 void MediaPlayer::showSettingsDialog()
 {
     if (!settingsDialog)
         initSettingsDialog();

     float oldBrightness = m_videoWidget->brightness();
     float oldHue = m_videoWidget->hue();
     float oldSaturation = m_videoWidget->saturation();
     float oldContrast = m_videoWidget->contrast();
     Phonon::VideoWidget::AspectRatio oldAspect = m_videoWidget->aspectRatio();
     Phonon::VideoWidget::ScaleMode oldScale = m_videoWidget->scaleMode();
     int currentEffect = ui->audioEffectsCombo->currentIndex();
     settingsDialog->exec();

     if (settingsDialog->result() == QDialog::Accepted){
         m_MediaObject.setTransitionTime((int)(1000 * float(ui->crossFadeSlider->value()) / 2.0f));
         QList<Phonon::AudioOutputDevice> devices = Phonon::BackendCapabilities::availableAudioOutputDevices();
         m_AudioOutput.setOutputDevice(devices[ui->deviceCombo->currentIndex()]);
         QList<Phonon::Effect *> currEffects = m_audioOutputPath.effects();
         QList<Phonon::EffectDescription> availableEffects = Phonon::BackendCapabilities::availableAudioEffects();

         if (ui->audioEffectsCombo->currentIndex() > 0){
             Phonon::Effect *currentEffect = currEffects.size() ? currEffects[0] : 0;
             if (!currentEffect || currentEffect->description() != nextEffect->description()){
                 foreach(Phonon::Effect *effect, currEffects) {
                     m_audioOutputPath.removeEffect(effect);
                     delete effect;
                 }
                 m_audioOutputPath.insertEffect(nextEffect);
             }
         } else {
             foreach(Phonon::Effect *effect, currEffects) {
                 m_audioOutputPath.removeEffect(effect);
                 delete effect;
                 nextEffect = 0;
             }
         }
     } else {
         // Restore previous settings
         m_videoWidget->setBrightness(oldBrightness);
         m_videoWidget->setSaturation(oldSaturation);
         m_videoWidget->setHue(oldHue);
         m_videoWidget->setContrast(oldContrast);
         m_videoWidget->setAspectRatio(oldAspect);
         m_videoWidget->setScaleMode(oldScale);
         ui->audioEffectsCombo->setCurrentIndex(currentEffect);
     }
 }

 void MediaPlayer::initVideoWindow()
 {
     QVBoxLayout *videoLayout = new QVBoxLayout();
     videoLayout->addWidget(m_videoWidget);
     videoLayout->setContentsMargins(0, 0, 0, 0);
     m_videoWindow.setLayout(videoLayout);
     m_videoWindow.setMinimumSize(100, 100);
 }

 void MediaPlayer::updateEffect()
 {
     for (int k=0 ; k< nextEffect->parameters().size() ; ++k) {
         Phonon::EffectParameter param = nextEffect->parameters()[k];
         switch(param.type()) {
         case QVariant::Int:
             {
                 QSpinBox *spin = (QSpinBox*)propertyControllers.value(param.name());
                 nextEffect->setParameterValue(param, spin->value());
             }
             break;
         case QVariant::Double:
             if (param.minimumValue() == -1.0 && param.maximumValue() == 1.0) {
                 QSlider *slider = (QSlider*)propertyControllers.value(param.name());
                 nextEffect->setParameterValue(param, (double)(slider->value() / (double)SLIDER_RANGE));
             } else {
                 QDoubleSpinBox *spin = (QDoubleSpinBox*)propertyControllers.value(param.name());
                 nextEffect->setParameterValue(param, spin->value());
             }
             break;
         case QVariant::Bool:
             {
                 QCheckBox *cb = (QCheckBox*)propertyControllers.value(param.name());
                 nextEffect->setParameterValue(param, cb->isChecked());
             }
             break;
         case QVariant::String:
             {
                 QLineEdit *edit = (QLineEdit*)propertyControllers.value(param.name());
                 nextEffect->setParameterValue(param, edit->text());
             }
             break;
         default:
             break;
         }
     }
 }

 void MediaPlayer::configureEffect()
 {
     QList<Phonon::Effect *> currEffects = m_audioOutputPath.effects();
     QList<Phonon::EffectDescription> availableEffects = Phonon::BackendCapabilities::availableAudioEffects();
     if (ui->audioEffectsCombo->currentIndex() > 0){
         QList<Phonon::EffectDescription> availableEffects = Phonon::BackendCapabilities::availableAudioEffects();
         Phonon::EffectDescription chosenEffect = availableEffects[ui->audioEffectsCombo->currentIndex() - 1];

         QDialog effectDialog;
         effectDialog.setWindowTitle(tr("Configure effect"));
         QVBoxLayout *topLayout = new QVBoxLayout(&effectDialog);

         QLabel *description = new QLabel("<b>Description:</b><br>" + chosenEffect.description(), &effectDialog);
         description->setWordWrap(true);
         topLayout->addWidget(description);

         QScrollArea *scrollArea = new QScrollArea(&effectDialog);
         topLayout->addWidget(scrollArea);

         QWidget *scrollWidget = new QWidget(&effectDialog);
         QVBoxLayout *scrollLayout = new QVBoxLayout(scrollWidget);
         scrollWidget->setMinimumWidth(320);
         scrollArea->setWidget(scrollWidget);

         if (nextEffect) {
             for (int k=0 ; k< nextEffect->parameters().size() ; ++k) {
                 Phonon::EffectParameter param = nextEffect->parameters()[k];
                 QHBoxLayout *hlayout = new QHBoxLayout();
                 QString labelName = param.name();
                 labelName[0] = labelName[0].toUpper();
                 hlayout->addWidget(new QLabel("<b>" + labelName + ":</b> "));
                 if (param.type() == QVariant::Int) {
                     QSpinBox *spin = new QSpinBox(&effectDialog);
                     spin->setMinimum(param.minimumValue().toInt());
                     spin->setMaximum(param.maximumValue().toInt());
                     QVariant currentValue = nextEffect->parameterValue(param);
                     spin->setProperty("oldValue", currentValue.toInt());
                     spin->setValue(currentValue.toInt());
                     connect(spin, SIGNAL(valueChanged(int)), this, SLOT(updateEffect()));
                     hlayout->addWidget(spin);
                     propertyControllers.insert(param.name(), spin);
                } else if (param.type() == QVariant::Double) {
                     if (param.minimumValue() == -1.0 && param.maximumValue() == 1.0) {
                         //Special case values between -1 and 1.0 to use a slider for improved usability
                         QSlider *slider = new QSlider(Qt::Horizontal, &effectDialog);
                         slider->setMinimum(-SLIDER_RANGE);
                         slider->setMaximum(SLIDER_RANGE);
                         QVariant currentValue = nextEffect->parameterValue(param);
                         slider->setProperty("oldValue", currentValue.toDouble());
                         slider->setValue((int)(SLIDER_RANGE * currentValue.toDouble()));
                         slider->setTickPosition(QSlider::TicksBelow);
                         slider->setTickInterval(4);
                         hlayout->addWidget(slider);
                         connect(slider, SIGNAL(valueChanged(int)), this, SLOT(updateEffect()));
                         propertyControllers.insert(param.name(), slider);
                     } else {
                         QDoubleSpinBox *spin = new QDoubleSpinBox(&effectDialog);
                         spin->setSingleStep(0.1);
                         spin->setMinimum(param.minimumValue().toDouble());
                         spin->setMaximum(param.maximumValue().toDouble());
                         QVariant currentValue = nextEffect->parameterValue(param);
                         spin->setProperty("oldValue", currentValue);
                         spin->setValue(currentValue.toDouble());
                         connect(spin, SIGNAL(valueChanged(double)), this, SLOT(updateEffect()));
                         hlayout->addWidget(spin);
                         propertyControllers.insert(param.name(), spin);
                     }
                 } else if (param.type() == QVariant::Bool) {
                     QCheckBox *cb = new QCheckBox(&effectDialog);
                     QVariant currentValue = nextEffect->parameterValue(param);
                     cb->setProperty("oldValue", currentValue);
                     cb->setChecked(currentValue.toBool());
                     connect(cb, SIGNAL(stateChanged(int)), this, SLOT(updateEffect()));
                     hlayout->addWidget(cb);
                     propertyControllers.insert(param.name(), cb);
                 } else if (param.type() == QVariant::String) {
                     QLineEdit *edit = new QLineEdit(&effectDialog);
                     QVariant currentValue = nextEffect->parameterValue(param);
                     edit->setProperty("oldValue", currentValue.toString());
                     edit->setText(currentValue.toString());
                     connect(edit, SIGNAL(returnPressed()), this, SLOT(updateEffect()));
                     hlayout->addWidget(edit);
                     propertyControllers.insert(param.name(), edit);
                 }
                 scrollLayout->addLayout(hlayout);
             }
             QDialogButtonBox *bbox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, &effectDialog);
             connect(bbox->button(QDialogButtonBox::Ok), SIGNAL(clicked()), &effectDialog, SLOT(accept()));
             connect(bbox->button(QDialogButtonBox::Cancel), SIGNAL(clicked()), &effectDialog, SLOT(reject()));
             topLayout->addWidget(bbox);

             scrollWidget->adjustSize();
             effectDialog.adjustSize();

             effectDialog.exec();
             if (effectDialog.result() != QDialog::Accepted){
                 // Revert any changes
                 for (int k=0 ; k< nextEffect->parameters().size() ; ++k) {
                     Phonon::EffectParameter param = nextEffect->parameters()[k];
                     switch(param.type()) {
                     case QVariant::Int:
                         {
                             QSpinBox *spin = (QSpinBox*)propertyControllers.value(param.name());
                             nextEffect->setParameterValue(param, spin->property("oldValue").toInt());
                         }
                         break;
                     case QVariant::Double:
                         if (param.minimumValue() == -1.0 && param.maximumValue() == 1.0) {
                             QSlider *slider = (QSlider*)propertyControllers.value(param.name());
                             nextEffect->setParameterValue(param, slider->property("oldValue").toDouble());
                         } else {
                             QDoubleSpinBox *spin = (QDoubleSpinBox*)propertyControllers.value(param.name());
                             nextEffect->setParameterValue(param, spin->property("oldValue").toDouble());
                         }
                         break;
                     case QVariant::Bool:
                         {
                             QCheckBox *cb = (QCheckBox*)propertyControllers.value(param.name());
                             nextEffect->setParameterValue(param, cb->property("oldValue").toBool());
                         }
                         break;
                     case QVariant::String:
                         {
                             QLineEdit *edit = (QLineEdit*)propertyControllers.value(param.name());
                             nextEffect->setParameterValue(param, edit->property("oldValue").toString());
                         }
                         break;
                     default:
                         break;
                     }
                 }
             }
             propertyControllers.clear();
         }
     }
 }

 void MediaPlayer::pause()
 {
     m_MediaObject.pause();
 }

 void MediaPlayer::handleDrop(QDropEvent *e)
 {
     QList<QUrl> urls = e->mimeData()->urls();
     if (e->proposedAction() == Qt::MoveAction){
         // Just add to the que:
         for (int i=0; i<urls.size(); i++)
             m_MediaObject.enqueue(Phonon::MediaSource(urls[i].toLocalFile()));
     } else {
         // Create new que:
         m_MediaObject.clearQueue();
         if (urls.size() > 0) {
             QString fileName = urls[0].toLocalFile();
             QDir dir(fileName);
             if (dir.exists()) {
                 dir.setFilter(QDir::Files);
                 QStringList entries = dir.entryList();
                 if (entries.size() > 0) {
                     setFile(fileName + QDir::separator() +  entries[0]);
                     for (int i=1; i< entries.size(); ++i)
                         m_MediaObject.enqueue(fileName + QDir::separator() + entries[i]);
                 }
             } else {
                 setFile(fileName);
                 for (int i=1; i<urls.size(); i++)
                     m_MediaObject.enqueue(Phonon::MediaSource(urls[i].toLocalFile()));
             }
         }
     }
     forwardButton->setEnabled(m_MediaObject.queue().size() > 0);
     play();
 }

 void MediaPlayer::dropEvent(QDropEvent *e)
 {
     if (e->mimeData()->hasUrls() && e->proposedAction() != Qt::LinkAction) {
         e->acceptProposedAction();
         handleDrop(e);
     } else {
         e->ignore();
     }
 }

 void MediaPlayer::dragEnterEvent(QDragEnterEvent *e)
 {
     dragMoveEvent(e);
 }

 void MediaPlayer::dragMoveEvent(QDragMoveEvent *e)
 {
     if (e->mimeData()->hasUrls()) {
         if (e->proposedAction() == Qt::CopyAction || e->proposedAction() == Qt::MoveAction){
             e->acceptProposedAction();
         }
     }
 }

 void MediaPlayer::playPause()
 {
     if (m_MediaObject.state() == Phonon::PlayingState)
         m_MediaObject.pause();
     else {
         if (m_MediaObject.currentTime() == m_MediaObject.totalTime())
             m_MediaObject.seek(0);
         m_MediaObject.play();
     }
 }

 void MediaPlayer::play()
 {
     m_MediaObject.play();
 }

 void MediaPlayer::setVolume(int volume)
 {
     Q_UNUSED(volume);
     m_AudioOutput.setVolume(volume/100.0f);
     if (volumeLabel) {
         if (volume == 0)
             volumeLabel->setPixmap(mutedIcon);
         else
             volumeLabel->setPixmap(volumeIcon);
     }
 }

 void MediaPlayer::setFile(const QString &fileName)
 {
     setWindowTitle(fileName.right(fileName.length() - fileName.lastIndexOf('/') - 1));
     m_MediaObject.setCurrentSource(Phonon::MediaSource(fileName));
     m_MediaObject.play();
 }

 void MediaPlayer::openFile()
 {
     QStringList fileNames = QFileDialog::getOpenFileNames(this);
     m_MediaObject.clearQueue();
     if (fileNames.size() > 0) {
         QString fileName = fileNames[0];
         setFile(fileName);
         for (int i=1; i<fileNames.size(); i++)
             m_MediaObject.enqueue(Phonon::MediaSource(fileNames[i]));
     }
     forwardButton->setEnabled(m_MediaObject.queue().size() > 0);
 }

 void MediaPlayer::bufferStatus(int percent)
 {
     if (percent == 0 || percent == 100)
         progressLabel->setText("");
     else {
         QString str("(");
         str += QString::number(percent);
         str += "%)";
         progressLabel->setText(str);
     }
 }

 void MediaPlayer::setSaturation(int val)
 {
     m_videoWidget->setSaturation(val / qreal(SLIDER_RANGE));
 }

 void MediaPlayer::setHue(int val)
 {
     m_videoWidget->setHue(val / qreal(SLIDER_RANGE));
 }

 void MediaPlayer::setAspect(int val)
 {
     m_videoWidget->setAspectRatio(Phonon::VideoWidget::AspectRatio(val));
 }

 void MediaPlayer::setScale(int val)
 {
     m_videoWidget->setScaleMode(Phonon::VideoWidget::ScaleMode(val));
 }

 void MediaPlayer::setBrightness(int val)
 {
     m_videoWidget->setBrightness(val / qreal(SLIDER_RANGE));
 }

 void MediaPlayer::setContrast(int val)
 {
     m_videoWidget->setContrast(val / qreal(SLIDER_RANGE));
 }

 void MediaPlayer::updateInfo()
 {
     int maxLength = 30;
     QString font = "<font color=#ffeeaa>";
     QString fontmono = "<font family=\"monospace,courier new\" color=#ffeeaa>";

     QMap <QString, QString> metaData = m_MediaObject.metaData();
     QString trackArtist = metaData.value("ARTIST");
     if (trackArtist.length() > maxLength)
         trackArtist = trackArtist.left(maxLength) + "...";

     QString trackTitle = metaData.value("TITLE");
     int trackBitrate = metaData.value("BITRATE").toInt();

     QString fileName;
     if (m_MediaObject.currentSource().type() == Phonon::MediaSource::Url) {
         fileName = m_MediaObject.currentSource().url().toString();
     } else {
         fileName = m_MediaObject.currentSource().fileName();
         fileName = fileName.right(fileName.length() - fileName.lastIndexOf('/') - 1);
         if (fileName.length() > maxLength)
             fileName = fileName.left(maxLength) + "...";
     }

     QString title;
     if (!trackTitle.isEmpty()) {
         if (trackTitle.length() > maxLength)
             trackTitle = trackTitle.left(maxLength) + "...";
         title = "Title: " + font + trackTitle + "<br></font>";
     } else if (!fileName.isEmpty()) {
         if (fileName.length() > maxLength)
             fileName = fileName.left(maxLength) + "...";
         title = font + fileName + "</font>";
         if (m_MediaObject.currentSource().type() == Phonon::MediaSource::Url) {
             title.prepend("Url: ");
         } else {
             title.prepend("File: ");
         }
     }

     QString artist;
     if (!trackArtist.isEmpty())
         artist = "Artist:  " + font + trackArtist + "</font>";

     QString bitrate;
     if (trackBitrate != 0)
         bitrate = "<br>Bitrate:  " + font + QString::number(trackBitrate/1000) + "kbit</font>";

     info->setText(title + artist + bitrate);
 }

 void MediaPlayer::updateTime()
 {
     long len = m_MediaObject.totalTime();
     long pos = m_MediaObject.currentTime();
     QString timeString;
     if (pos || len)
     {
         int sec = pos/1000;
         int min = sec/60;
         int hour = min/60;
         int msec = pos;

         QTime playTime(hour%60, min%60, sec%60, msec%1000);
         sec = len / 1000;
         min = sec / 60;
         hour = min / 60;
         msec = len;

         QTime stopTime(hour%60, min%60, sec%60, msec%1000);
         QString timeFormat = "m:ss";
         if (hour > 0)
             timeFormat = "h:mm:ss";
         timeString = playTime.toString(timeFormat);
         if (len)
             timeString += " / " + stopTime.toString(timeFormat);
     }
     timeLabel->setText(timeString);
 }

 void MediaPlayer::rewind()
 {
     m_MediaObject.setTickInterval(50);
     m_MediaObject.seek(0);
 }

 void MediaPlayer::forward()
 {
     QList<Phonon::MediaSource> queue = m_MediaObject.queue();
     if (queue.size() > 0) {
         m_MediaObject.setCurrentSource(queue[0]);
         forwardButton->setEnabled(queue.size() > 1);
         m_MediaObject.play();
     }
 }

 void MediaPlayer::openUrl()
 {
     QSettings settings;
     settings.beginGroup(QLatin1String("BrowserMainWindow"));
     QString sourceURL = settings.value("location").toString();
     sourceURL = QInputDialog::getText(this, tr("Open Location"), tr("Please enter a valid address here:"), QLineEdit::Normal, sourceURL);
     if (!sourceURL.isEmpty()) {
             setWindowTitle(sourceURL.right(sourceURL.length() - sourceURL.lastIndexOf('/') - 1));
             m_MediaObject.setCurrentSource(Phonon::MediaSource(QUrl::fromEncoded(sourceURL.toUtf8())));
             m_MediaObject.play();
         settings.setValue("location", sourceURL);
     }
 }

 void MediaPlayer::finished()
 {
 }

 void MediaPlayer::showContextMenu(const QPoint &p)
 {
     fileMenu->popup(m_videoWidget->isFullScreen() ? p : mapToGlobal(p));
 }

 void MediaPlayer::scaleChanged(QAction *act)
 {
     if (act->text() == "Scale and crop")
         m_videoWidget->setScaleMode(Phonon::VideoWidget::ScaleAndCrop);
     else
         m_videoWidget->setScaleMode(Phonon::VideoWidget::FitInView);
 }

 void MediaPlayer::aspectChanged(QAction *act)
 {
     if (act->text() == "16/9")
         m_videoWidget->setAspectRatio(Phonon::VideoWidget::AspectRatio16_9);
     else if (act->text() == "Scale")
         m_videoWidget->setAspectRatio(Phonon::VideoWidget::AspectRatioWidget);
     else if (act->text() == "4/3")
         m_videoWidget->setAspectRatio(Phonon::VideoWidget::AspectRatio4_3);
     else
         m_videoWidget->setAspectRatio(Phonon::VideoWidget::AspectRatioAuto);
 }