class DebuggerEnginePrivate;
class DebuggerRunControl;
-class QmlCppEngine;
class DEBUGGER_EXPORT DebuggerStartParameters
{
class ThreadsHandler;
class WatchHandler;
class BreakpointParameters;
+class QmlCppEngine;
struct WatchUpdateFlags
{
private:
// Wrapper engine needs access to state of its subengines.
- friend class QmlCppEngine;
+ friend class Internal::QmlCppEngine;
void setState(DebuggerState state, bool forced = false);
void setSlaveEngine(bool value);
QmlCppEnginePrivate();
~QmlCppEnginePrivate() {}
- friend class Debugger::QmlCppEngine;
+ friend class QmlCppEngine;
private:
- QmlEngine *m_qmlEngine;
+ DebuggerEngine *m_qmlEngine;
DebuggerEngine *m_cppEngine;
DebuggerEngine *m_activeEngine;
DebuggerState m_errorState;
m_errorState(InferiorRunOk)
{}
-} // namespace Internal
-
-using namespace Internal;
QmlCppEngine::QmlCppEngine(const DebuggerStartParameters &sp)
: DebuggerEngine(sp), d(new QmlCppEnginePrivate)
{
- d->m_qmlEngine = qobject_cast<QmlEngine*>(Internal::createQmlEngine(sp));
+ d->m_qmlEngine = createQmlEngine(sp);
if (startParameters().cppEngineType == GdbEngineType) {
- d->m_cppEngine = Internal::createGdbEngine(sp);
+ d->m_cppEngine = createGdbEngine(sp);
} else {
QString errorMessage;
- d->m_cppEngine = Internal::createCdbEngine(sp, &errorMessage);
+ d->m_cppEngine = createCdbEngine(sp, &errorMessage);
if (!d->m_cppEngine) {
qWarning("%s", qPrintable(errorMessage));
return;
void QmlCppEngine::attemptBreakpointSynchronization()
{
d->m_cppEngine->attemptBreakpointSynchronization();
- static_cast<DebuggerEngine*>(d->m_qmlEngine)->attemptBreakpointSynchronization();
+ d->m_qmlEngine->attemptBreakpointSynchronization();
}
bool QmlCppEngine::acceptsBreakpoint(BreakpointId id) const
return d->m_cppEngine;
}
-
+} // namespace Internal
} // namespace Debugger
}
namespace Debugger {
-
namespace Internal {
+
class QmlCppEnginePrivate;
-} // namespace Internal
class DEBUGGER_EXPORT QmlCppEngine : public DebuggerEngine
{
virtual void setToolTipExpression(const QPoint &mousePos,
TextEditor::ITextEditor * editor, int cursorPos);
- virtual void updateWatchData(const Internal::WatchData &data,
- const Internal::WatchUpdateFlags &flags);
+ virtual void updateWatchData(const WatchData &data,
+ const WatchUpdateFlags &flags);
virtual void watchPoint(const QPoint &);
- virtual void fetchMemory(Internal::MemoryViewAgent *, QObject *,
+ virtual void fetchMemory(MemoryViewAgent *, QObject *,
quint64 addr, quint64 length);
- virtual void fetchDisassembler(Internal::DisassemblerViewAgent *);
+ virtual void fetchDisassembler(DisassemblerViewAgent *);
virtual void activateFrame(int index);
virtual void reloadModules();
virtual bool acceptsBreakpoint(BreakpointId id) const;
virtual void selectThread(int index);
- virtual void assignValueInDebugger(const Internal::WatchData *data,
+ virtual void assignValueInDebugger(const WatchData *data,
const QString &expr, const QVariant &value);
QAbstractItemModel *modulesModel() const;
void engineStateChanged(const DebuggerState &newState);
private:
- QScopedPointer<Internal::QmlCppEnginePrivate> d;
+ QScopedPointer<QmlCppEnginePrivate> d;
};
+} // namespace Internal
} // namespace Debugger
#endif // QMLGDBENGINE_H
explicit QmlEnginePrivate(QmlEngine *q);
~QmlEnginePrivate() { delete m_adapter; }
- friend class Debugger::QmlEngine;
private:
+ friend class QmlEngine;
int m_ping;
QmlAdapter *m_adapter;
ProjectExplorer::ApplicationLauncher m_applicationLauncher;
: m_ping(0), m_adapter(new QmlAdapter(q))
{}
-} // namespace Internal
-
-using namespace Internal;
///////////////////////////////////////////////////////////////////////
//
}
QmlEngine::~QmlEngine()
-{
-}
+{}
void QmlEngine::gotoLocation(const QString &fileName, int lineNumber, bool setMarker)
{
return newFilename;
}
+} // namespace Internal
} // namespace Debugger
#include <QtNetwork/QAbstractSocket>
namespace Debugger {
-
namespace Internal {
+
class QmlEnginePrivate;
-} // namespace Internal
-class DEBUGGER_EXPORT QmlEngine : public DebuggerEngine
+class QmlEngine : public DebuggerEngine
{
Q_OBJECT
public:
explicit QmlEngine(const DebuggerStartParameters &startParameters);
- virtual ~QmlEngine();
+ ~QmlEngine();
void handleRemoteSetupDone(int port);
void handleRemoteSetupFailed(const QString &message);
void gotoLocation(const QString &fileName, int lineNumber, bool setMarker);
- void gotoLocation(const Internal::StackFrame &frame, bool setMarker);
+ void gotoLocation(const StackFrame &frame, bool setMarker);
void pauseConnection();
void remoteStartupRequested();
private:
- // DebuggerEngine implementation
+ // DebuggerEngine implementation.
bool isSynchronous() const { return false; }
void executeStep();
void executeStepOut();
void attemptBreakpointSynchronization();
bool acceptsBreakpoint(BreakpointId id) const;
- void assignValueInDebugger(const Internal::WatchData *data,
+ void assignValueInDebugger(const WatchData *data,
const QString &expr, const QVariant &value);
void loadSymbols(const QString &moduleName);
void loadAllSymbols();
void reloadFullStack() {}
bool supportsThreads() const { return false; }
- void updateWatchData(const Internal::WatchData &data,
- const Internal::WatchUpdateFlags &flags);
+ void updateWatchData(const WatchData &data,
+ const WatchUpdateFlags &flags);
void executeDebuggerCommand(const QString &command);
unsigned int debuggerCapabilities() const;
private:
friend class QmlCppEngine;
- QScopedPointer<Internal::QmlEnginePrivate> d;
+ QScopedPointer<QmlEnginePrivate> d;
};
+} // namespace Internal
} // namespace Debugger
#endif // DEBUGGER_QMLENGINE_H