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

**

** 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 <qmobilityglobal.h>

#include <QtTest/QtTest>

#include "../../../src/multimedia/qvideowidget.h"

#include "../../../src/multimedia/qmediaobject.h"

#include "../../../src/multimedia/qmediaservice.h"

#include "../../../src/multimedia/qpaintervideosurface_p.h"

#include "../../../src/multimedia/qvideooutputcontrol.h"

#include "../../../src/multimedia/qvideowindowcontrol.h"

#include "../../../src/multimedia/qvideowidgetcontrol.h"

#include "../../../src/multimedia/qvideorenderercontrol.h"

#include <QtMultimedia/qabstractvideosurface.h>

#include <QtMultimedia/qvideosurfaceformat.h>

#include <QtGui/qapplication.h>

QT_USE_NAMESPACE

class tst_QVideoWidget : public QObject

{

    Q_OBJECT

private slots:

    void nullObject();

    void nullService();

    void nullOutputControl();

    void noOutputs();

    void serviceDestroyed();

    void objectDestroyed();

    void setMediaObject();

    void showWindowControl();

    void fullScreenWindowControl();

    void aspectRatioWindowControl();

    void sizeHintWindowControl_data() { sizeHint_data(); }

    void sizeHintWindowControl();

    void brightnessWindowControl_data() { color_data(); }

    void brightnessWindowControl();

    void contrastWindowControl_data() { color_data(); }

    void contrastWindowControl();

    void hueWindowControl_data() { color_data(); }

    void hueWindowControl();

    void saturationWindowControl_data() { color_data(); }

    void saturationWindowControl();

    void showWidgetControl();

    void fullScreenWidgetControl();

    void aspectRatioWidgetControl();

    void sizeHintWidgetControl_data() { sizeHint_data(); }

    void sizeHintWidgetControl();

    void brightnessWidgetControl_data() { color_data(); }

    void brightnessWidgetControl();

    void contrastWidgetControl_data() { color_data(); }

    void contrastWidgetControl();

    void hueWidgetControl_data() { color_data(); }

    void hueWidgetControl();

    void saturationWidgetControl_data() { color_data(); }

    void saturationWidgetControl();

    void showRendererControl();

    void fullScreenRendererControl();

    void aspectRatioRendererControl();

    void sizeHintRendererControl_data();

    void sizeHintRendererControl();

    void brightnessRendererControl_data() { color_data(); }

    void brightnessRendererControl();

    void contrastRendererControl_data() { color_data(); }

    void contrastRendererControl();

    void hueRendererControl_data() { color_data(); }

    void hueRendererControl();

    void saturationRendererControl_data() { color_data(); }

    void saturationRendererControl();

    void paintRendererControl();

private:

    void sizeHint_data();

    void color_data();

};

Q_DECLARE_METATYPE(Qt::AspectRatioMode)

Q_DECLARE_METATYPE(const uchar *)

class QtTestOutputControl : public QVideoOutputControl

{

public:

    QtTestOutputControl() : m_output(NoOutput) {}

    QList<Output> availableOutputs() const { return m_outputs; }

    void setAvailableOutputs(const QList<Output> outputs) { m_outputs = outputs; }

    Output output() const { return m_output; }

    virtual void setOutput(Output output) { m_output = output; }

private:

    Output m_output;

    QList<Output> m_outputs;

};

class QtTestWindowControl : public QVideoWindowControl

{

public:

    QtTestWindowControl()

        : m_winId(0)

        , m_repaintCount(0)

        , m_brightness(0)

        , m_contrast(0)

        , m_saturation(0)

        , m_aspectRatioMode(Qt::KeepAspectRatio)

        , m_fullScreen(0)

    {

    }

    WId winId() const { return m_winId; }

    void setWinId(WId id) { m_winId = id; }

    QRect displayRect() const { return m_displayRect; }

    void setDisplayRect(const QRect &rect) { m_displayRect = rect; }

    bool isFullScreen() const { return m_fullScreen; }

    void setFullScreen(bool fullScreen) { emit fullScreenChanged(m_fullScreen = fullScreen); }

    int repaintCount() const { return m_repaintCount; }

    void setRepaintCount(int count) { m_repaintCount = count; }

    void repaint() { ++m_repaintCount; }

    QSize nativeSize() const { return m_nativeSize; }

    void setNativeSize(const QSize &size) { m_nativeSize = size; emit nativeSizeChanged(); }

    Qt::AspectRatioMode aspectRatioMode() const { return m_aspectRatioMode; }

    void setAspectRatioMode(Qt::AspectRatioMode mode) { m_aspectRatioMode = mode; }

    int brightness() const { return m_brightness; }

    void setBrightness(int brightness) { emit brightnessChanged(m_brightness = brightness); }

    int contrast() const { return m_contrast; }

    void setContrast(int contrast) { emit contrastChanged(m_contrast = contrast); }

    int hue() const { return m_hue; }

    void setHue(int hue) { emit hueChanged(m_hue = hue); }

    int saturation() const { return m_saturation; }

    void setSaturation(int saturation) { emit saturationChanged(m_saturation = saturation); }

private:

    WId m_winId;

    int m_repaintCount;

    int m_brightness;

    int m_contrast;

    int m_hue;

    int m_saturation;

    Qt::AspectRatioMode m_aspectRatioMode;

    QRect m_displayRect;

    QSize m_nativeSize;

    bool m_fullScreen;

};

class QtTestWidgetControl : public QVideoWidgetControl

{

public:

    QtTestWidgetControl()

        : m_brightness(1.0)

        , m_contrast(1.0)

        , m_hue(1.0)

        , m_saturation(1.0)

        , m_aspectRatioMode(Qt::KeepAspectRatio)

        , m_fullScreen(false)

    {

    }

    bool isFullScreen() const { return m_fullScreen; }

    void setFullScreen(bool fullScreen) { emit fullScreenChanged(m_fullScreen = fullScreen); }

    Qt::AspectRatioMode aspectRatioMode() const { return m_aspectRatioMode; }

    void setAspectRatioMode(Qt::AspectRatioMode mode) { m_aspectRatioMode = mode; }

    int brightness() const { return m_brightness; }

    void setBrightness(int brightness) { emit brightnessChanged(m_brightness = brightness); }

    int contrast() const { return m_contrast; }

    void setContrast(int contrast) { emit contrastChanged(m_contrast = contrast); }

    int hue() const { return m_hue; }

    void setHue(int hue) { emit hueChanged(m_hue = hue); }

    int saturation() const { return m_saturation; }

    void setSaturation(int saturation) { emit saturationChanged(m_saturation = saturation); }

    void setSizeHint(const QSize &size) { m_widget.setSizeHint(size); }

    QWidget *videoWidget() { return &m_widget; }

private:

    class Widget : public QWidget

    {

    public:

        QSize sizeHint() const { return m_sizeHint; }

        void setSizeHint(const QSize &size) { m_sizeHint = size; updateGeometry(); }

    private:

        QSize m_sizeHint;

    } m_widget;

    int m_brightness;

    int m_contrast;

    int m_hue;

    int m_saturation;

    Qt::AspectRatioMode m_aspectRatioMode;

    QSize m_sizeHint;

    bool m_fullScreen;

};

class QtTestRendererControl : public QVideoRendererControl

{

public:

    QtTestRendererControl()

        : m_surface(0)

    {

    }

    QAbstractVideoSurface *surface() const { return m_surface; }

    void setSurface(QAbstractVideoSurface *surface) { m_surface = surface; }

private:

    QAbstractVideoSurface *m_surface;

};

class QtTestVideoService : public QMediaService

{

    Q_OBJECT

public:

    QtTestVideoService(

            QtTestOutputControl *output,

            QtTestWindowControl *window,

            QtTestWidgetControl *widget,

            QtTestRendererControl *renderer)

        : QMediaService(0)

        , outputControl(output)

        , windowControl(window)

        , widgetControl(widget)

        , rendererControl(renderer)

    {

    }

    ~QtTestVideoService()

    {

        delete outputControl;

        delete windowControl;

        delete widgetControl;

        delete rendererControl;

    }

    QMediaControl *control(const char *name) const

    {

        if (qstrcmp(name, QVideoOutputControl_iid) == 0)

            return outputControl;

        else if (qstrcmp(name, QVideoWindowControl_iid) == 0)

            return windowControl;

        else if (qstrcmp(name, QVideoWidgetControl_iid) == 0)

            return widgetControl;

        else if (qstrcmp(name, QVideoRendererControl_iid) == 0)

            return rendererControl;

        else

            return 0;

    }

    QtTestOutputControl *outputControl;

    QtTestWindowControl *windowControl;

    QtTestWidgetControl *widgetControl;

    QtTestRendererControl *rendererControl;

};

class QtTestVideoObject : public QMediaObject

{

    Q_OBJECT

public:

    QtTestVideoObject(

            QtTestWindowControl *window,

            QtTestWidgetControl *widget,

            QtTestRendererControl *renderer):

        QMediaObject(0, new QtTestVideoService(new QtTestOutputControl, window, widget, renderer))

    {

        testService = qobject_cast<QtTestVideoService*>(service());

        QList<QVideoOutputControl::Output> outputs;

        if (window)

            outputs.append(QVideoOutputControl::WindowOutput);

        if (widget)

            outputs.append(QVideoOutputControl::WidgetOutput);

        if (renderer)

            outputs.append(QVideoOutputControl::RendererOutput);

        testService->outputControl->setAvailableOutputs(outputs);

    }

    QtTestVideoObject(QtTestVideoService *service):

        QMediaObject(0, service),

        testService(service)

    {

    }

    ~QtTestVideoObject()

    {

        delete testService;

    }

    QtTestVideoService *testService;

};

void tst_QVideoWidget::nullObject()

{

    QVideoWidget widget;

    widget.setWindowFlags(Qt::X11BypassWindowManagerHint);

    QVERIFY(widget.sizeHint().isEmpty());

    widget.setFullScreen(true);

    QTest::qWaitForWindowShown(&widget);

    QCOMPARE(widget.isFullScreen(), true);

    widget.setAspectRatioMode(Qt::IgnoreAspectRatio);

    QCOMPARE(widget.aspectRatioMode(), Qt::IgnoreAspectRatio);

    {

        QSignalSpy spy(&widget, SIGNAL(brightnessChanged(int)));

        widget.setBrightness(100);

        QCOMPARE(widget.brightness(), 100);

        QCOMPARE(spy.count(), 1);

        QCOMPARE(spy.value(0).value(0).toInt(), 100);

        widget.setBrightness(100);

        QCOMPARE(widget.brightness(), 100);

        QCOMPARE(spy.count(), 1);

        widget.setBrightness(-120);

        QCOMPARE(widget.brightness(), -100);

        QCOMPARE(spy.count(), 2);

        QCOMPARE(spy.value(1).value(0).toInt(), -100);

    } {

        QSignalSpy spy(&widget, SIGNAL(contrastChanged(int)));

        widget.setContrast(100);

        QCOMPARE(widget.contrast(), 100);

        QCOMPARE(spy.count(), 1);

        QCOMPARE(spy.value(0).value(0).toInt(), 100);

        widget.setContrast(100);

        QCOMPARE(widget.contrast(), 100);

        QCOMPARE(spy.count(), 1);

        widget.setContrast(-120);

        QCOMPARE(widget.contrast(), -100);

        QCOMPARE(spy.count(), 2);

        QCOMPARE(spy.value(1).value(0).toInt(), -100);

    } {

        QSignalSpy spy(&widget, SIGNAL(hueChanged(int)));

        widget.setHue(100);

        QCOMPARE(widget.hue(), 100);

        QCOMPARE(spy.count(), 1);

        QCOMPARE(spy.value(0).value(0).toInt(), 100);

        widget.setHue(100);

        QCOMPARE(widget.hue(), 100);

        QCOMPARE(spy.count(), 1);

        widget.setHue(-120);

        QCOMPARE(widget.hue(), -100);

        QCOMPARE(spy.count(), 2);

        QCOMPARE(spy.value(1).value(0).toInt(), -100);

    } {

        QSignalSpy spy(&widget, SIGNAL(saturationChanged(int)));

        widget.setSaturation(100);

        QCOMPARE(widget.saturation(), 100);

        QCOMPARE(spy.count(), 1);

        QCOMPARE(spy.value(0).value(0).toInt(), 100);

        widget.setSaturation(100);

        QCOMPARE(widget.saturation(), 100);

        QCOMPARE(spy.count(), 1);

        widget.setSaturation(-120);

        QCOMPARE(widget.saturation(), -100);

        QCOMPARE(spy.count(), 2);

        QCOMPARE(spy.value(1).value(0).toInt(), -100);

    }

}

void tst_QVideoWidget::nullService()

{

    QtTestVideoObject object(0);

    QVideoWidget widget;

    widget.setMediaObject(&object);

    widget.setWindowFlags(Qt::X11BypassWindowManagerHint);

    QVERIFY(widget.sizeHint().isEmpty());

    widget.setFullScreen(true);

    QTest::qWaitForWindowShown(&widget);

    QCOMPARE(widget.isFullScreen(), true);

    widget.setAspectRatioMode(Qt::IgnoreAspectRatio);

    QCOMPARE(widget.aspectRatioMode(), Qt::IgnoreAspectRatio);

    widget.setBrightness(100);

    QCOMPARE(widget.brightness(), 100);

    widget.setContrast(100);

    QCOMPARE(widget.contrast(), 100);

    widget.setHue(100);

    QCOMPARE(widget.hue(), 100);

    widget.setSaturation(100);

    QCOMPARE(widget.saturation(), 100);

}

void tst_QVideoWidget::nullOutputControl()

{

    QtTestVideoObject object(new QtTestVideoService(0, 0, 0, 0));

    QVideoWidget widget;

    widget.setMediaObject(&object);

    widget.setWindowFlags(Qt::X11BypassWindowManagerHint);

    QVERIFY(widget.sizeHint().isEmpty());

    widget.setFullScreen(true);

    QTest::qWaitForWindowShown(&widget);

    QCOMPARE(widget.isFullScreen(), true);

    widget.setBrightness(100);

    QCOMPARE(widget.brightness(), 100);

    widget.setContrast(100);

    QCOMPARE(widget.contrast(), 100);

    widget.setHue(100);

    QCOMPARE(widget.hue(), 100);

    widget.setSaturation(100);

    QCOMPARE(widget.saturation(), 100);

}

void tst_QVideoWidget::noOutputs()

{

    QtTestVideoObject object(0, 0, 0);

    QVideoWidget widget;

    widget.setMediaObject(&object);

    widget.setWindowFlags(Qt::X11BypassWindowManagerHint);

    QVERIFY(widget.sizeHint().isEmpty());

    widget.setFullScreen(true);

    QCOMPARE(widget.isFullScreen(), true);

    widget.setBrightness(100);

    QCOMPARE(widget.brightness(), 100);

    widget.setContrast(100);

    QCOMPARE(widget.contrast(), 100);

    widget.setHue(100);

    QCOMPARE(widget.hue(), 100);

    widget.setSaturation(100);

    QCOMPARE(widget.saturation(), 100);

}

void tst_QVideoWidget::serviceDestroyed()

{

    QtTestVideoObject object(new QtTestWindowControl, new QtTestWidgetControl, 0);

    QVideoWidget widget;

    widget.setMediaObject(&object);

    widget.setWindowFlags(Qt::X11BypassWindowManagerHint);

    widget.show();

    QTest::qWaitForWindowShown(&widget);

    widget.setBrightness(100);