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

**

** Copyright (C) 2009 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 <QtMultimedia/qvideosurfaceformat.h>

#include <qpainter.h>

#include <qapplication.h>

#include <qevent.h>

#include <qdialog.h>

#include <qboxlayout.h>

#include <qnamespace.h>

using namespace Qt;

QTM_BEGIN_NAMESPACE

QVideoWidgetControlBackend::QVideoWidgetControlBackend(

        QVideoWidgetControl *control, QWidget *widget)

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

}

{

    return m_widgetControl->aspectRatioMode();

}

{

    m_widgetControl->setAspectRatioMode(mode);

}

QRendererVideoWidgetBackend::QRendererVideoWidgetBackend(

        QVideoRendererControl *control, QWidget *widget)

    : m_rendererControl(control)

    , m_widget(widget)

    , m_surface(new QPainterVideoSurface)

    , 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(surfaceFormatChanged(QVideoSurfaceFormat)),

    m_rendererControl->setSurface(m_surface);

}

QRendererVideoWidgetBackend::~QRendererVideoWidgetBackend()

{

    delete m_surface;

}

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

}

{

    return m_aspectRatioMode;

}

{

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

{

}

void QRendererVideoWidgetBackend::moveEvent(QMoveEvent *)

{

}

void QRendererVideoWidgetBackend::paintEvent(QPaintEvent *event)

{

    QPainter painter(m_widget);

        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

    }

}

{

    }

}

QWindowVideoWidgetBackend::QWindowVideoWidgetBackend(QVideoWindowControl *control, QWidget *widget)

    : m_windowControl(control)

    , m_widget(widget)

{

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

}

{

    return m_windowControl->aspectRatioMode();

}

{

    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)

{

    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::show()

{

    if (outputControl) {

        if (widgetBackend != 0) {

            setCurrentControl(widgetBackend);

            outputControl->setOutput(QVideoOutputControl::WidgetOutput);

        } else if (windowBackend != 0 && (q_func()->window() == 0

                || !q_func()->window()->testAttribute(Qt::WA_DontShowOnScreen))) {

            windowBackend->showEvent();

            currentBackend = windowBackend;

            setCurrentControl(windowBackend);

            outputControl->setOutput(QVideoOutputControl::WindowOutput);

        } else if (rendererBackend != 0) {

            rendererBackend->showEvent();

            currentBackend = rendererBackend;

            setCurrentControl(rendererBackend);

            outputControl->setOutput(QVideoOutputControl::RendererOutput);

        } else {

            outputControl->setOutput(QVideoOutputControl::NoOutput);

        }

    }

}

void QVideoWidgetPrivate::clearService()

{

    if (service) {

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

        if (outputControl)

            outputControl->setOutput(QVideoOutputControl::NoOutput);

        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;

            delete widgetBackend;

            widgetBackend = 0;

        }

        delete windowBackend;

        windowBackend = 0;

        if (rendererBackend) {

            rendererBackend->clearSurface();

            delete rendererBackend;

            rendererBackend = 0;

        }

        currentBackend = 0;

        currentControl = 0;

        outputControl = 0;

        service = 0;

    }

}

void QVideoWidgetPrivate::_q_serviceDestroyed()

{

    if (widgetBackend) {

        delete q_func()->layout();

        delete widgetBackend;

        widgetBackend = 0;

    }

    delete windowBackend;

    windowBackend = 0;

    delete rendererBackend;

    rendererBackend = 0;

    currentControl = 0;

    currentBackend = 0;

    outputControl = 0;

    service = 0;

}

void QVideoWidgetPrivate::_q_mediaObjectDestroyed()

{

    mediaObject = 0;

    clearService();

}

void QVideoWidgetPrivate::_q_brightnessChanged(int b)

{

    if (b != brightness)

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

}

void QVideoWidgetPrivate::_q_contrastChanged(int c)

{

    if (c != contrast)

        emit q_func()->contrastChanged(contrast = c);

}

void QVideoWidgetPrivate::_q_hueChanged(int h)

{

    if (h != hue)

        emit q_func()->hueChanged(hue = h);

}

void QVideoWidgetPrivate::_q_saturationChanged(int s)

{

    if (s != saturation)

        emit q_func()->saturationChanged(saturation = s);

}

void QVideoWidgetPrivate::_q_fullScreenChanged(bool fullScreen)

{

    if (!fullScreen && q_func()->isFullScreen())

        q_func()->showNormal();