static QDeclarativeViewer *openFile(const QString &fileName);

static void showViewer(QDeclarativeViewer *viewer);

static QDeclarativeViewer* globalViewer = 0;

// The qml file that is shown if the user didn't specify a QML file

QString initialFile = "qrc:/startup/startup.qml";

struct ViewerOptions

{

    ViewerOptions()

        : frameless(false),

          fps(0.0),

          autorecord_from(0),

          autorecord_to(0),

          dither("none"),

          runScript(false),

          devkeys(false),

          cache(0),

          useGL(false),

          fullScreen(false),

          stayOnTop(false),

          maximized(false),

          useNativeFileBrowser(true),

          experimentalGestures(false),

          warningsConfig(DefaultWarnings),

          sizeToView(true)

    {

#if defined(Q_OS_SYMBIAN)

        maximized = true;

        useNativeFileBrowser = false;

#endif

#if defined(Q_WS_MAC)

        useGL = true;

#endif

    }

    bool frameless;

    double fps;

    int autorecord_from;

    int autorecord_to;

    QString dither;

    QString recordfile;

    QStringList recordargs;

    QStringList imports;

    QStringList plugins;

    QString script;

    QString scriptopts;

    bool runScript;

    bool devkeys;

    int cache;

    QString translationFile;

    bool useGL;

    bool fullScreen;

    bool stayOnTop;

    bool maximized;

    bool useNativeFileBrowser;

    bool experimentalGestures;

    WarningsConfig warningsConfig;

    bool sizeToView;

    QDeclarativeViewer::ScriptOptions scriptOptions;

};

static ViewerOptions opts;

static QStringList fileNames;

class Application : public QApplication

{

    Q_OBJECT

public:

    Application(int &argc, char **&argv)

        : QApplication(argc, argv)

    {}

protected:

    bool event(QEvent *ev)

    {

        if (ev->type() != QEvent::FileOpen)

            return QApplication::event(ev);

        QFileOpenEvent *fev = static_cast<QFileOpenEvent *>(ev);

        globalViewer->open(fev->file());

        if (!globalViewer->isVisible())

            showViewer(globalViewer);

        return true;

    }

private Q_SLOTS:

    void showInitialViewer()

    {

        QApplication::processEvents();

        QDeclarativeViewer *viewer = globalViewer;

        if (!viewer)

            return;

        if (viewer->currentFile().isEmpty()) {

            if(opts.useNativeFileBrowser)

                viewer->open(initialFile);

            else

                viewer->openFile();

        }

        if (!viewer->isVisible())

            showViewer(viewer);

    }

};

static void parseScriptOptions()

{

    QStringList options =

        opts.scriptopts.split(QLatin1Char(','), QString::SkipEmptyParts);

    QDeclarativeViewer::ScriptOptions scriptOptions = 0;

    for (int i = 0; i < options.count(); ++i) {

        const QString &option = options.at(i);

        if (option == QLatin1String("help")) {

            scriptOptsUsage();

        } else if (option == QLatin1String("play")) {

            scriptOptions |= QDeclarativeViewer::Play;

        } else if (option == QLatin1String("record")) {

            scriptOptions |= QDeclarativeViewer::Record;

        } else if (option == QLatin1String("testimages")) {

            scriptOptions |= QDeclarativeViewer::TestImages;

        } else if (option == QLatin1String("testerror")) {

            scriptOptions |= QDeclarativeViewer::TestErrorProperty;

        } else if (option == QLatin1String("exitoncomplete")) {

            scriptOptions |= QDeclarativeViewer::ExitOnComplete;

        } else if (option == QLatin1String("exitonfailure")) {

            scriptOptions |= QDeclarativeViewer::ExitOnFailure;

        } else if (option == QLatin1String("saveonexit")) {

            scriptOptions |= QDeclarativeViewer::SaveOnExit;

        } else if (option == QLatin1String("snapshot")) {

            scriptOptions |= QDeclarativeViewer::Snapshot;

        } else {

            scriptOptsUsage();

        }

    }

    opts.scriptOptions = scriptOptions;

}

static void parseCommandLineOptions(const QStringList &arguments)

{

    for (int i = 1; i < arguments.count(); ++i) {

        bool lastArg = (i == arguments.count() - 1);

        QString arg = arguments.at(i);

        if (arg == "-frameless") {

            opts.frameless = true;

        } else if (arg == "-maximized") {

            opts.maximized = true;

        } else if (arg == "-fullscreen") {

            opts.fullScreen = true;

        } else if (arg == "-stayontop") {

            opts.stayOnTop = true;

        } else if (arg == "-netcache") {

            if (lastArg) usage();

            opts.cache = arguments.at(++i).toInt();

        } else if (arg == "-recordrate") {

            if (lastArg) usage();

            opts.fps = arguments.at(++i).toDouble();

        } else if (arg == "-recordfile") {

            if (lastArg) usage();

            opts.recordfile = arguments.at(++i);

        } else if (arg == "-record") {

            if (lastArg) usage();

            opts.recordargs << arguments.at(++i);

        } else if (arg == "-recorddither") {

            if (lastArg) usage();

            opts.dither = arguments.at(++i);

        } else if (arg == "-autorecord") {

            if (lastArg) usage();

            QString range = arguments.at(++i);

            int dash = range.indexOf('-');

            if (dash > 0)

                opts.autorecord_from = range.left(dash).toInt();

            opts.autorecord_to = range.mid(dash+1).toInt();

        } else if (arg == "-devicekeys") {

            opts.devkeys = true;

        } else if (arg == "-dragthreshold") {

            if (lastArg) usage();

            qApp->setStartDragDistance(arguments.at(++i).toInt());

        } else if (arg == QLatin1String("-v") || arg == QLatin1String("-version")) {

            qWarning("Qt QML Viewer version %s", QT_VERSION_STR);

            exit(0);

        } else if (arg == "-translation") {

            if (lastArg) usage();

            opts.translationFile = arguments.at(++i);

        } else if (arg == "-opengl") {

            opts.useGL = true;

        } else if (arg == "-qmlbrowser") {

            opts.useNativeFileBrowser = false;

        } else if (arg == "-warnings") {

            if (lastArg) usage();

            QString warningsStr = arguments.at(++i);

            if (warningsStr == QLatin1String("show")) {

                opts.warningsConfig = ShowWarnings;

            } else if (warningsStr == QLatin1String("hide")) {

                opts.warningsConfig = HideWarnings;

            } else {

                usage();

            }

        } else if (arg == "-I" || arg == "-L") {

            if (arg == "-L")

                qWarning("-L option provided for compatibility only, use -I instead");

            if (lastArg) {

                QDeclarativeEngine tmpEngine;

                QString paths = tmpEngine.importPathList().join(QLatin1String(":"));

                qWarning("Current search path: %s", paths.toLocal8Bit().constData());

                exit(0);

            }

            opts.imports << arguments.at(++i);

        } else if (arg == "-P") {

            if (lastArg) usage();

            opts.plugins << arguments.at(++i);

        } else if (arg == "-script") {

            if (lastArg) usage();

            opts.script = arguments.at(++i);

        } else if (arg == "-scriptopts") {

            if (lastArg) usage();

            opts.scriptopts = arguments.at(++i);

        } else if (arg == "-savescript") {

            if (lastArg) usage();

            opts.script = arguments.at(++i);

            opts.runScript = false;