kdelibs/kutils/kmediaplayer/kmediawidget.cpp

/*  This file is part of the KDE libraries
    Copyright (C) 2016 Ivailo Monev <xakepa10@gmail.com>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2, as published by the Free Software Foundation.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#include <kdebug.h>
#include <klocale.h>
#include <kicon.h>
#include <kmainwindow.h>
#include <kstatusbar.h>
#include <QFileDialog>
#include <QInputDialog>
#include <QMessageBox>
#include <QTimer>
#include <QMouseEvent>

#include "kmediaplayer.h"
#include "kmediawidget.h"
#include "ui_kmediawidget.h"

class KMediaWidgetPrivate
{
public:
    KMediaPlayer *m_player;
    KMediaWidget::KMediaOptions m_options;
    QWidget *m_parent;
    QMainWindow *m_parenthack;
    QSize m_parentsizehack;
    QElapsedTimer m_timer;
    QString m_path;
    bool m_replay;
    Ui_KMediaWidgetPrivate *m_ui;
};

KMediaWidget::KMediaWidget(QWidget *parent, KMediaOptions options)
    : QWidget(parent), d(new KMediaWidgetPrivate)
{
    d->m_ui = new Ui_KMediaWidgetPrivate();
    d->m_ui->setupUi(this);
    d->m_player = new KMediaPlayer(d->m_ui->w_player);
    d->m_options = options;
    d->m_parent = parent;

    d->m_ui->w_play->setIcon(KIcon("media-playback-start"));
    d->m_ui->w_play->setText(i18n("Play"));
    d->m_ui->w_play->setEnabled(false);
    d->m_ui->w_position->setEnabled(false);
    d->m_ui->w_volume->setValue(d->m_player->volume());
    d->m_ui->w_fullscreen->setIcon(KIcon("view-fullscreen"));

    connect(d->m_ui->w_play, SIGNAL(clicked()), this, SLOT(setPlay()));
    // connect(d->m_ui->w_position, SIGNAL(sliderMoved(int)), this, SLOT(setPosition(int)));
    connect(d->m_ui->w_position, SIGNAL(sliderReleased()), this, SLOT(_setPosition()));
    connect(d->m_ui->w_volume, SIGNAL(valueChanged(int)), this, SLOT(setVolume(int)));
    connect(d->m_ui->w_fullscreen, SIGNAL(clicked()), SLOT(setFullscreen()));

    connect(d->m_player, SIGNAL(paused(bool)), this, SLOT(_updatePlay(bool)));
    connect(d->m_player, SIGNAL(loaded()), this, SLOT(_updateLoaded()));
    connect(d->m_player, SIGNAL(seekable(bool)), this, SLOT(_updateSeekable(bool)));
    connect(d->m_player, SIGNAL(position(double)), this, SLOT(_updatePosition(double)));
    connect(d->m_player, SIGNAL(finished()), this, SLOT(_updateFinished()));
    connect(d->m_player, SIGNAL(error(QString)), this, SLOT(_updateError(QString)));

    if (options & DragDrop) {
        setAcceptDrops(true);
        d->m_player->setAcceptDrops(true);
    }

    if ((options & FullscreenVideo) == 0) {
        d->m_ui->w_fullscreen->setVisible(false);
    }

    if (options & HiddenControls) {
        setMouseTracking(true);
    }
}

KMediaWidget::~KMediaWidget()
{
    delete d->m_player;
    delete d->m_ui;
    delete d;
}

void KMediaWidget::open(QString path)
{
    // m_path should be updated from _updateLoaded() but that may be too late
    d->m_path = path;
    d->m_replay = false;

    d->m_ui->w_play->setEnabled(true);
    d->m_ui->w_position->setEnabled(true);

    d->m_player->load(path);

    d->m_ui->w_position->setEnabled(d->m_player->isSeekable());

    if (d->m_options & HiddenControls) {
        startTimer(200);
        d->m_timer.start();
    }
}

KMediaPlayer* KMediaWidget::player() const
{
    return d->m_player;
}

void KMediaWidget::setPlay(int value)
{
    // TODO: can the position be stored and restored reliably as well?
    if (d->m_replay && !d->m_path.isEmpty()) {
        open(d->m_path);
        return;
    }

    bool pause;
    if (value == -1) {
        pause = d->m_player->isPlaying();
    } else {
        pause = bool(value);
    }
    if (pause) {
        d->m_player->pause();
    } else {
        d->m_player->play();
    }
}

void KMediaWidget::setPosition(int value)
{
    d->m_player->seek(value);
}

void KMediaWidget::setVolume(int value)
{
    d->m_player->setVolume(value);
}

void KMediaWidget::setFullscreen(int value)
{
    bool fullscreen;
    if (value == -1) {
        fullscreen = !d->m_player->isFullscreen();
    } else {
        fullscreen = bool(value);
    }
    /*
        Making a QWidget go fullscreen requires quite some magic for X11
        because showFullScreen() requires the parent of the widget to be a
        window (QMainWindow) thus the hack bellow. Asking the parent widget to
        go fullscreen is required to preserve the media controls visible and
        interactive. Note that setting the MPV property is just for consistency
        and possible clients quering it, it does nothing when MPV is embed (as
        of the time of writing this).
    */
    if (!d->m_parent && (parentWidget() == window()) && !d->m_parenthack) {
        kDebug() << i18n("using parent widget from parentWidget()");
        d->m_parent = parentWidget();
        d->m_parentsizehack = QSize(-1, -1);
        d->m_parenthack = NULL;
    } else if (!d->m_parent && parentWidget()) {
        kWarning() << i18n("creating a parent, detaching widget, starting voodoo dance..");
        d->m_parent = parentWidget();
        d->m_parentsizehack = d->m_parent->size();
        d->m_parenthack = new QMainWindow(d->m_parent);
    }

    if (fullscreen) {
        if (d->m_parenthack && d->m_parentsizehack.isValid() && d->m_parent) {
            kDebug() << i18n("using parent hack widget");
            d->m_parenthack->setCentralWidget(this);
            d->m_parenthack->showFullScreen();
        } else if (d->m_parent) {
            kDebug() << i18n("using parent widget");
            d->m_parent->showFullScreen();
        } else {
            kWarning() << i18n("cannot set fullscreen state");
        }
        d->m_player->setFullscreen(true);
    } else {
        if (d->m_parenthack && d->m_parentsizehack.isValid() && d->m_parent) {
            kDebug() << i18n("restoring parent from hack widget");
            setParent(d->m_parent);
            resize(d->m_parentsizehack);
            show();
            delete d->m_parenthack;
            d->m_parenthack = NULL;
            d->m_parent = NULL;
        } else if (d->m_parent) {
            kDebug() << i18n("restoring from parent widget");
            d->m_parent->showNormal();
        } else {
            kWarning() << i18n("cannot restore to non-fullscreen state");
        }
        d->m_player->setFullscreen(false);
    }
}

QSize KMediaWidget::sizeHint() const
{
    return d->m_ui->w_player->sizeHint();
}

QSize KMediaWidget::minimumSizeHint() const
{
    if (d->m_options & FullscreenVideo) {
        return QSize(300, 233);
    }
    return QSize(180, 140);
}

void KMediaWidget::mouseDoubleClickEvent(QMouseEvent *event)
{
    if (d->m_options & FullscreenVideo) {
        setFullscreen();
        event->ignore();
    }
}

void KMediaWidget::mouseMoveEvent(QMouseEvent *event)
{
    if (d->m_options & HiddenControls) {
        d->m_timer.restart();
        event->ignore();
    }
}

void KMediaWidget::timerEvent(QTimerEvent *event)
{
    if (d->m_timer.elapsed() > 3000
        && !d->m_ui->w_play->isDown()
        && !d->m_ui->w_position->isSliderDown()
        && !d->m_ui->w_volume->isSliderDown()
        && !d->m_ui->w_fullscreen->isDown()) {
        _updateControls(false);
    } else {
        _updateControls(true);
    }
    event->ignore();
}

void KMediaWidget::_updateControls(bool visible)
{
    if (visible != d->m_ui->w_frame->isVisible()) {
        d->m_ui->w_frame->setVisible(visible);
        emit controlsHidden(visible);
    }
}

void KMediaWidget::_updatePlay(bool paused)
{
    if (paused) {
        d->m_ui->w_play->setIcon(KIcon("media-playback-start"));
        d->m_ui->w_play->setText(i18n("Play"));
    } else {
        d->m_ui->w_play->setIcon(KIcon("media-playback-pause"));
        d->m_ui->w_play->setText(i18n("Pause"));
    }
}

void KMediaWidget::_updateSeekable(bool seekable)
{
    d->m_ui->w_position->setEnabled(seekable);
    d->m_ui->w_position->setMaximum(d->m_player->totalTime());
}

void KMediaWidget::_setPosition()
{
    d->m_player->seek(d->m_ui->w_position->value());
}

void KMediaWidget::_updatePosition(double seconds)
{
    // do not update the slider while it's dragged by the user
    if (!d->m_ui->w_position->isSliderDown()) {
        d->m_ui->w_position->setValue(seconds);
    }
}

void KMediaWidget::_updateLoaded()
{
    d->m_path = d->m_player->path();
    const QString title = d->m_player->title();
    if (!title.isEmpty()) {
        _updateStatus(title);
    }
    _updatePlay(!d->m_player->isPlaying());
}

void KMediaWidget::_updateStatus(QString string)
{
    if (d->m_options & FullscreenVideo) {
        QWidget *windowwidget = window();
        KMainWindow *kmainwindow = qobject_cast<KMainWindow*>(windowwidget);
        if (kmainwindow) {
            kmainwindow->setCaption(string);
            KStatusBar *statusbar = kmainwindow->statusBar();
            if (statusbar) {
                if (d->m_player->isPlaying()) {
                    statusbar->showMessage(i18n("Now playing: %1", string));
                } else {
                    statusbar->showMessage(string);
                }
            }
        } else if (windowwidget) {
            windowwidget->setWindowTitle(string);
        }
    }
}

void KMediaWidget::_updateFinished()
{
    d->m_replay = true;

    if (d->m_options & HiddenControls) {
        // show the controls until the next open
        d->m_timer.invalidate();
        _updateControls(true);
    }
    _updatePlay(true);
}

void KMediaWidget::_updateError(QString error)
{
    if (d->m_options & FullscreenVideo) {
        _updateStatus(error);
    } else {
        // since there are not many ways to indicate an error when
        // there are no extended controls use the play button to do so
        d->m_ui->w_play->setIcon(KIcon("dialog-error"));
        d->m_ui->w_play->setText(i18n("Error"));
    }

    d->m_ui->w_position->setEnabled(false);
}

void KMediaWidget::dragEnterEvent(QDragEnterEvent *event)
{
    if (event->mimeData()->hasUrls()) {
        event->acceptProposedAction();
    }
}

void KMediaWidget::dropEvent(QDropEvent *event)
{
    const QList<QUrl> urls = event->mimeData()->urls();
    QStringList invalid;
    foreach (const QUrl url, urls) {
        QString urlstring = url.toString();
        if (!d->m_player->isPathSupported(urlstring)) {
            kDebug() << i18n("ignoring unsupported:\n%1", urlstring);
            invalid.append(urlstring);
            continue;
        }
        open(urlstring);
    }
    if (!invalid.isEmpty()) {
        QMessageBox::warning(this, i18n("Invalid paths"),
            i18n("Some paths are invalid:\n%1", invalid.join("\n")));
    } else {
        event->acceptProposedAction();
    }
}

#include "moc_kmediawidget.cpp"