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

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtSCriptTools module 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 "qscriptdebugger_p.h"

#include "qscriptdebuggerconsole_p.h"

#include "qscriptdebuggerconsolecommandmanager_p.h"

#include "qscriptdebuggerconsolecommandjob_p.h"

#include "qscriptstdmessagehandler_p.h"

#include "qscriptdebuggerfrontend_p.h"

#include "qscriptdebuggereventhandlerinterface_p.h"

#include "qscriptdebuggerresponsehandlerinterface_p.h"

#include "qscriptdebuggerjobschedulerinterface_p.h"

#include "qscriptdebuggerconsolewidgetinterface_p.h"

#include "qscriptcompletionproviderinterface_p.h"

#include "qscriptcompletiontask_p.h"

#include "qscripttooltipproviderinterface_p.h"

#include "qscriptdebuggerstackwidgetinterface_p.h"

#include "qscriptdebuggerstackmodel_p.h"

#include "qscriptdebuggerscriptswidgetinterface_p.h"

#include "qscriptdebuggerscriptsmodel_p.h"

#include "qscriptdebuggerlocalswidgetinterface_p.h"

#include "qscriptdebuggerlocalsmodel_p.h"

#include "qscriptdebuggercodewidgetinterface_p.h"

#include "qscriptdebuggercodeviewinterface_p.h"

#include "qscriptdebuggercodefinderwidgetinterface_p.h"

#include "qscriptbreakpointswidgetinterface_p.h"

#include "qscriptbreakpointsmodel_p.h"

#include "qscriptdebugoutputwidgetinterface_p.h"

#include "qscripterrorlogwidgetinterface_p.h"

#include "qscriptdebuggerwidgetfactoryinterface_p.h"

#include "qscriptdebuggerevent_p.h"

#include "qscriptdebuggervalue_p.h"

#include "qscriptdebuggerresponse_p.h"

#include "qscriptdebuggercommand_p.h"

#include "qscriptdebuggercommandschedulerfrontend_p.h"

#include "qscriptdebuggercommandschedulerjob_p.h"

#include "qscriptdebuggerjob_p_p.h"

#include "qscriptxmlparser_p.h"

#include "private/qobject_p.h"

#include <QtScript/qscriptcontext.h>

#include <QtScript/qscriptcontextinfo.h>

#include <QtCore/qcoreapplication.h>

#include <QtCore/qdir.h>

#include <QtCore/qfileinfo.h>

#include <QtCore/qstringlist.h>

#include <QtCore/qdebug.h>

#include <QtGui/qaction.h>

#include <QtGui/qevent.h>

#include <QtGui/qicon.h>

#include <QtGui/qinputdialog.h>

#include <QtGui/qmenu.h>

#include <QtGui/qtoolbar.h>

#include <QtGui/qtooltip.h>

QT_BEGIN_NAMESPACE

typedef QPair<QList<qint64>, QList<qint64> > QScriptScriptsDelta;

typedef QPair<QList<qint64>, QList<qint64> > QScriptContextsDelta;

QT_END_NAMESPACE

Q_DECLARE_METATYPE(QScriptScriptsDelta)

QT_BEGIN_NAMESPACE

Q_SCRIPT_EXPORT QString qt_scriptToXml(const QString &program, int lineNumber = 1);

namespace {

static int scriptDebuggerCount = 0;

static bool eventCallbackRegistered = false;

static bool widgetInPaintEvent = false;

static bool scriptDebuggerEventCallback(void **data)

{

    QEvent *event = reinterpret_cast<QEvent*>(data[1]);

    if (event->type() == QEvent::Paint) {

        QObject *receiver = reinterpret_cast<QObject*>(data[0]);

        bool was = widgetInPaintEvent;

        widgetInPaintEvent = true;

        QCoreApplication::instance()->notify(receiver, event);

        widgetInPaintEvent = was;

        bool *result = reinterpret_cast<bool*>(data[2]);

        *result = true;

        return true;

    }

    return false;

}

}

/*!

  \since 4.5

  \class QScriptDebugger

  \internal

  \brief The QScriptDebugger class provides a Qt Script debugger.

  \ingroup script

*/

class QScriptDebuggerPrivate

    : public QObjectPrivate,

      public QScriptDebuggerCommandSchedulerInterface,

      public QScriptDebuggerJobSchedulerInterface,

      public QScriptDebuggerEventHandlerInterface,

      public QScriptDebuggerResponseHandlerInterface,

      public QScriptCompletionProviderInterface,

      public QScriptToolTipProviderInterface

{

    Q_DECLARE_PUBLIC(QScriptDebugger)

public:

    QScriptDebuggerPrivate();

    ~QScriptDebuggerPrivate();

    int scheduleJob(QScriptDebuggerJob *job);

    void finishJob(QScriptDebuggerJob *job);

    void hibernateUntilEvaluateFinished(QScriptDebuggerJob *job);

    void maybeStartNewJob();

    int scheduleCommand(const QScriptDebuggerCommand &command,

                        QScriptDebuggerResponseHandlerInterface *responseHandler);

    void handleResponse(

        const QScriptDebuggerResponse &response, int commandId);

    bool debuggerEvent(const QScriptDebuggerEvent &event);

    QScriptCompletionTaskInterface *createCompletionTask(

        const QString &contents, int cursorPosition, int frameIndex, int options);

    void showToolTip(const QPoint &pos, int frameIndex,

                     int lineNumber, const QStringList &path);

    static QPixmap pixmap(const QString &path);

    void startInteraction(QScriptDebuggerEvent::Type type,

                          qint64 scriptId, int lineNumber);

    void sync();

    void loadLocals(int frameIndex);

    QScriptDebuggerLocalsModel *createLocalsModel();

    void selectScriptForFrame(int frameIndex);

    void emitStoppedSignal();

    void maybeDelete(QWidget *widget);

    // private slots

    void _q_onLineEntered(const QString &contents);

    void _q_onCurrentFrameChanged(int frameIndex);

    void _q_onCurrentScriptChanged(qint64 scriptId);

    void _q_onScriptLocationSelected(int lineNumber);

    void _q_interrupt();

    void _q_continue();

    void _q_stepInto();

    void _q_stepOver();

    void _q_stepOut();

    void _q_runToCursor();

    void _q_runToNewScript();

    void _q_toggleBreakpoint();

    void _q_clearDebugOutput();

    void _q_clearErrorLog();

    void _q_clearConsole();

    void _q_findInScript();

    void _q_findNextInScript();

    void _q_findPreviousInScript();

    void _q_onFindCodeRequest(const QString &, int);

    void _q_goToLine();

    void executeConsoleCommand(const QString &command);

    void findCode(const QString &exp, int options);

    QScriptDebuggerFrontend *frontend;

    bool interactive;

    QScriptDebuggerConsole *console;

    int nextJobId;

    QList<QScriptDebuggerJob*> pendingJobs;

    QList<int> pendingJobIds;

    QScriptDebuggerJob *activeJob;

    bool activeJobHibernating;

    QHash<int, QScriptDebuggerCommand> watchedCommands;

    QHash<int, QScriptDebuggerResponseHandlerInterface*> responseHandlers;

    QScriptDebuggerConsoleWidgetInterface *consoleWidget;

    QScriptDebuggerStackWidgetInterface *stackWidget;

    QScriptDebuggerStackModel *stackModel;

    QScriptDebuggerScriptsWidgetInterface *scriptsWidget;

    QScriptDebuggerScriptsModel *scriptsModel;

    QScriptDebuggerLocalsWidgetInterface *localsWidget;

    QHash<int, QScriptDebuggerLocalsModel*> localsModels;

    QScriptDebuggerCodeWidgetInterface *codeWidget;

    QScriptDebuggerCodeFinderWidgetInterface *codeFinderWidget;

    QScriptBreakpointsWidgetInterface *breakpointsWidget;

    QScriptBreakpointsModel *breakpointsModel;

    QScriptDebugOutputWidgetInterface *debugOutputWidget;

    QScriptErrorLogWidgetInterface *errorLogWidget;

    QScriptDebuggerWidgetFactoryInterface *widgetFactory;

    QAction *interruptAction;

    QAction *continueAction;

    QAction *stepIntoAction;

    QAction *stepOverAction;

    QAction *stepOutAction;

    QAction *runToCursorAction;

    QAction *runToNewScriptAction;

    QAction *toggleBreakpointAction;

    QAction *clearDebugOutputAction;

    QAction *clearErrorLogAction;

    QAction *clearConsoleAction;

    QAction *findInScriptAction;

    QAction *findNextInScriptAction;

    QAction *findPreviousInScriptAction;

    QAction *goToLineAction;

    int updatesEnabledTimerId;

};

QScriptDebuggerPrivate::QScriptDebuggerPrivate()

{

    frontend = 0;

    activeJob = 0;

    activeJobHibernating = false;

    nextJobId = 0;

    interactive = false;

    console = new QScriptDebuggerConsole();

    QString scriptsPath = QLatin1String(":/qt/scripttools/debugging/scripts/commands");

    QScriptStdMessageHandler tmp;

    console->loadScriptedCommands(scriptsPath, &tmp);

    consoleWidget = 0;

    stackWidget = 0;

    stackModel = 0;

    scriptsWidget = 0;

    scriptsModel = 0;

    localsWidget = 0;

    codeWidget = 0;

    codeFinderWidget = 0;

    breakpointsWidget = 0;

    breakpointsModel = 0;

    debugOutputWidget = 0;

    errorLogWidget = 0;

    widgetFactory = 0;

    interruptAction = 0;

    continueAction = 0;

    stepIntoAction = 0;

    stepOverAction = 0;

    stepOutAction = 0;

    runToCursorAction = 0;

    runToNewScriptAction = 0;

    toggleBreakpointAction = 0;

    clearErrorLogAction = 0;

    clearDebugOutputAction = 0;

    clearConsoleAction = 0;

    findInScriptAction = 0;

    findNextInScriptAction = 0;

    findPreviousInScriptAction = 0;

    goToLineAction = 0;

    updatesEnabledTimerId = -1;

}

QScriptDebuggerPrivate::~QScriptDebuggerPrivate()

{

    delete console;

    qDeleteAll(pendingJobs);

    delete activeJob;

    maybeDelete(consoleWidget);

    maybeDelete(stackWidget);

    maybeDelete(scriptsWidget);

    maybeDelete(localsWidget);

    maybeDelete(codeWidget);

    maybeDelete(codeFinderWidget);

    maybeDelete(breakpointsWidget);

    maybeDelete(debugOutputWidget);

    maybeDelete(errorLogWidget);

}

void QScriptDebuggerPrivate::maybeDelete(QWidget *widget)

{

    if (widget && !widget->parent())

        delete widget;

}

QPixmap QScriptDebuggerPrivate::pixmap(const QString &path)

{

    static QString prefix = QString::fromLatin1(":/qt/scripttools/debugging/images/");

    return QPixmap(prefix + path);

}

/*!

  \reimp

*/

int QScriptDebuggerPrivate::scheduleJob(QScriptDebuggerJob *job)

{

    QScriptDebuggerJobPrivate *priv = QScriptDebuggerJobPrivate::get(job);

    Q_ASSERT(priv->jobScheduler == 0);

    priv->jobScheduler = this;

    int id = nextJobId;

    pendingJobs.append(job);

    pendingJobIds.append(id);

    maybeStartNewJob();

    return id;

}

/*!

  \reimp

*/

void QScriptDebuggerPrivate::finishJob(QScriptDebuggerJob *job)

{

    Q_UNUSED(job);

    Q_ASSERT(activeJob == job);

    delete activeJob;

    activeJob = 0;

    activeJobHibernating = false;

    maybeStartNewJob();

}

/*!

  \reimp

*/

void QScriptDebuggerPrivate::hibernateUntilEvaluateFinished(QScriptDebuggerJob *job)

{

    Q_UNUSED(job);

    Q_ASSERT(activeJob == job);

    activeJobHibernating = true;

}

/*!

  Starts a new job if appropriate.

*/

void QScriptDebuggerPrivate::maybeStartNewJob()

{

    if (activeJob || pendingJobs.isEmpty())

        return;

    activeJob = pendingJobs.takeFirst();

    activeJob->start();

}

/*!

  \reimp

*/

int QScriptDebuggerPrivate::scheduleCommand(

    const QScriptDebuggerCommand &command,

    QScriptDebuggerResponseHandlerInterface *responseHandler)

{

    if (!frontend)

        return -1;

    int id = frontend->scheduleCommand(command, this);

    if (responseHandler && (responseHandler != this))

        responseHandlers.insert(id, responseHandler);

    if ((command.type() == QScriptDebuggerCommand::SetBreakpoint)

        || (command.type() == QScriptDebuggerCommand::SetBreakpointData)

        || (command.type() == QScriptDebuggerCommand::DeleteBreakpoint)) {

        // need to watch this command and update the breakpoints model afterwards

        watchedCommands.insert(id, command);

    }

    return id;

}

/*!

  \reimp

*/

void QScriptDebuggerPrivate::handleResponse(

    const QScriptDebuggerResponse &response, int commandId)

{

    Q_Q(QScriptDebugger);

    if (watchedCommands.contains(commandId)) {

        QScriptDebuggerCommand command = watchedCommands.take(commandId);

        if (response.error() == QScriptDebuggerResponse::NoError) {

            if (!breakpointsModel)

                breakpointsModel = new QScriptBreakpointsModel(this, this, q);

            switch (command.type()) {

            case QScriptDebuggerCommand::SetBreakpoint: {

                int breakpointId = response.resultAsInt();

                QScriptBreakpointData data = command.breakpointData();

                breakpointsModel->addBreakpoint(breakpointId, data);

            }   break;

            case QScriptDebuggerCommand::SetBreakpointData: {

                int breakpointId = command.breakpointId();

                QScriptBreakpointData data = command.breakpointData();

                breakpointsModel->modifyBreakpoint(breakpointId, data);

            }   break;

            case QScriptDebuggerCommand::DeleteBreakpoint: {

                int breakpointId = command.breakpointId();

                breakpointsModel->removeBreakpoint(breakpointId);

            }   break;

            default:

                Q_ASSERT(false);

            }

        }

    } else if (response.async()) {

        interactive = false;

        // disable/invalidate/enable stuff

        if (continueAction)

            continueAction->setEnabled(false);

        if (stepIntoAction)

            stepIntoAction->setEnabled(false);

        if (stepOverAction)

            stepOverAction->setEnabled(false);

        if (stepOutAction)

            stepOutAction->setEnabled(false);

        if (runToCursorAction)

            runToCursorAction->setEnabled(false);

        if (runToNewScriptAction)

            runToNewScriptAction->setEnabled(false);

        if (interruptAction)

            interruptAction->setEnabled(true);

        // the timer is to avoid flicker when stepping

        if (stackWidget) {

            stackWidget->setUpdatesEnabled(false);

            stackWidget->setEnabled(false);

            if (updatesEnabledTimerId == -1)

                updatesEnabledTimerId = q->startTimer(75);

        }

        if (localsWidget) {

            localsWidget->setUpdatesEnabled(false);

            localsWidget->setEnabled(false);

            if (updatesEnabledTimerId == -1)

                updatesEnabledTimerId = q->startTimer(75);

        }

        if (codeWidget)

            codeWidget->invalidateExecutionLineNumbers();

        emit q->started();

    }

    QScriptDebuggerResponseHandlerInterface *realHandler = responseHandlers.take(commandId);

    if (realHandler)

        realHandler->handleResponse(response, commandId);

}

/*!

  \reimp

  Handles a debugger event from the frontend.

*/

bool QScriptDebuggerPrivate::debuggerEvent(const QScriptDebuggerEvent &event)

{

    Q_Q(QScriptDebugger);

    switch (event.type()) {

    case QScriptDebuggerEvent::None:

    case QScriptDebuggerEvent::UserEvent:

    case QScriptDebuggerEvent::MaxUserEvent:

        Q_ASSERT(false);

        break;

    case QScriptDebuggerEvent::Trace:

        if (!debugOutputWidget && widgetFactory)

            q->setDebugOutputWidget(widgetFactory->createDebugOutputWidget());

        if (debugOutputWidget)

            debugOutputWidget->message(QtDebugMsg, event.message());

        return true; // trace doesn't stall execution

    case QScriptDebuggerEvent::SteppingFinished: {

        if (!consoleWidget && widgetFactory)

            q->setConsoleWidget(widgetFactory->createConsoleWidget());

        if (consoleWidget) {

            QString msg = event.message();

            if (!msg.isEmpty())

                consoleWidget->message(QtDebugMsg, msg);

        }

    }   break;

    case QScriptDebuggerEvent::Interrupted:

    case QScriptDebuggerEvent::LocationReached:

        break;

    case QScriptDebuggerEvent::Breakpoint: {

        int bpId = event.breakpointId();

        if (!consoleWidget && widgetFactory)

            q->setConsoleWidget(widgetFactory->createConsoleWidget());

        if (consoleWidget) {

            consoleWidget->message(QtDebugMsg,

                                   QString::fromLatin1("Breakpoint %0 at %1, line %2.")

                                   .arg(bpId).arg(event.fileName())

                                   .arg(event.lineNumber()));

        }