/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the demonstration applications of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

***************************************************************************/

#include <QtGui>

#define SLIDER_RANGE 8

#include "mediaplayer.h"

#include "ui_settings.h"

MediaVideoWidget::MediaVideoWidget(MediaPlayer *player, QWidget *parent) :

    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);

}

void MediaVideoWidget::setFullScreen(bool enabled)

{

    Phonon::VideoWidget::setFullScreen(enabled);

    emit fullScreenChanged(enabled);

}

void MediaVideoWidget::mouseDoubleClickEvent(QMouseEvent *e)

{

    Phonon::VideoWidget::mouseDoubleClickEvent(e);

    setFullScreen(!isFullScreen());

}

void MediaVideoWidget::keyPressEvent(QKeyEvent *e)

{

    if(!e->modifiers()) {

        // On non-QWERTY Symbian key-based devices, there is no space key.

        // The zero key typically is marked with a space character.

        if (e->key() == Qt::Key_Space || e->key() == Qt::Key_0) {

            m_player->playPause();

            e->accept();

            return;

        }

        // On Symbian devices, there is no key which maps to Qt::Key_Escape

        // On devices which lack a backspace key (i.e. non-QWERTY devices),

        // the 'C' key maps to Qt::Key_Backspace

        else if (e->key() == Qt::Key_Escape || e->key() == Qt::Key_Backspace) {

            setFullScreen(false);

            e->accept();

            return;

        }

    }

    Phonon::VideoWidget::keyPressEvent(e);

}

bool MediaVideoWidget::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:

#ifndef QT_NO_CURSOR

        unsetCursor();

#endif

        //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();

#ifndef QT_NO_CURSOR

                unsetCursor();

#endif

            }

        }

        break;

    default:

        break;

    }

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

}

void MediaVideoWidget::timerEvent(QTimerEvent *e)

{

    if (e->timerId() == m_timer.timerId()) {

        //let's store the cursor shape

#ifndef QT_NO_CURSOR

        setCursor(Qt::BlankCursor);

#endif

    }

    Phonon::VideoWidget::timerEvent(e);

}

void MediaVideoWidget::dropEvent(QDropEvent *e)

{

    m_player->handleDrop(e);

}

void MediaVideoWidget::dragEnterEvent(QDragEnterEvent *e) {

    if (e->mimeData()->hasUrls())

        e->acceptProposedAction();

}

MediaPlayer::MediaPlayer(const QString &filePath,

                         const bool hasSmallScreen) :

        playButton(0), nextEffect(0), settingsDialog(0), ui(0),

            m_AudioOutput(Phonon::VideoCategory),

            m_videoWidget(new MediaVideoWidget(this)),

            m_hasSmallScreen(hasSmallScreen)

{

    setWindowTitle(tr("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 Phonon::VolumeSlider(&m_AudioOutput);

    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(54, 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(tr("<center>No media</center>"));

    volume->setFixedWidth(120);

    layout->addWidget(openButton);

    layout->addWidget(rewindButton);

    layout->addWidget(playButton);

    layout->addWidget(forwardButton);

    layout->addStretch();

    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..."));

    QAction *const openLinkAction = fileMenu->addAction(tr("Open &RAM File..."));

    connect(openLinkAction, SIGNAL(triggered(bool)), this, SLOT(openRamFile()));

    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(tr("Auto"));

    aspectActionAuto->setCheckable(true);

    aspectActionAuto->setChecked(true);

    aspectGroup->addAction(aspectActionAuto);

    QAction *aspectActionScale = aspectMenu->addAction(tr("Scale"));

    aspectActionScale->setCheckable(true);

    aspectGroup->addAction(aspectActionScale);

    QAction *aspectAction16_9 = aspectMenu->addAction(tr("16/9"));

    aspectAction16_9->setCheckable(true);

    aspectGroup->addAction(aspectAction16_9);

    QAction *aspectAction4_3 = aspectMenu->addAction(tr("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(tr("Fit in view"));

    scaleActionFit->setCheckable(true);

    scaleActionFit->setChecked(true);

    scaleGroup->addAction(scaleActionFit);

    QAction *scaleActionCrop = scaleMenu->addAction(tr("Scale and crop"));

    scaleActionCrop->setCheckable(true);

    scaleGroup->addAction(scaleActionCrop);

    m_fullScreenAction = fileMenu->addAction(tr("Full screen video"));

    m_fullScreenAction->setCheckable(true);

    m_fullScreenAction->setEnabled(false); // enabled by hasVideoChanged

    bool b = connect(m_fullScreenAction, SIGNAL(toggled(bool)), m_videoWidget, SLOT(setFullScreen(bool)));

    Q_ASSERT(b);

    b = connect(m_videoWidget, SIGNAL(fullScreenChanged(bool)), m_fullScreenAction, SLOT(setChecked(bool)));

    Q_ASSERT(b);

    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(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)));

    connect(&m_MediaObject, SIGNAL(hasVideoChanged(bool)), this, SLOT(hasVideoChanged(bool)));

    rewindButton->setEnabled(false);

    playButton->setEnabled(false);

    setAcceptDrops(true);

    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) {

        QRect videoHintRect = QRect(QPoint(0, 0), m_videoWindow.sizeHint());

        QRect newVideoRect = QApplication::desktop()->screenGeometry().intersected(videoHintRect);

        if (!m_hasSmallScreen) {

            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:

            if (m_MediaObject.errorType() == Phonon::FatalError) {

                playButton->setEnabled(false);

                rewindButton->setEnabled(false);

            } else {

                m_MediaObject.pause();

            }

            QMessageBox::warning(this, "Phonon Mediaplayer", m_MediaObject.errorString(), QMessageBox::Close);

            break;

        case Phonon::StoppedState:

            m_videoWidget->setFullScreen(false);

            // Fall through

        case Phonon::PausedState:

            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(tr("<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 (currentIndex) {

        QList<Phonon::EffectDescription> availableEffects = Phonon::BackendCapabilities::availableAudioEffects();

        Phonon::EffectDescription chosenEffect = availableEffects[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()

{

    const bool hasPausedForDialog = playPauseForDialog();

    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;

                }