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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

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

**

** This file is part of the Qt Mobility Components.

**

** $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 "qvideowidget_p.h"

#include <qmediaobject.h>

#include <qmediaservice.h>

#include <qvideowindowcontrol.h>

#include <qvideowidgetcontrol.h>

#include <qpaintervideosurface_p.h>

#include <qvideorenderercontrol.h>

#include <qvideosurfaceformat.h>

#include <qpainter.h>

#include <qapplication.h>

#include <qevent.h>

#include <qdialog.h>

#include <qboxlayout.h>

#include <qnamespace.h>

using namespace Qt;

QT_BEGIN_NAMESPACE

QVideoWidgetControlBackend::QVideoWidgetControlBackend(

        QMediaService *service, QVideoWidgetControl *control, QWidget *widget)

    : m_service(service)

    , m_widgetControl(control)

{

    connect(control, SIGNAL(brightnessChanged(int)), widget, SLOT(_q_brightnessChanged(int)));

    connect(control, SIGNAL(contrastChanged(int)), widget, SLOT(_q_contrastChanged(int)));

    connect(control, SIGNAL(hueChanged(int)), widget, SLOT(_q_hueChanged(int)));

    connect(control, SIGNAL(saturationChanged(int)), widget, SLOT(_q_saturationChanged(int)));

    connect(control, SIGNAL(fullScreenChanged(bool)), widget, SLOT(_q_fullScreenChanged(bool)));

    QBoxLayout *layout = new QVBoxLayout;

    layout->setMargin(0);

    layout->setSpacing(0);

    layout->addWidget(control->videoWidget());

    widget->setLayout(layout);

}

void QVideoWidgetControlBackend::releaseControl()

{

    m_service->releaseControl(m_widgetControl);

}

void QVideoWidgetControlBackend::setBrightness(int brightness)

{

    m_widgetControl->setBrightness(brightness);

}

void QVideoWidgetControlBackend::setContrast(int contrast)

{

    m_widgetControl->setContrast(contrast);

}

void QVideoWidgetControlBackend::setHue(int hue)

{

    m_widgetControl->setHue(hue);

}

void QVideoWidgetControlBackend::setSaturation(int saturation)

{

    m_widgetControl->setSaturation(saturation);

}

void QVideoWidgetControlBackend::setFullScreen(bool fullScreen)

{

    m_widgetControl->setFullScreen(fullScreen);

}

Qt::AspectRatioMode QVideoWidgetControlBackend::aspectRatioMode() const

{

    return m_widgetControl->aspectRatioMode();

}

void QVideoWidgetControlBackend::setAspectRatioMode(Qt::AspectRatioMode mode)

{

    m_widgetControl->setAspectRatioMode(mode);

}

QRendererVideoWidgetBackend::QRendererVideoWidgetBackend(

        QMediaService *service, QVideoRendererControl *control, QWidget *widget)

    : m_service(service)

    , m_rendererControl(control)

    , m_widget(widget)

    , m_surface(new QPainterVideoSurface)

    , m_aspectRatioMode(Qt::KeepAspectRatio)

    , m_updatePaintDevice(true)

{

    connect(this, SIGNAL(brightnessChanged(int)), m_widget, SLOT(_q_brightnessChanged(int)));

    connect(this, SIGNAL(contrastChanged(int)), m_widget, SLOT(_q_contrastChanged(int)));

    connect(this, SIGNAL(hueChanged(int)), m_widget, SLOT(_q_hueChanged(int)));

    connect(this, SIGNAL(saturationChanged(int)), m_widget, SLOT(_q_saturationChanged(int)));

    connect(m_surface, SIGNAL(frameChanged()), this, SLOT(frameChanged()));

    connect(m_surface, SIGNAL(surfaceFormatChanged(QVideoSurfaceFormat)),

            this, SLOT(formatChanged(QVideoSurfaceFormat)));

    m_rendererControl->setSurface(m_surface);

}

QRendererVideoWidgetBackend::~QRendererVideoWidgetBackend()

{

    delete m_surface;

}

void QRendererVideoWidgetBackend::releaseControl()

{

    m_service->releaseControl(m_rendererControl);

}

void QRendererVideoWidgetBackend::clearSurface()

{

    m_rendererControl->setSurface(0);

}

void QRendererVideoWidgetBackend::setBrightness(int brightness)

{

    m_surface->setBrightness(brightness);

    emit brightnessChanged(brightness);

}

void QRendererVideoWidgetBackend::setContrast(int contrast)

{

    m_surface->setContrast(contrast);

    emit contrastChanged(contrast);

}

void QRendererVideoWidgetBackend::setHue(int hue)

{

    m_surface->setHue(hue);

    emit hueChanged(hue);

}

void QRendererVideoWidgetBackend::setSaturation(int saturation)

{

    m_surface->setSaturation(saturation);

    emit saturationChanged(saturation);

}

Qt::AspectRatioMode QRendererVideoWidgetBackend::aspectRatioMode() const

{

    return m_aspectRatioMode;

}

void QRendererVideoWidgetBackend::setAspectRatioMode(Qt::AspectRatioMode mode)

{

    m_aspectRatioMode = mode;

    m_widget->updateGeometry();

}

void QRendererVideoWidgetBackend::setFullScreen(bool)

{

}

QSize QRendererVideoWidgetBackend::sizeHint() const

{

    return m_surface->surfaceFormat().sizeHint();

}

void QRendererVideoWidgetBackend::showEvent()

{

}

void QRendererVideoWidgetBackend::hideEvent(QHideEvent *)

{

#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_1_CL) && !defined(QT_OPENGL_ES_1)

    m_updatePaintDevice = true;

    m_surface->setGLContext(0);

#endif

}

void QRendererVideoWidgetBackend::resizeEvent(QResizeEvent *)

{

    updateRects();

}

void QRendererVideoWidgetBackend::moveEvent(QMoveEvent *)

{

}

void QRendererVideoWidgetBackend::paintEvent(QPaintEvent *event)

{

    QPainter painter(m_widget);

    if (m_widget->testAttribute(Qt::WA_OpaquePaintEvent)) {

        QRegion borderRegion = event->region();

        borderRegion = borderRegion.subtracted(m_boundingRect);

        QBrush brush = m_widget->palette().window();

        QVector<QRect> rects = borderRegion.rects();

        for (QVector<QRect>::iterator it = rects.begin(), end = rects.end(); it != end; ++it) {

            painter.fillRect(*it, brush);

        }

    }

    if (m_surface->isActive() && m_boundingRect.intersects(event->rect())) {

        m_surface->paint(&painter, m_boundingRect, m_sourceRect);

        m_surface->setReady(true);

    } else {

 #if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_1_CL) && !defined(QT_OPENGL_ES_1)

        if (m_updatePaintDevice && (painter.paintEngine()->type() == QPaintEngine::OpenGL

                || painter.paintEngine()->type() == QPaintEngine::OpenGL2)) {

            m_updatePaintDevice = false;

            m_surface->setGLContext(const_cast<QGLContext *>(QGLContext::currentContext()));

            if (m_surface->supportedShaderTypes() & QPainterVideoSurface::GlslShader) {

                m_surface->setShaderType(QPainterVideoSurface::GlslShader);

            } else {

                m_surface->setShaderType(QPainterVideoSurface::FragmentProgramShader);

            }

        }

#endif

    }

}

void QRendererVideoWidgetBackend::formatChanged(const QVideoSurfaceFormat &format)

{

    m_nativeSize = format.sizeHint();

    updateRects();

    m_widget->updateGeometry();

    m_widget->update();

}

void QRendererVideoWidgetBackend::frameChanged()

{

    m_widget->update(m_boundingRect);

}

void QRendererVideoWidgetBackend::updateRects()

{

    QRect rect = m_widget->rect();

    if (m_nativeSize.isEmpty()) {

        m_boundingRect = QRect();

    } else if (m_aspectRatioMode == Qt::IgnoreAspectRatio) {

        m_boundingRect = rect;

        m_sourceRect = QRectF(0, 0, 1, 1);

    } else if (m_aspectRatioMode == Qt::KeepAspectRatio) {

        QSize size = m_nativeSize;

        size.scale(rect.size(), Qt::KeepAspectRatio);

        m_boundingRect = QRect(0, 0, size.width(), size.height());

        m_boundingRect.moveCenter(rect.center());

        m_sourceRect = QRectF(0, 0, 1, 1);

    } else if (m_aspectRatioMode == Qt::KeepAspectRatioByExpanding) {

        m_boundingRect = rect;

        QSizeF size = rect.size();

        size.scale(m_nativeSize, Qt::KeepAspectRatio);

        m_sourceRect = QRectF(

                0, 0, size.width() / m_nativeSize.width(), size.height() / m_nativeSize.height());

        m_sourceRect.moveCenter(QPointF(0.5, 0.5));

    }

}

QWindowVideoWidgetBackend::QWindowVideoWidgetBackend(

        QMediaService *service, QVideoWindowControl *control, QWidget *widget)

    : m_service(service)

    , m_windowControl(control)

    , m_widget(widget)

    , m_aspectRatioMode(Qt::KeepAspectRatio)

{

    connect(control, SIGNAL(brightnessChanged(int)), m_widget, SLOT(_q_brightnessChanged(int)));

    connect(control, SIGNAL(contrastChanged(int)), m_widget, SLOT(_q_contrastChanged(int)));

    connect(control, SIGNAL(hueChanged(int)), m_widget, SLOT(_q_hueChanged(int)));

    connect(control, SIGNAL(saturationChanged(int)), m_widget, SLOT(_q_saturationChanged(int)));

    connect(control, SIGNAL(fullScreenChanged(bool)), m_widget, SLOT(_q_fullScreenChanged(bool)));

    connect(control, SIGNAL(nativeSizeChanged()), m_widget, SLOT(_q_dimensionsChanged()));

}

QWindowVideoWidgetBackend::~QWindowVideoWidgetBackend()

{

}

void QWindowVideoWidgetBackend::releaseControl()

{

    m_service->releaseControl(m_windowControl);

}

void QWindowVideoWidgetBackend::setBrightness(int brightness)

{

    m_windowControl->setBrightness(brightness);

}

void QWindowVideoWidgetBackend::setContrast(int contrast)

{

    m_windowControl->setContrast(contrast);

}

void QWindowVideoWidgetBackend::setHue(int hue)

{

    m_windowControl->setHue(hue);

}

void QWindowVideoWidgetBackend::setSaturation(int saturation)

{

    m_windowControl->setSaturation(saturation);

}

void QWindowVideoWidgetBackend::setFullScreen(bool fullScreen)

{

    m_windowControl->setFullScreen(fullScreen);

}

Qt::AspectRatioMode QWindowVideoWidgetBackend::aspectRatioMode() const

{

    return m_windowControl->aspectRatioMode();

}

void QWindowVideoWidgetBackend::setAspectRatioMode(Qt::AspectRatioMode mode)

{

    m_windowControl->setAspectRatioMode(mode);

}

QSize QWindowVideoWidgetBackend::sizeHint() const

{

    return m_windowControl->nativeSize();

}

void QWindowVideoWidgetBackend::showEvent()

{

    m_windowControl->setWinId(m_widget->winId());

    m_windowControl->setDisplayRect(m_widget->rect());

}

void QWindowVideoWidgetBackend::hideEvent(QHideEvent *)

{

}

void QWindowVideoWidgetBackend::moveEvent(QMoveEvent *)

{

    m_windowControl->setDisplayRect(m_widget->rect());

}

void QWindowVideoWidgetBackend::resizeEvent(QResizeEvent *)

{

    m_windowControl->setDisplayRect(m_widget->rect());

}

void QWindowVideoWidgetBackend::paintEvent(QPaintEvent *event)

{

    if (m_widget->testAttribute(Qt::WA_OpaquePaintEvent)) {

        QPainter painter(m_widget);

        painter.fillRect(event->rect(), m_widget->palette().window());

    }

    m_windowControl->repaint();

    event->accept();

}

void QVideoWidgetPrivate::setCurrentControl(QVideoWidgetControlInterface *control)

{

    if (currentControl != control) {

        currentControl = control;

        currentControl->setBrightness(brightness);

        currentControl->setContrast(contrast);

        currentControl->setHue(hue);

        currentControl->setSaturation(saturation);

        currentControl->setAspectRatioMode(aspectRatioMode);

    }

}

void QVideoWidgetPrivate::clearService()

{

    if (service) {

        QObject::disconnect(service, SIGNAL(destroyed()), q_func(), SLOT(_q_serviceDestroyed()));

        if (widgetBackend) {

            QLayout *layout = q_func()->layout();

            for (QLayoutItem *item = layout->takeAt(0); item; item = layout->takeAt(0)) {

                item->widget()->setParent(0);

                delete item;

            }

            delete layout;

            widgetBackend->releaseControl();

            delete widgetBackend;

            widgetBackend = 0;

        } else if (rendererBackend) {

            rendererBackend->clearSurface();

            rendererBackend->releaseControl();

            delete rendererBackend;

            rendererBackend = 0;

        } else {

            windowBackend->releaseControl();

            delete windowBackend;

            windowBackend = 0;

        }

        currentBackend = 0;

        currentControl = 0;

        service = 0;

    }

}

bool QVideoWidgetPrivate::createWidgetBackend()

{

    if (QMediaControl *control = service->requestControl(QVideoWidgetControl_iid)) {

        if (QVideoWidgetControl *widgetControl = qobject_cast<QVideoWidgetControl *>(control)) {

            widgetBackend = new QVideoWidgetControlBackend(service, widgetControl, q_func());

            setCurrentControl(widgetBackend);

            return true;

        }

        service->releaseControl(control);

    }

    return false;

}

bool QVideoWidgetPrivate::createWindowBackend()

{

    if (QMediaControl *control = service->requestControl(QVideoWindowControl_iid)) {

        if (QVideoWindowControl *windowControl = qobject_cast<QVideoWindowControl *>(control)) {

            windowBackend = new QWindowVideoWidgetBackend(service, windowControl, q_func());

            currentBackend = windowBackend;

            setCurrentControl(windowBackend);

            return true;

        }

        service->releaseControl(control);

    }

    return false;

}

bool QVideoWidgetPrivate::createRendererBackend()

{

    if (QMediaControl *control = service->requestControl(QVideoRendererControl_iid)) {

        if (QVideoRendererControl *rendererControl = qobject_cast<QVideoRendererControl *>(control)) {

            rendererBackend = new QRendererVideoWidgetBackend(service, rendererControl, q_func());

            currentBackend = rendererBackend;

            setCurrentControl(rendererBackend);

            return true;

        }

        service->releaseControl(control);

    }

    return false;

}

void QVideoWidgetPrivate::_q_serviceDestroyed()

{

    if (widgetBackend)

        delete q_func()->layout();

    delete widgetBackend;

    delete windowBackend;

    delete rendererBackend;

    widgetBackend = 0;

    windowBackend = 0;

    rendererBackend = 0;

    currentControl = 0;

    currentBackend = 0;

    service = 0;

}

void QVideoWidgetPrivate::_q_brightnessChanged(int b)

{

    if (b != brightness)

        emit q_func()->brightnessChanged(brightness = b);

}