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

**

** 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 demonstration 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 "menumanager.h"

#include "colors.h"

#include "menucontent.h"

#include "examplecontent.h"

MenuManager *MenuManager::pInstance = 0;

MenuManager * MenuManager::instance()

{

    if (!MenuManager::pInstance)

        MenuManager::pInstance = new MenuManager();

    return MenuManager::pInstance;

}

MenuManager::MenuManager()

{

    this->ticker = 0;

    this->tickerInAnim = 0;

    this->upButton = 0;

    this->downButton = 0;

    this->helpEngine = 0;

    this->score = new Score();

    this->currentMenu = QLatin1String("[no menu visible]");

    this->currentCategory = QLatin1String("[no category visible]");

    this->currentMenuButtons = QLatin1String("[no menu buttons visible]");

    this->currentInfo = QLatin1String("[no info visible]");

    this->currentMenuCode = -1;

    this->readXmlDocument();

    this->initHelpEngine();

}

MenuManager::~MenuManager()

{

    delete this->score;

    delete this->contentsDoc;

    delete this->helpEngine;

}

QByteArray MenuManager::getResource(const QString &name)

{

    QByteArray ba = this->helpEngine->fileData(name);

    if (Colors::verbose && ba.isEmpty())

        qDebug() << " - WARNING: Could not get " << name;

    return ba;

}

void MenuManager::readXmlDocument()

{

    this->contentsDoc = new QDomDocument();

    QString errorStr;

    int errorLine;

    int errorColumn;

    QFile file(":/xml/examples.xml");

    bool statusOK = this->contentsDoc->setContent(&file, true, &errorStr, &errorLine, &errorColumn);

    if (!statusOK){

        QMessageBox::critical(0,

                              QObject::tr("DOM Parser"),

                              QObject::tr("Could not read or find the contents document. Error at line %1, column %2:\n%3")

                              .arg(errorLine).arg(errorColumn).arg(errorStr)

                              );

        exit(-1);

    }

}

void MenuManager::initHelpEngine()

{

    this->helpRootUrl = QString("qthelp://com.trolltech.qt.%1%2%3/qdoc/")

        .arg(QT_VERSION >> 16).arg((QT_VERSION >> 8) & 0xFF)

        .arg(QT_VERSION & 0xFF);

    // Store help collection file in cache dir of assistant

    QString cacheDir = QDesktopServices::storageLocation(QDesktopServices::DataLocation)

                     + QLatin1String("/Trolltech/Assistant/");

    QString helpDataFile = QString(QLatin1String("qtdemo_%1.qhc")).arg(QLatin1String(QT_VERSION_STR));

    QDir dir;

    if (!dir.exists(cacheDir))

        dir.mkpath(cacheDir);

    // Create help engine (and new

    // helpDataFile if it does not exist):

    this->helpEngine = new QHelpEngineCore(cacheDir + helpDataFile);

    this->helpEngine->setupData();

    QString qtDocRoot = QLibraryInfo::location(QLibraryInfo::DocumentationPath) + QLatin1String("/qch");

    qtDocRoot = QDir(qtDocRoot).absolutePath();

    QStringList qchFiles;

    qchFiles << QLatin1String("/qt.qch")

             << QLatin1String("/designer.qch")

             << QLatin1String("/linguist.qch");

    QString oldDir = helpEngine->customValue(QLatin1String("docDir"), QString()).toString();

    if (oldDir != qtDocRoot) {

        foreach (const QString &qchFile, qchFiles)

            helpEngine->unregisterDocumentation(QHelpEngineCore::namespaceName(qtDocRoot + qchFile));

    }

    // If the data that the engine will work

    // on is not yet registered, do it now:

    foreach (const QString &qchFile, qchFiles)

        helpEngine->registerDocumentation(qtDocRoot + qchFile);

    helpEngine->setCustomValue(QLatin1String("docDir"), qtDocRoot);

}

void MenuManager::itemSelected(int userCode, const QString &menuName)

{

    switch (userCode){

    case LAUNCH:

        this->launchExample(this->currentInfo);

        break;

    case LAUNCH_QML:

        this->launchQmlExample(this->currentInfo);

        break;

    case DOCUMENTATION:

        this->showDocInAssistant(this->currentInfo);

        break;

    case QUIT:

        this->window->loop = false;

        QCoreApplication::quit();

        break;

    case FULLSCREEN:

        this->window->toggleFullscreen();

        break;

    case ROOT:

        // out:

        this->score->queueMovie(this->currentMenu + " -out", Score::FROM_START, Score::LOCK_ITEMS);

        this->score->queueMovie(this->currentMenuButtons + " -out", Score::FROM_START, Score::LOCK_ITEMS);

        this->score->queueMovie(this->currentInfo + " -out");

        this->score->queueMovie(this->currentInfo + " -buttons -out", Score::NEW_ANIMATION_ONLY);

        this->score->queueMovie("back -out", Score::ONLY_IF_VISIBLE);

        if(qmlRoot)

            qmlRoot->setProperty("show", QVariant(false));

        // book-keeping:

        this->currentMenuCode = ROOT;

        this->currentMenu = menuName + " -menu1";

        this->currentMenuButtons = menuName + " -buttons";

        this->currentInfo = menuName + " -info";

        // in:

        this->score->queueMovie("upndown -shake");

        this->score->queueMovie(this->currentMenu, Score::FROM_START, Score::UNLOCK_ITEMS);

        this->score->queueMovie(this->currentMenuButtons, Score::FROM_START, Score::UNLOCK_ITEMS);

        this->score->queueMovie(this->currentInfo);

        if (!Colors::noTicker){

            this->ticker->doIntroTransitions = true;

            this->tickerInAnim->startDelay = 2000;

            this->ticker->useGuideQt();

            this->score->queueMovie("ticker", Score::NEW_ANIMATION_ONLY);

        }

        break;

    case MENU1:

        // out:

        this->score->queueMovie(this->currentMenu + " -out", Score::FROM_START, Score::LOCK_ITEMS);

        this->score->queueMovie(this->currentMenuButtons + " -out", Score::FROM_START, Score::LOCK_ITEMS);

        this->score->queueMovie(this->currentInfo + " -out");

        if(qmlRoot)

            qmlRoot->setProperty("show", QVariant(false));

        // book-keeping:

        this->currentMenuCode = MENU1;

        this->currentCategory = menuName;

        this->currentMenu = menuName + " -menu1";

        this->currentInfo = menuName + " -info";

        // in:

        this->score->queueMovie("upndown -shake");

        this->score->queueMovie("back -in");

        this->score->queueMovie(this->currentMenu, Score::FROM_START, Score::UNLOCK_ITEMS);

        this->score->queueMovie(this->currentInfo);

        if (!Colors::noTicker)

            this->ticker->useGuideTt();

        break;

    case MENU2:

        // out:

        this->score->queueMovie(this->currentInfo + " -out", Score::NEW_ANIMATION_ONLY);

        this->score->queueMovie(this->currentInfo + " -buttons -out", Score::NEW_ANIMATION_ONLY);

        if(qmlRoot)

            qmlRoot->setProperty("show", QVariant(false));

        // book-keeping:

        this->currentMenuCode = MENU2;

        this->currentInfo = menuName;

        // in / shake:

        this->score->queueMovie("upndown -shake");

        this->score->queueMovie("back -shake");

        this->score->queueMovie(this->currentMenu + " -shake");

        this->score->queueMovie(this->currentInfo, Score::NEW_ANIMATION_ONLY);

        this->score->queueMovie(this->currentInfo + " -buttons", Score::NEW_ANIMATION_ONLY);

        if (!Colors::noTicker){

            this->score->queueMovie("ticker -out", Score::NEW_ANIMATION_ONLY);

        }

        break;

    case UP:{

        QString backMenu = this->info[this->currentMenu]["back"];

        if (!backMenu.isNull()){

            this->score->queueMovie(this->currentMenu + " -top_out", Score::FROM_START, Score::LOCK_ITEMS);

            this->score->queueMovie(backMenu + " -bottom_in", Score::FROM_START, Score::UNLOCK_ITEMS);

            this->currentMenu = backMenu;

        }

        break; }

    case DOWN:{

        QString moreMenu = this->info[this->currentMenu]["more"];

        if (!moreMenu.isNull()){

            this->score->queueMovie(this->currentMenu + " -bottom_out", Score::FROM_START, Score::LOCK_ITEMS);

            this->score->queueMovie(moreMenu + " -top_in", Score::FROM_START, Score::UNLOCK_ITEMS);

            this->currentMenu = moreMenu;

        }

        break; }

    case BACK:{

        if (this->currentMenuCode == MENU2){

            // out:

            this->score->queueMovie(this->currentInfo + " -out", Score::NEW_ANIMATION_ONLY);

            this->score->queueMovie(this->currentInfo + " -buttons -out", Score::NEW_ANIMATION_ONLY);

            if(qmlRoot)

                qmlRoot->setProperty("show", QVariant(false));

            // book-keeping:

            this->currentMenuCode = MENU1;

            this->currentMenuButtons = this->currentCategory + " -buttons";

            this->currentInfo = this->currentCategory + " -info";

            // in / shake:

            this->score->queueMovie("upndown -shake");

            this->score->queueMovie(this->currentMenu + " -shake");

            this->score->queueMovie(this->currentInfo, Score::NEW_ANIMATION_ONLY);

            this->score->queueMovie(this->currentInfo + " -buttons", Score::NEW_ANIMATION_ONLY);

            if (!Colors::noTicker){

                this->ticker->doIntroTransitions = false;

                this->tickerInAnim->startDelay = 500;

                this->score->queueMovie("ticker", Score::NEW_ANIMATION_ONLY);

            }

        } else if (this->currentMenuCode != ROOT)

            itemSelected(ROOT, Colors::rootMenuName);

        break; }

    }

    // update back- and more buttons

    bool noBackMenu = this->info[this->currentMenu]["back"].isNull();

    bool noMoreMenu = this->info[this->currentMenu]["more"].isNull();

    this->upButton->setState(noBackMenu ? TextButton::DISABLED : TextButton::OFF);

    this->downButton->setState(noMoreMenu ? TextButton::DISABLED : TextButton::OFF);

    if (this->score->hasQueuedMovies()){

        this->score->playQue();

        // Playing new movies might include

        // loading etc. So ignore the FPS

        // at this point

        this->window->fpsHistory.clear();

    }

}

void MenuManager::showDocInAssistant(const QString &name)

{

    QString url = this->resolveDocUrl(name);

    if (Colors::verbose)

        qDebug() << "Sending URL to Assistant:" << url;

    // Start assistant if it's not already running:

    if (this->assistantProcess.state() != QProcess::Running){

        QString app = QLibraryInfo::location(QLibraryInfo::BinariesPath) + QDir::separator();

#if !defined(Q_OS_MAC)

        app += QLatin1String("assistant");

#else

        app += QLatin1String("Assistant.app/Contents/MacOS/Assistant");

#endif

        QStringList args;

        args << QLatin1String("-enableRemoteControl");

        this->assistantProcess.start(app, args);

        if (!this->assistantProcess.waitForStarted()) {

            QMessageBox::critical(0, tr("Qt Demo"), tr("Could not start Qt Assistant.").arg(app));

            return;

        }

    }

    // Send command through remote control even if the process

    // was started to activate assistant and bring it to front:

    QTextStream str(&this->assistantProcess);

    str << "SetSource " << url << QLatin1Char('\0') << endl;

}

void MenuManager::launchExample(const QString &name)

{

    QString executable = this->resolveExeFile(name);

#ifdef Q_OS_MAC

    if (Colors::verbose)

        qDebug() << "Launching:" << executable;

    bool success = QDesktopServices::openUrl(QUrl::fromLocalFile(executable));

    if (!success){

        QMessageBox::critical(0, tr("Failed to launch the example"),

                          tr("Could not launch the example. Ensure that it has been built."),

                          QMessageBox::Cancel);

    }

#else // Not mac. To not break anything regarding dll's etc, keep it the way it was before:

    QProcess *process = new QProcess(this);

    connect(process, SIGNAL(finished(int)), this, SLOT(exampleFinished()));

    connect(process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(exampleError(QProcess::ProcessError)));

#ifdef Q_OS_WIN

    //make sure it finds the dlls on windows

    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();

    env.insert(QLatin1String("PATH"), QLibraryInfo::location(QLibraryInfo::BinariesPath) 

               + QLatin1Char(';') + env.value(QLatin1String("Path")));

    process->setProcessEnvironment(env);

#endif

    if (info[name]["changedirectory"] != "false"){

        QString workingDirectory = resolveDataDir(name);

        process->setWorkingDirectory(workingDirectory);

        if (Colors::verbose)

            qDebug() << "Setting working directory:" << workingDirectory;

    }

    if (Colors::verbose)

        qDebug() << "Launching:" << executable;

    process->start(executable);

#endif

}

void MenuManager::launchQmlExample(const QString &name)

{

    if(!qmlRoot){

        exampleError(QProcess::UnknownError);

        return;

    }

    //resolveQmlFilename - refactor to separate fn?

    QString dirName = this->info[name]["dirname"];

    QString category = this->info[name]["category"];

    QString fileName = this->info[name]["filename"];

    QDir dir;

    if (category == "demos")

        dir = QDir(QLibraryInfo::location(QLibraryInfo::DemosPath));

    else

        dir = QDir(QLibraryInfo::location(QLibraryInfo::ExamplesPath));

    QFile file(dir.path() + "/" + dirName + "/" + fileName + "/" + "main.qml");

    if(!file.exists()){

        //try dirname.qml as well

        file.setFileName(dir.path() + "/" + dirName + "/" + fileName + "/" + fileName.split('/').last() + ".qml");

        if(!file.exists()){

            exampleError(QProcess::UnknownError);

            return;

        }

    }

    qmlRoot->setProperty("qmlFile", QVariant(""));//unload component

    qmlRoot->setProperty("show", QVariant(true));

    qmlRoot->setProperty("qmlFile", QUrl::fromLocalFile(file.fileName()));

}

void MenuManager::exampleFinished()

{

}

void MenuManager::exampleError(QProcess::ProcessError error)

{

    if (error != QProcess::Crashed)

        QMessageBox::critical(0, tr("Failed to launch the example"),

                          tr("Could not launch the example. Ensure that it has been built."),

                          QMessageBox::Cancel);

}

void MenuManager::init(MainWindow *window)

{

    this->window = window;

    // Create div:

    this->createTicker();

    this->createUpnDownButtons();

    this->createBackButton();

    // Create first level menu:

    QDomElement rootElement = this->contentsDoc->documentElement();

    this->createRootMenu(rootElement);

    // Create second level menus:

    QDomNode level2MenuNode = rootElement.firstChild();

    while (!level2MenuNode.isNull()){

        QDomElement level2MenuElement = level2MenuNode.toElement();

        this->createSubMenu(level2MenuElement);

        // create leaf menu and example info:

        QDomNode exampleNode = level2MenuElement.firstChild();

        while (!exampleNode.isNull()){

            QDomElement exampleElement = exampleNode.toElement();

            this->readInfoAboutExample(exampleElement);

            this->createLeafMenu(exampleElement);

            exampleNode = exampleNode.nextSibling();

        }

        level2MenuNode = level2MenuNode.nextSibling();

    }

    // Create QML Loader

    declarativeEngine = new QDeclarativeEngine(this);

    QDeclarativeComponent component(declarativeEngine, QUrl("qrc:qml/qmlShell.qml"), this);

    qmlRoot = 0;

    if(component.isReady())

        qmlRoot = qobject_cast<QDeclarativeItem*>(component.create());

    else

        qDebug() << component.status() << component.errorString();

    if(qmlRoot){

        qmlRoot->setHeight(this->window->scene->sceneRect().height());

        qmlRoot->setWidth(this->window->scene->sceneRect().width());

        qmlRoot->setZValue(101);//Above other items

        qmlRoot->setCursor(Qt::ArrowCursor);

        window->scene->addItem(qmlRoot);

        //Note that QML adds key handling to the app.

        window->viewport()->setFocusPolicy(Qt::NoFocus);//Correct keyboard focus handling

        window->setFocusPolicy(Qt::StrongFocus);

        window->scene->setStickyFocus(true);

        window->setFocus();

    }else{

        qDebug() << "Error intializing QML subsystem, Declarative examples will not work";

    }

}

void MenuManager::readInfoAboutExample(const QDomElement &example)

{

    QString name = example.attribute("name");

    if (this->info.contains(name))

        qWarning() << "__WARNING: MenuManager::readInfoAboutExample: Demo/example with name"

                    << name << "appears twice in the xml-file!__";

    this->info[name]["filename"] = example.attribute("filename");

    this->info[name]["category"] = example.parentNode().toElement().tagName();

    this->info[name]["dirname"] = example.parentNode().toElement().attribute("dirname");

    this->info[name]["changedirectory"] = example.attribute("changedirectory");

    this->info[name]["image"] = example.attribute("image");

    this->info[name]["qml"] = example.attribute("qml");

}

QString MenuManager::resolveDataDir(const QString &name)

{

    QString dirName = this->info[name]["dirname"];

    QString category = this->info[name]["category"];

    QString fileName = this->info[name]["filename"];

    QDir dir;

    if (category == "demos")

        dir = QDir(QLibraryInfo::location(QLibraryInfo::DemosPath));

    else

        dir = QDir(QLibraryInfo::location(QLibraryInfo::ExamplesPath));

    dir.cd(dirName);

    dir.cd(fileName);

    return dir.absolutePath();

}

QString MenuManager::resolveExeFile(const QString &name)

{

    QString dirName = this->info[name]["dirname"];

    QString category = this->info[name]["category"];

    QString fileName = this->info[name]["filename"];

    QDir dir;

    if (category == "demos")

        dir = QDir(QLibraryInfo::location(QLibraryInfo::DemosPath));

    else

        dir = QDir(QLibraryInfo::location(QLibraryInfo::ExamplesPath));

    dir.cd(dirName);

    dir.cd(fileName);

    QFile unixFile(dir.path() + "/" + fileName);

    if (unixFile.exists()) return unixFile.fileName();

    QFile winR(dir.path() + "\\release\\" + fileName + ".exe");

    if (winR.exists()) return winR.fileName();

    QFile winD(dir.path() + "\\debug\\" + fileName + ".exe");

    if (winD.exists()) return winD.fileName();

    QFile mac(dir.path() + "/" + fileName + ".app");

    if (mac.exists()) return mac.fileName();

    if (Colors::verbose)

        qDebug() << "- WARNING: Could not resolve executable:" << dir.path() << fileName;

    return "__executable not found__";

}

QString MenuManager::resolveDocUrl(const QString &name)

{

    QString dirName = this->info[name]["dirname"];

    QString category = this->info[name]["category"];

    QString fileName = this->info[name]["filename"];