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

**

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

#include "ui_recopts.h"

#include "qmlruntime.h"

#include <qdeclarativecontext.h>

#include <qdeclarativeengine.h>

#include <qdeclarativenetworkaccessmanagerfactory.h>

#include "qdeclarative.h"

#include <private/qabstractanimation_p.h>

#include <QAbstractAnimation>

#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>

#if defined (Q_OS_SYMBIAN)

#define SYMBIAN_NETWORK_INIT

#endif

#if defined (SYMBIAN_NETWORK_INIT)

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <QTextCodec>

#include "sym_iap_util.h"

#endif

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;

};

class SizedMenuBar : public QMenuBar

{

    Q_OBJECT

public:

    SizedMenuBar(QWidget *parent, QWidget *referenceWidget)

        : QMenuBar(parent), refWidget(referenceWidget)

    {

    }

    virtual QSize sizeHint() const

    {

        return QSize(refWidget->sizeHint().width(), QMenuBar::sizeHint().height());

    }

private:

    QWidget *refWidget;

};

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

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

        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;

    }

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 NetworkAccessManagerFactory : public QDeclarativeNetworkAccessManagerFactory

{

public:

    NetworkAccessManagerFactory() : cacheSize(0) {}

    ~NetworkAccessManagerFactory() {}

    QNetworkAccessManager *create(QObject *parent);

    void setupProxy(QNetworkAccessManager *nam)

    {

        class SystemProxyFactory : public QNetworkProxyFactory

        {

        public:

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

            {

                QString protocolTag = query.protocolTag();

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

                    QList<QNetworkProxy> ret;

                    ret << httpProxy;

                    return ret;

                }

                return QNetworkProxyFactory::systemProxyForQuery(query);

            }

            void setHttpProxy (QNetworkProxy proxy)

            {

                httpProxy = proxy;

                httpProxyInUse = true;

            }

            void unsetHttpProxy ()

            {

                httpProxyInUse = false;

            }

        private:

            bool httpProxyInUse;

            QNetworkProxy httpProxy;

        };

        SystemProxyFactory *proxyFactory = new SystemProxyFactory;

        if (ProxySettings::httpProxyInUse())

            proxyFactory->setHttpProxy(ProxySettings::httpProxy());

        else

            proxyFactory->unsetHttpProxy();

        nam->setProxyFactory(proxyFactory);

    }

    void setCacheSize(int size) {

        if (size != cacheSize) {

            cacheSize = size;

        }

    }

    static PersistentCookieJar *cookieJar;

    QMutex mutex;

    int cacheSize;

};

PersistentCookieJar *NetworkAccessManagerFactory::cookieJar = 0;

static void cleanup_cookieJar()

{

    delete NetworkAccessManagerFactory::cookieJar;

    NetworkAccessManagerFactory::cookieJar = 0;

}

QNetworkAccessManager *NetworkAccessManagerFactory::create(QObject *parent)

{

    QMutexLocker lock(&mutex);

    QNetworkAccessManager *manager = new QNetworkAccessManager(parent);

    if (!cookieJar) {

        qAddPostRoutine(cleanup_cookieJar);

        cookieJar = new PersistentCookieJar(0);

    }

    manager->setCookieJar(cookieJar);

    cookieJar->setParent(0);

    setupProxy(manager);

    if (cacheSize > 0) {

        QNetworkDiskCache *cache = new QNetworkDiskCache;

        cache->setCacheDirectory(QDir::tempPath()+QLatin1String("/qml-viewer-network-cache"));

        cache->setMaximumCacheSize(cacheSize);

        manager->setCache(cache);

    } else {

        manager->setCache(0);

    }

    qDebug() << "created new network access manager for" << parent;

    return manager;

}

QString QDeclarativeViewer::getVideoFileName()

{

    QString title = convertAvailable || ffmpegAvailable ? tr("Save Video File") : tr("Save PNG Frames");

    QStringList types;

    if (ffmpegAvailable) types += tr("Common Video files")+QLatin1String(" (*.avi *.mpeg *.mov)");

    if (convertAvailable) types += tr("GIF Animation")+QLatin1String(" (*.gif)");

    types += tr("Individual PNG frames")+QLatin1String(" (*.png)");

    if (ffmpegAvailable) types += tr("All ffmpeg formats (*.*)");

    return QFileDialog::getSaveFileName(this, title, "", types.join(";; "));

}

QDeclarativeViewer::QDeclarativeViewer(QWidget *parent, Qt::WindowFlags flags)

#if defined(Q_OS_SYMBIAN)

    : QMainWindow(parent, flags)

#else

    : QWidget(parent, flags)

#endif

      , loggerWindow(new LoggerWidget())

      , frame_stream(0), mb(0)

      , portraitOrientation(0), landscapeOrientation(0)

      , showWarningsWindow(0)

      , m_scriptOptions(0)

      , tester(0)

      , useQmlFileBrowser(true)

      , translator(0)

{

    QDeclarativeViewer::registerTypes();

    setWindowTitle(tr("Qt QML Viewer"));

    devicemode = false;

    canvas = 0;

    record_autotime = 0;

    record_rate = 50;

    record_args += QLatin1String("-sameq");

    recdlg = new RecordingDialog(this);

    connect(recdlg->pickfile, SIGNAL(clicked()), this, SLOT(pickRecordingFile()));

    senseFfmpeg();

    senseImageMagick();

    if (!ffmpegAvailable)

        recdlg->ffmpegOptions->hide();

    if (!ffmpegAvailable && !convertAvailable)

        recdlg->rateOptions->hide();

    QString warn;

    if (!ffmpegAvailable) {

        if (!convertAvailable)

            warn = tr("ffmpeg and ImageMagick not available - no video output");

        else

            warn = tr("ffmpeg not available - GIF and PNG outputs only");

        recdlg->warning->setText(warn);

    } else {

        recdlg->warning->hide();

    }

    canvas = new QDeclarativeView(this);

    canvas->setAttribute(Qt::WA_OpaquePaintEvent);

    canvas->setAttribute(Qt::WA_NoSystemBackground);

    canvas->setFocus();

    QObject::connect(canvas, SIGNAL(sceneResized(QSize)), this, SLOT(sceneResized(QSize)));

    QObject::connect(canvas, SIGNAL(statusChanged(QDeclarativeView::Status)), this, SLOT(statusChanged()));

    QObject::connect(canvas->engine(), SIGNAL(quit()), QCoreApplication::instance (), SLOT(quit()));

    QObject::connect(warningsWidget(), SIGNAL(opened()), this, SLOT(warningsWidgetOpened()));

    QObject::connect(warningsWidget(), SIGNAL(closed()), this, SLOT(warningsWidgetClosed()));

    if (!(flags & Qt::FramelessWindowHint)) {

        createMenu(menuBar(),0);

        setPortrait();

    }

#if !defined(Q_OS_SYMBIAN)

    QVBoxLayout *layout = new QVBoxLayout;

    layout->setMargin(0);

    layout->setSpacing(0);

    setLayout(layout);

    if (mb)

        layout->addWidget(mb);

    layout->addWidget(canvas);

#else

    setCentralWidget(canvas);

#endif

    namFactory = new NetworkAccessManagerFactory;

    canvas->engine()->setNetworkAccessManagerFactory(namFactory);

    connect(&autoStartTimer, SIGNAL(triggered()), this, SLOT(autoStartRecording()));

    connect(&autoStopTimer, SIGNAL(triggered()), this, SLOT(autoStopRecording()));

    connect(&recordTimer, SIGNAL(triggered()), this, SLOT(recordFrame()));

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

            this, SLOT(orientationChanged()), Qt::QueuedConnection);

    autoStartTimer.setRunning(false);

    autoStopTimer.setRunning(false);

    recordTimer.setRunning(false);

    recordTimer.setRepeating(true);

}

QDeclarativeViewer::~QDeclarativeViewer()

{

    delete loggerWindow;

    canvas->engine()->setNetworkAccessManagerFactory(0);

    delete namFactory;

}

void QDeclarativeViewer::enableExperimentalGestures()

{

    canvas->viewport()->grabGesture(Qt::TapGesture,Qt::DontStartGestureOnChildren|Qt::ReceivePartialGestures|Qt::IgnoredGesturesPropagateToParent);

    canvas->viewport()->grabGesture(Qt::TapAndHoldGesture,Qt::DontStartGestureOnChildren|Qt::ReceivePartialGestures|Qt::IgnoredGesturesPropagateToParent);

    canvas->viewport()->grabGesture(Qt::PanGesture,Qt::DontStartGestureOnChildren|Qt::ReceivePartialGestures|Qt::IgnoredGesturesPropagateToParent);

    canvas->viewport()->grabGesture(Qt::PinchGesture,Qt::DontStartGestureOnChildren|Qt::ReceivePartialGestures|Qt::IgnoredGesturesPropagateToParent);

    canvas->viewport()->grabGesture(Qt::SwipeGesture,Qt::DontStartGestureOnChildren|Qt::ReceivePartialGestures|Qt::IgnoredGesturesPropagateToParent);

    canvas->viewport()->setAttribute(Qt::WA_AcceptTouchEvents);

}

int QDeclarativeViewer::menuBarHeight() const

{

    if (!(windowFlags() & Qt::FramelessWindowHint))

        return menuBar()->height();

    else

        return 0; // don't create menu

}

QMenuBar *QDeclarativeViewer::menuBar() const

{

#if !defined(Q_OS_SYMBIAN)

    if (!mb)

        mb = new SizedMenuBar((QWidget*)this, canvas);

#else

    mb = QMainWindow::menuBar();

#endif

    return mb;

}

QDeclarativeView *QDeclarativeViewer::view() const

{

    return canvas;

}

LoggerWidget *QDeclarativeViewer::warningsWidget() const

{

    return loggerWindow;

}

void QDeclarativeViewer::createMenu(QMenuBar *menu, QMenu *flatmenu)

{

    QObject *parent = flatmenu ? (QObject*)flatmenu : (QObject*)menu;

    QMenu *fileMenu = flatmenu ? flatmenu : menu->addMenu(tr("&File"));

    QAction *openAction = new QAction(tr("&Open..."), parent);

    openAction->setShortcut(QKeySequence("Ctrl+O"));

    connect(openAction, SIGNAL(triggered()), this, SLOT(openFile()));

    fileMenu->addAction(openAction);

    QAction *reloadAction = new QAction(tr("&Reload"), parent);

    reloadAction->setShortcut(QKeySequence("Ctrl+R"));

    connect(reloadAction, SIGNAL(triggered()), this, SLOT(reload()));

    fileMenu->addAction(reloadAction);

#if defined(Q_OS_SYMBIAN)

    QAction *networkAction = new QAction(tr("Start &Network"), parent);

    connect(networkAction, SIGNAL(triggered()), this, SLOT(startNetwork()));

    fileMenu->addAction(networkAction);