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

**

** 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 tools 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 <qdeclarativeview.h>

#ifdef hz

#undef hz

#endif

#ifdef Q_WS_MAEMO_5

#  include <QMaemo5ValueButton>

#  include <QMaemo5ListPickSelector>

#  include <QWidgetAction>

#  include <QStringListModel>

#  include "ui_recopts_maemo5.h"

#else

#  include "ui_recopts.h"

#endif

#include "qmlruntime.h"

#include <qdeclarativecontext.h>

#include <qdeclarativeengine.h>

#include <qdeclarativenetworkaccessmanagerfactory.h>

#include "qdeclarative.h"

#include <QAbstractAnimation>

#include <private/qabstractanimation_p.h>

#include <QSettings>

#include <QXmlStreamReader>

#include <QBuffer>

#include <QNetworkReply>

#include <QNetworkCookieJar>

#include <QNetworkDiskCache>

#include <QNetworkAccessManager>

#include <QSignalMapper>

#include <QDeclarativeComponent>

#include <QWidget>

#include <QApplication>

#include <QTranslator>

#include <QDir>

#include <QTextBrowser>

#include <QFile>

#include <QFileInfo>

#include <QVBoxLayout>

#include <QProgressDialog>

#include <QProcess>

#include <QMenuBar>

#include <QMenu>

#include <QAction>

#include <QFileDialog>

#include <QTimer>

#include <QGraphicsObject>

#include <QNetworkProxyFactory>

#include <QKeyEvent>

#include <QMutex>

#include <QMutexLocker>

#include "proxysettings.h"

#include "deviceorientation.h"

#ifdef GL_SUPPORTED

#include <QGLWidget>

#endif

#include <qdeclarativetester.h>

QT_BEGIN_NAMESPACE

class Runtime : public QObject

{

    Q_OBJECT

    Q_PROPERTY(bool isActiveWindow READ isActiveWindow NOTIFY isActiveWindowChanged)

    Q_PROPERTY(DeviceOrientation::Orientation orientation READ orientation NOTIFY orientationChanged)

public:

    static Runtime* instance()

    {

        static Runtime *instance = 0;

        if (!instance)

            instance = new Runtime;

        return instance;

    }

    bool isActiveWindow() const { return activeWindow; }

    void setActiveWindow(bool active)

    {

        if (active == activeWindow)

            return;

        activeWindow = active;

        emit isActiveWindowChanged();

    }

    DeviceOrientation::Orientation orientation() const { return DeviceOrientation::instance()->orientation(); }

Q_SIGNALS:

    void isActiveWindowChanged();

    void orientationChanged();

private:

    Runtime(QObject *parent=0) : QObject(parent), activeWindow(false)

    {

        connect(DeviceOrientation::instance(), SIGNAL(orientationChanged()),

                this, SIGNAL(orientationChanged()));

    }

    bool activeWindow;

};

#if defined(Q_WS_MAEMO_5)

class Maemo5PickerAction : public QWidgetAction {

    Q_OBJECT

public:

    Maemo5PickerAction(const QString &text, QActionGroup *actions, QObject *parent)

        : QWidgetAction(parent), m_text(text), m_actions(actions)

    { }

    QWidget *createWidget(QWidget *parent)

    {

	QMaemo5ValueButton *button = new QMaemo5ValueButton(m_text, parent);

	button->setValueLayout(QMaemo5ValueButton::ValueUnderTextCentered);

        QMaemo5ListPickSelector *pick = new QMaemo5ListPickSelector(button);

	button->setPickSelector(pick);

	if (m_actions) {

	    QStringList sl;

	    int curIdx = -1, idx = 0;

	    foreach (QAction *a, m_actions->actions()) {

		sl << a->text();

		if (a->isChecked())

		    curIdx = idx;

		idx++;

            }

	    pick->setModel(new QStringListModel(sl));

	    pick->setCurrentIndex(curIdx);

	} else {

	    button->setEnabled(false);

	}

	connect(pick, SIGNAL(selected(QString)), this, SLOT(emitTriggered()));

	return button;

    }

private slots:

    void emitTriggered()

    {

	QMaemo5ListPickSelector *pick = qobject_cast<QMaemo5ListPickSelector *>(sender());

	if (!pick)

	    return;

	int idx = pick->currentIndex();

	if (m_actions && idx >= 0 && idx < m_actions->actions().count())

	    m_actions->actions().at(idx)->trigger();

    }

private:

    QString m_text;

    QPointer<QActionGroup> m_actions;

};

#endif // Q_WS_MAEMO_5

static struct { const char *name, *args; } ffmpegprofiles[] = {

    {"Maximum Quality", "-sameq"},

    {"High Quality", "-qmax 2"},

    {"Medium Quality", "-qmax 6"},

    {"Low Quality", "-qmax 16"},

    {"Custom ffmpeg arguments", ""},

    {0,0}

};

class RecordingDialog : public QDialog, public Ui::RecordingOptions {

    Q_OBJECT

public:

    RecordingDialog(QWidget *parent) : QDialog(parent)

    {

        setupUi(this);

#ifndef Q_WS_MAEMO_5

        hz->setValidator(new QDoubleValidator(hz));

#endif

        for (int i=0; ffmpegprofiles[i].name; ++i) {

            profile->addItem(ffmpegprofiles[i].name);

        }

    }

    void setArguments(QString a)

    {

        int i;

        for (i=0; ffmpegprofiles[i].args[0]; ++i) {

            if (ffmpegprofiles[i].args == a) {

                profile->setCurrentIndex(i);

                args->setText(QLatin1String(ffmpegprofiles[i].args));

                return;

            }

        }

        customargs = a;

        args->setText(a);

        profile->setCurrentIndex(i);

    }

    QString arguments() const

    {

        int i = profile->currentIndex();

        return ffmpegprofiles[i].args[0] ? QLatin1String(ffmpegprofiles[i].args) : customargs;

    }

    void setOriginalSize(const QSize &s)

    {

        QString str = tr("Original (%1x%2)").arg(s.width()).arg(s.height());

#ifdef Q_WS_MAEMO_5

        sizeCombo->setItemText(0, str);

#else

        sizeOriginal->setText(str);

        if (sizeWidth->value()<=1) {

            sizeWidth->setValue(s.width());

            sizeHeight->setValue(s.height());

        }

#endif

    }

    void showffmpegOptions(bool b)

    {

#ifdef Q_WS_MAEMO_5

        profileLabel->setVisible(b);

        profile->setVisible(b);

        ffmpegHelp->setVisible(b);

        args->setVisible(b);

#else

        ffmpegOptions->setVisible(b);

#endif

    }

    void showRateOptions(bool b)

    {

#ifdef Q_WS_MAEMO_5

        rateLabel->setVisible(b);

        rateCombo->setVisible(b);

#else

        rateOptions->setVisible(b);

#endif

    }

    void setVideoRate(int rate)

    {

#ifdef Q_WS_MAEMO_5

        int idx;

        if (rate >= 60)

            idx = 0;

        else if (rate >= 50)

            idx = 2;

        else if (rate >= 25)

            idx = 3;

        else if (rate >= 24)

            idx = 4;

        else if (rate >= 20)

            idx = 5;

        else if (rate >= 15)

            idx = 6;

        else

            idx = 7;

        rateCombo->setCurrentIndex(idx);

#else

        if (rate == 24)

            hz24->setChecked(true);

        else if (rate == 25)

            hz25->setChecked(true);

        else if (rate == 50)

            hz50->setChecked(true);

        else if (rate == 60)

            hz60->setChecked(true);

        else {

            hzCustom->setChecked(true);

            hz->setText(QString::number(rate));

        }

#endif

    }

    int videoRate() const

    {

#ifdef Q_WS_MAEMO_5

        switch (rateCombo->currentIndex()) {

            case 0: return 60;

            case 1: return 50;

            case 2: return 25;

            case 3: return 24;

            case 4: return 20;

            case 5: return 15;

            case 7: return 10;

            default: return 60;

        }

#else

        if (hz24->isChecked())

            return 24;

        else if (hz25->isChecked())

            return 25;

        else if (hz50->isChecked())

            return 50;

        else if (hz60->isChecked())

            return 60;

        else {

            return hz->text().toInt();

        }

#endif

    }

    QSize videoSize() const

    {

#ifdef Q_WS_MAEMO_5

        switch (sizeCombo->currentIndex()) {

            case 0: return QSize();

            case 1: return QSize(640,480);

            case 2: return QSize(320,240);

            case 3: return QSize(1280,720);

            default: return QSize();

        }

#else

        if (sizeOriginal->isChecked())

            return QSize();

        else if (size720p->isChecked())

            return QSize(1280,720);

        else if (sizeVGA->isChecked())

            return QSize(640,480);

        else if (sizeQVGA->isChecked())

            return QSize(320,240);

        else

            return QSize(sizeWidth->value(), sizeHeight->value());

#endif

    }

private slots:

    void pickProfile(int i)

    {

        if (ffmpegprofiles[i].args[0]) {

            args->setText(QLatin1String(ffmpegprofiles[i].args));

        } else {

            args->setText(customargs);

        }

    }

    void storeCustomArgs(QString s)

    {

        setArguments(s);

    }

private:

    QString customargs;

};

class PersistentCookieJar : public QNetworkCookieJar {

public:

    PersistentCookieJar(QObject *parent) : QNetworkCookieJar(parent) { load(); }

    ~PersistentCookieJar() { save(); }

    virtual QList<QNetworkCookie> cookiesForUrl(const QUrl &url) const

    {

        QMutexLocker lock(&mutex);

        return QNetworkCookieJar::cookiesForUrl(url);

    }

    virtual bool setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url)

    {

        QMutexLocker lock(&mutex);

        return QNetworkCookieJar::setCookiesFromUrl(cookieList, url);

    }

private:

    void save()

    {

        QMutexLocker lock(&mutex);

        QList<QNetworkCookie> list = allCookies();

        QByteArray data;

        foreach (QNetworkCookie cookie, list) {

            if (!cookie.isSessionCookie()) {

                data.append(cookie.toRawForm());

                data.append("\n");

            }

        }

        QSettings settings;

        settings.setValue("Cookies",data);

    }

    void load()

    {

        QMutexLocker lock(&mutex);

        QSettings settings;

        QByteArray data = settings.value("Cookies").toByteArray();

        setAllCookies(QNetworkCookie::parseCookies(data));

    }

    mutable QMutex mutex;

};

class SystemProxyFactory : public QNetworkProxyFactory

{

public:

    SystemProxyFactory() : proxyDirty(true), httpProxyInUse(false) {

    }

    virtual QList<QNetworkProxy> queryProxy(const QNetworkProxyQuery &query)

    {

        if (proxyDirty)

            setupProxy();

        QString protocolTag = query.protocolTag();

        if (httpProxyInUse && (protocolTag == "http" || protocolTag == "https")) {

            QList<QNetworkProxy> ret;

            ret << httpProxy;

            return ret;

        }

#ifdef Q_OS_WIN

        // systemProxyForQuery can take insanely long on Windows (QTBUG-10106)

        return QNetworkProxyFactory::proxyForQuery(query);

#else

        return QNetworkProxyFactory::systemProxyForQuery(query);

#endif

    }

    void setupProxy() {

        // Don't bother locking because we know that the proxy only

        // changes in response to the settings dialog and that

        // the view will be reloaded.