Symbian: tcftrk renamed to Coda

2011-02-07 14:26:34 +01:00
parent 3212e1152c
commit 532a8ad2e7
17 changed files with 535 additions and 535 deletions
--- a/src/plugins/debugger/gdb/tcftrkgdbadapter.cpp
+++ b/src/plugins/debugger/gdb/tcftrkgdbadapter.cpp
@@ -31,10 +31,10 @@
 **
 **************************************************************************/

-#include "tcftrkgdbadapter.h"
+#include "codagdbadapter.h"

 #include "debuggerstartparameters.h"
-#include "tcftrkdevice.h"
+#include "codadevice.h"
 #include "trkutils.h"
 #include "gdbmi.h"
 #include "virtualserialdevice.h"
@@ -66,7 +66,7 @@
 #endif

 #define CB(callback) \
-    static_cast<GdbEngine::AdapterCallback>(&TcfTrkGdbAdapter::callback), \
+    static_cast<GdbEngine::AdapterCallback>(&CodaGdbAdapter::callback), \
    STRINGIFY(callback)

 enum { debug = 0 };
@@ -88,17 +88,17 @@ namespace Debugger {
 namespace Internal {

 using namespace Symbian;
-using namespace tcftrk;
+using namespace Coda;

 static inline QString startMsg(const trk::Session &session)
 {
-    return TcfTrkGdbAdapter::tr("Process started, PID: 0x%1, thread id: 0x%2, "
+    return CodaGdbAdapter::tr("Process started, PID: 0x%1, thread id: 0x%2, "
       "code segment: 0x%3, data segment: 0x%4.")
         .arg(session.pid, 0, 16).arg(session.tid, 0, 16)
         .arg(session.codeseg, 0, 16).arg(session.dataseg, 0, 16);
 }

-/* -------------- TcfTrkGdbAdapter:
+/* -------------- CodaGdbAdapter:
 * Startup-sequence:
 *  - startAdapter connects both sockets/devices
 *  - In the TCF Locator Event, gdb is started and the engine is notified
@@ -119,11 +119,11 @@ static inline QString startMsg(const trk::Session &session)
 *       - Stop all threads once one stops?
 *       - Breakpoints do not trigger in threads other than the main thread. */

-TcfTrkGdbAdapter::TcfTrkGdbAdapter(GdbEngine *engine) :
+CodaGdbAdapter::CodaGdbAdapter(GdbEngine *engine) :
    AbstractGdbAdapter(engine),
    m_running(false),
    m_stopReason(0),
-    m_trkDevice(new TcfTrkDevice(this)),
+    m_trkDevice(new CodaDevice(this)),
    m_gdbAckMode(true),
    m_uid(0),
    m_verbose(0),
@@ -149,38 +149,38 @@ TcfTrkGdbAdapter::TcfTrkGdbAdapter(GdbEngine *engine) :
    connect(debuggerCore()->action(VerboseLog), SIGNAL(valueChanged(QVariant)),
        this, SLOT(setVerbose(QVariant)));
    connect(m_trkDevice, SIGNAL(error(QString)),
-        this, SLOT(tcftrkDeviceError(QString)));
+        this, SLOT(codaDeviceError(QString)));
    connect(m_trkDevice, SIGNAL(logMessage(QString)),
        this, SLOT(trkLogMessage(QString)));
-    connect(m_trkDevice, SIGNAL(tcfEvent(tcftrk::TcfTrkEvent)),
-        this, SLOT(tcftrkEvent(tcftrk::TcfTrkEvent)));
+    connect(m_trkDevice, SIGNAL(tcfEvent(Coda::CodaEvent)),
+        this, SLOT(codaEvent(Coda::CodaEvent)));
 }

-TcfTrkGdbAdapter::~TcfTrkGdbAdapter()
+CodaGdbAdapter::~CodaGdbAdapter()
 {
    cleanup();
    logMessage("Shutting down.\n");
 }

-void TcfTrkGdbAdapter::setVerbose(const QVariant &value)
+void CodaGdbAdapter::setVerbose(const QVariant &value)
 {
    setVerbose(value.toInt());
 }

-void TcfTrkGdbAdapter::setVerbose(int verbose)
+void CodaGdbAdapter::setVerbose(int verbose)
 {
    if (debug)
-        qDebug("TcfTrkGdbAdapter::setVerbose %d", verbose);
+        qDebug("CodaGdbAdapter::setVerbose %d", verbose);
    m_verbose = verbose;
    m_trkDevice->setVerbose(m_verbose);
 }

-void TcfTrkGdbAdapter::trkLogMessage(const QString &msg)
+void CodaGdbAdapter::trkLogMessage(const QString &msg)
 {
    logMessage(_("TRK ") + msg);
 }

-void TcfTrkGdbAdapter::setGdbServerName(const QString &name)
+void CodaGdbAdapter::setGdbServerName(const QString &name)
 {
    m_gdbServerName = name;
 }
@@ -201,7 +201,7 @@ static QPair<QString, unsigned short> splitIpAddressSpec(const QString &addressS
    return QPair<QString, unsigned short>(address, port);
 }

-void TcfTrkGdbAdapter::handleTcfTrkRunControlModuleLoadContextSuspendedEvent(const TcfTrkRunControlModuleLoadContextSuspendedEvent &se)
+void CodaGdbAdapter::handleCodaRunControlModuleLoadContextSuspendedEvent(const CodaRunControlModuleLoadContextSuspendedEvent &se)
 {
    m_snapshot.resetMemory();
    const ModuleLoadEventInfo &minfo = se.info();
@@ -278,12 +278,12 @@ void TcfTrkGdbAdapter::handleTcfTrkRunControlModuleLoadContextSuspendedEvent(con
                qDebug() << "Initial module load suspended: " << m_session.toString();
        } else {
            // Consecutive module load suspended: (not observed yet): Just continue
-            m_trkDevice->sendRunControlResumeCommand(TcfTrkCallback(), se.id());
+            m_trkDevice->sendRunControlResumeCommand(CodaCallback(), se.id());
        }
    }
 }

-void TcfTrkGdbAdapter::handleTargetRemote(const GdbResponse &record)
+void CodaGdbAdapter::handleTargetRemote(const GdbResponse &record)
 {
    QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state());
    if (record.resultClass == GdbResultDone) {
@@ -297,29 +297,29 @@ void TcfTrkGdbAdapter::handleTargetRemote(const GdbResponse &record)
    }
 }

-void TcfTrkGdbAdapter::tcftrkEvent(const TcfTrkEvent &e)
+void CodaGdbAdapter::codaEvent(const CodaEvent &e)
 {
    if (debug)
        qDebug() << e.toString() << m_session.toString() << m_snapshot.toString();
    logMessage(e.toString());

    switch (e.type()) {
-    case TcfTrkEvent::LocatorHello:
-        m_trkDevice->sendLoggingAddListenerCommand(TcfTrkCallback());
+    case CodaEvent::LocatorHello:
+        m_trkDevice->sendLoggingAddListenerCommand(CodaCallback());
        startGdb(); // Commands are only accepted after hello
        break;
-    case TcfTrkEvent::RunControlModuleLoadSuspended: // A module was loaded
-        handleTcfTrkRunControlModuleLoadContextSuspendedEvent(
-            static_cast<const TcfTrkRunControlModuleLoadContextSuspendedEvent &>(e));
+    case CodaEvent::RunControlModuleLoadSuspended: // A module was loaded
+        handleCodaRunControlModuleLoadContextSuspendedEvent(
+            static_cast<const CodaRunControlModuleLoadContextSuspendedEvent &>(e));
        break;
-    case TcfTrkEvent::RunControlContextAdded: // Thread/process added
-        foreach(const RunControlContext &rc, static_cast<const TcfTrkRunControlContextAddedEvent &>(e).contexts())
+    case CodaEvent::RunControlContextAdded: // Thread/process added
+        foreach(const RunControlContext &rc, static_cast<const CodaRunControlContextAddedEvent &>(e).contexts())
            if (rc.type() == RunControlContext::Thread)
                addThread(rc.threadId());
        break;
-    case TcfTrkEvent::RunControlContextRemoved: // Thread/process removed
+    case CodaEvent::RunControlContextRemoved: // Thread/process removed
        foreach (const QByteArray &id,
-            static_cast<const TcfTrkRunControlContextRemovedEvent &>(e).ids())
+            static_cast<const CodaRunControlContextRemovedEvent &>(e).ids())
            switch (RunControlContext::typeFromTcfId(id)) {
            case RunControlContext::Thread:
                m_snapshot.removeThread(RunControlContext::threadIdFromTcdfId(id));
@@ -329,10 +329,10 @@ void TcfTrkGdbAdapter::tcftrkEvent(const TcfTrkEvent &e)
                break;
        }
        break;
-    case TcfTrkEvent::RunControlSuspended: {
+    case CodaEvent::RunControlSuspended: {
            // Thread suspended/stopped
-            const TcfTrkRunControlContextSuspendedEvent &se =
-                static_cast<const TcfTrkRunControlContextSuspendedEvent &>(e);
+            const CodaRunControlContextSuspendedEvent &se =
+                static_cast<const CodaRunControlContextSuspendedEvent &>(e);
            const unsigned threadId = RunControlContext::threadIdFromTcdfId(se.id());
            const QString reason = QString::fromUtf8(se.reasonID());
            const QString message = QString::fromUtf8(se.message()).replace(QLatin1String("\n"), QLatin1String(", "));
@@ -350,12 +350,12 @@ void TcfTrkGdbAdapter::tcftrkEvent(const TcfTrkEvent &e)
                           || reason.contains(QLatin1String("panic"), Qt::CaseInsensitive) ?
                           gdbServerSignalSegfault : gdbServerSignalTrap;
            m_trkDevice->sendRegistersGetMRangeCommand(
-                TcfTrkCallback(this, &TcfTrkGdbAdapter::handleAndReportReadRegistersAfterStop),
+                CodaCallback(this, &CodaGdbAdapter::handleAndReportReadRegistersAfterStop),
                currentThreadContextId(), 0,
                Symbian::RegisterCount);
    }
        break;
-    case tcftrk::TcfTrkEvent::LoggingWriteEvent: // TODO: Not tested yet.
+    case Coda::CodaEvent::LoggingWriteEvent: // TODO: Not tested yet.
        showMessage(e.toString(), AppOutput);
        break;
    default:
@@ -363,7 +363,7 @@ void TcfTrkGdbAdapter::tcftrkEvent(const TcfTrkEvent &e)
    }
 }

-void TcfTrkGdbAdapter::startGdb()
+void CodaGdbAdapter::startGdb()
 {
    QStringList gdbArgs;
    gdbArgs.append(QLatin1String("--nx")); // Do not read .gdbinit file
@@ -374,7 +374,7 @@ void TcfTrkGdbAdapter::startGdb()
    m_engine->handleAdapterStarted();
 }

-void TcfTrkGdbAdapter::tcftrkDeviceError(const QString  &errorString)
+void CodaGdbAdapter::codaDeviceError(const QString  &errorString)
 {
    logMessage(errorString);
    if (state() == EngineSetupRequested) {
@@ -384,7 +384,7 @@ void TcfTrkGdbAdapter::tcftrkDeviceError(const QString  &errorString)
    }
 }

-void TcfTrkGdbAdapter::logMessage(const QString &msg, int channel)
+void CodaGdbAdapter::logMessage(const QString &msg, int channel)
 {
    if (m_verbose || channel != LogDebug)
        showMessage(msg, channel);
@@ -395,7 +395,7 @@ void TcfTrkGdbAdapter::logMessage(const QString &msg, int channel)
 //
 // Gdb
 //
-void TcfTrkGdbAdapter::handleGdbConnection()
+void CodaGdbAdapter::handleGdbConnection()
 {
    logMessage("HANDLING GDB CONNECTION");
    QTC_ASSERT(m_gdbConnection == 0, /**/);
@@ -412,7 +412,7 @@ static inline QString msgGdbPacket(const QString &p)
    return QLatin1String("gdb:                              ") + p;
 }

-void TcfTrkGdbAdapter::readGdbServerCommand()
+void CodaGdbAdapter::readGdbServerCommand()
 {
    QTC_ASSERT(m_gdbConnection, return);
    QByteArray packet = m_gdbConnection->readAll();
@@ -482,7 +482,7 @@ void TcfTrkGdbAdapter::readGdbServerCommand()
    }
 }

-bool TcfTrkGdbAdapter::sendGdbServerPacket(const QByteArray &packet, bool doFlush)
+bool CodaGdbAdapter::sendGdbServerPacket(const QByteArray &packet, bool doFlush)
 {
    if (!m_gdbConnection) {
        logMessage(_("Cannot write to gdb: No connection (%1)")
@@ -504,7 +504,7 @@ bool TcfTrkGdbAdapter::sendGdbServerPacket(const QByteArray &packet, bool doFlus
    return true;
 }

-void TcfTrkGdbAdapter::sendGdbServerAck()
+void CodaGdbAdapter::sendGdbServerAck()
 {
    if (!m_gdbAckMode)
        return;
@@ -512,7 +512,7 @@ void TcfTrkGdbAdapter::sendGdbServerAck()
    sendGdbServerPacket(QByteArray(1, '+'), false);
 }

-void TcfTrkGdbAdapter::sendGdbServerMessage(const QByteArray &msg, const QByteArray &logNote)
+void CodaGdbAdapter::sendGdbServerMessage(const QByteArray &msg, const QByteArray &logNote)
 {
    trk::byte sum = 0;
    for (int i = 0; i != msg.size(); ++i)
@@ -545,7 +545,7 @@ static QByteArray msgStepRangeReceived(unsigned from, unsigned to, bool over)
    return rc;
 }

-void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
+void CodaGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
 {
    if (debug)
        qDebug("handleGdbServerCommand: %s", cmd.constData());
@@ -689,7 +689,7 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
                   arg(addrLength.second).arg(addrLength.first, 0, 16).
                   arg(QString::fromAscii(data.toHex())));
        m_trkDevice->sendMemorySetCommand(
-            TcfTrkCallback(this, &TcfTrkGdbAdapter::handleWriteMemory),
+            CodaCallback(this, &CodaGdbAdapter::handleWriteMemory),
            m_tcfProcessId, addrLength.first, data);
    }

@@ -708,7 +708,7 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
        } else {
            //qDebug() << "Fetching single register";
            m_trkDevice->sendRegistersGetMRangeCommand(
-                TcfTrkCallback(this, &TcfTrkGdbAdapter::handleAndReportReadRegister),
+                CodaCallback(this, &CodaGdbAdapter::handleAndReportReadRegister),
                currentThreadContextId(), registerNumber, 1);
        }
    }
@@ -724,7 +724,7 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
        QByteArray registerValue;
        trk::appendInt(&registerValue, trk::BigEndian); // Registers are big endian
        m_trkDevice->sendRegistersSetCommand(
-            TcfTrkCallback(this, &TcfTrkGdbAdapter::handleWriteRegister),
+            CodaCallback(this, &CodaGdbAdapter::handleWriteRegister),
            currentThreadContextId(), regnumValue.first, registerValue,
            QVariant(regnumValue.first));
        // Note that App TRK refuses to write registers 13 and 14
@@ -894,13 +894,13 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
            logMessage(_("Inserting breakpoint at 0x%1, %2")
                .arg(addrLen.first, 0, 16).arg(addrLen.second));
            // const QByteArray ba = trkBreakpointMessage(addr, len, len == 4);
-            tcftrk::Breakpoint bp(addrLen.first);
+            Coda::Breakpoint bp(addrLen.first);
            bp.size = addrLen.second;
            bp.setContextId(m_session.pid);
            // We use the automatic ids calculated from the location
            // address instead of the map in snapshot.
            m_trkDevice->sendBreakpointsAddCommand(
-                TcfTrkCallback(this, &TcfTrkGdbAdapter::handleAndReportSetBreakpoint),
+                CodaCallback(this, &CodaGdbAdapter::handleAndReportSetBreakpoint),
                bp);
        } else {
            logMessage("MISPARSED BREAKPOINT '" + cmd + "'')" , LogError);
@@ -915,8 +915,8 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
        const int pos = cmd.lastIndexOf(',');
        const uint addr = cmd.mid(3, pos - 3).toUInt(0, 16);
        m_trkDevice->sendBreakpointsRemoveCommand(
-            TcfTrkCallback(this, &TcfTrkGdbAdapter::handleClearBreakpoint),
-            tcftrk::Breakpoint::idFromLocation(addr));
+            CodaCallback(this, &CodaGdbAdapter::handleClearBreakpoint),
+            Coda::Breakpoint::idFromLocation(addr));
    }

    else if (cmd.startsWith("qPart:") || cmd.startsWith("qXfer:"))  {
@@ -955,16 +955,16 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
    }
 }

-void TcfTrkGdbAdapter::sendRunControlTerminateCommand()
+void CodaGdbAdapter::sendRunControlTerminateCommand()
 {
    // Requires id of main thread to terminate.
    // Note that calling 'Settings|set|removeExecutable' crashes TCF TRK,
    // so, it is apparently not required.
-    m_trkDevice->sendRunControlTerminateCommand(TcfTrkCallback(this, &TcfTrkGdbAdapter::handleRunControlTerminate),
+    m_trkDevice->sendRunControlTerminateCommand(CodaCallback(this, &CodaGdbAdapter::handleRunControlTerminate),
                                                mainThreadContextId());
 }

-void TcfTrkGdbAdapter::handleRunControlTerminate(const tcftrk::TcfTrkCommandResult &)
+void CodaGdbAdapter::handleRunControlTerminate(const Coda::CodaCommandResult &)
 {
    QString msg = QString::fromLatin1("CODA disconnected");
    const bool emergencyShutdown = m_gdbProc.state() != QProcess::Running;
@@ -977,7 +977,7 @@ void TcfTrkGdbAdapter::handleRunControlTerminate(const tcftrk::TcfTrkCommandResu
    }
 }

-void TcfTrkGdbAdapter::gdbSetCurrentThread(const QByteArray &cmd, const char *why)
+void CodaGdbAdapter::gdbSetCurrentThread(const QByteArray &cmd, const char *why)
 {
    // Thread ID from Hg/Hc commands: '-1': All, '0': arbitrary, else hex thread id.
    const QByteArray id = cmd.mid(2);
@@ -991,12 +991,12 @@ void TcfTrkGdbAdapter::gdbSetCurrentThread(const QByteArray &cmd, const char *wh
    sendGdbServerMessage("OK", message);
 }

-void TcfTrkGdbAdapter::interruptInferior()
+void CodaGdbAdapter::interruptInferior()
 {
-    m_trkDevice->sendRunControlSuspendCommand(TcfTrkCallback(), m_tcfProcessId);
+    m_trkDevice->sendRunControlSuspendCommand(CodaCallback(), m_tcfProcessId);
 }

-void TcfTrkGdbAdapter::startAdapter()
+void CodaGdbAdapter::startAdapter()
 {
    m_snapshot.fullReset();
    m_session.reset();
@@ -1011,13 +1011,13 @@ void TcfTrkGdbAdapter::startAdapter()
    if (!m_symbolFile.isEmpty())
        m_symbolFileFolder = QFileInfo(m_symbolFile).absolutePath();

-    QPair<QString, unsigned short> tcfTrkAddress;
+    QPair<QString, unsigned short> codaAddress;

-    QSharedPointer<QTcpSocket> tcfTrkSocket;
+    QSharedPointer<QTcpSocket> codaSocket;
    if (parameters.communicationChannel == DebuggerStartParameters::CommunicationChannelTcpIp) {
-        tcfTrkSocket = QSharedPointer<QTcpSocket>(new QTcpSocket);
-        m_trkDevice->setDevice(tcfTrkSocket);
-        m_trkIODevice = tcfTrkSocket;
+        codaSocket = QSharedPointer<QTcpSocket>(new QTcpSocket);
+        m_trkDevice->setDevice(codaSocket);
+        m_trkIODevice = codaSocket;
    } else {
        QSharedPointer<SymbianUtils::VirtualSerialDevice> serialDevice(new SymbianUtils::VirtualSerialDevice(parameters.remoteChannel));
        m_trkDevice->setSerialFrame(true);
@@ -1037,7 +1037,7 @@ void TcfTrkGdbAdapter::startAdapter()
        qDebug() << parameters.processArgs;

    m_uid = parameters.executableUid;
-    tcfTrkAddress = QPair<QString, unsigned short>(parameters.serverAddress, parameters.serverPort);
+    codaAddress = QPair<QString, unsigned short>(parameters.serverAddress, parameters.serverPort);
 //    m_remoteArguments.clear(); FIXME: Should this be here?

    // Unixish gdbs accept only forward slashes
@@ -1045,7 +1045,7 @@ void TcfTrkGdbAdapter::startAdapter()
    // Start
    QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state());
    showMessage(_("TRYING TO START ADAPTER"));
-    logMessage(QLatin1String("### Starting TcfTrkGdbAdapter"));
+    logMessage(QLatin1String("### Starting CodaGdbAdapter"));

    QTC_ASSERT(m_gdbServer == 0, delete m_gdbServer);
    QTC_ASSERT(m_gdbConnection == 0, m_gdbConnection = 0);
@@ -1068,14 +1068,14 @@ void TcfTrkGdbAdapter::startAdapter()

    if (parameters.communicationChannel == DebuggerStartParameters::CommunicationChannelTcpIp) {
        logMessage(_("Connecting to TCF TRK on %1:%2")
-                   .arg(tcfTrkAddress.first).arg(tcfTrkAddress.second));
-        tcfTrkSocket->connectToHost(tcfTrkAddress.first, tcfTrkAddress.second);
+                   .arg(codaAddress.first).arg(codaAddress.second));
+        codaSocket->connectToHost(codaAddress.first, codaAddress.second);
    } else {
        m_trkDevice->sendSerialPing(false);
    }
 }

-void TcfTrkGdbAdapter::setupInferior()
+void CodaGdbAdapter::setupInferior()
 {
    QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state());

@@ -1086,12 +1086,12 @@ void TcfTrkGdbAdapter::setupInferior()
        libraries.push_back(QString::fromAscii(librariesC[i]));

    m_trkDevice->sendProcessStartCommand(
-        TcfTrkCallback(this, &TcfTrkGdbAdapter::handleCreateProcess),
+        CodaCallback(this, &CodaGdbAdapter::handleCreateProcess),
        m_remoteExecutable, m_uid, m_remoteArguments,
        QString(), true, libraries);
 }

-void TcfTrkGdbAdapter::addThread(unsigned id)
+void CodaGdbAdapter::addThread(unsigned id)
 {
    showMessage(QString::fromLatin1("Thread %1 reported").arg(id), LogMisc);
    // Make thread known, register as main if it is the first one.
@@ -1104,13 +1104,13 @@ void TcfTrkGdbAdapter::addThread(unsigned id)
        }
        // We cannot retrieve register values unless the registers of that
        // thread have been retrieved (TCF TRK oddity).
-        const QByteArray contextId = tcftrk::RunControlContext::tcfId(m_session.pid, id);
-        m_trkDevice->sendRegistersGetChildrenCommand(TcfTrkCallback(this, &TcfTrkGdbAdapter::handleRegisterChildren),
+        const QByteArray contextId = Coda::RunControlContext::tcfId(m_session.pid, id);
+        m_trkDevice->sendRegistersGetChildrenCommand(CodaCallback(this, &CodaGdbAdapter::handleRegisterChildren),
                                                     contextId, QVariant(contextId));
    }
 }

-void TcfTrkGdbAdapter::handleCreateProcess(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleCreateProcess(const CodaCommandResult &result)
 {
    if (debug)
        qDebug() << "ProcessCreated: " << result.toString();
@@ -1135,7 +1135,7 @@ void TcfTrkGdbAdapter::handleCreateProcess(const TcfTrkCommandResult &result)
    m_session.dataseg = 0;
 }

-void TcfTrkGdbAdapter::runEngine()
+void CodaGdbAdapter::runEngine()
 {
    QTC_ASSERT(state() == EngineRunRequested, qDebug() << state());
    m_engine->notifyEngineRunAndInferiorStopOk();
@@ -1147,7 +1147,7 @@ void TcfTrkGdbAdapter::runEngine()
 // AbstractGdbAdapter interface implementation
 //

-void TcfTrkGdbAdapter::write(const QByteArray &data)
+void CodaGdbAdapter::write(const QByteArray &data)
 {
    // Write magic packets directly to TRK.
    if (data.startsWith("@#")) {
@@ -1179,7 +1179,7 @@ void TcfTrkGdbAdapter::write(const QByteArray &data)
    m_gdbProc.write(data);
 }

-void TcfTrkGdbAdapter::cleanup()
+void CodaGdbAdapter::cleanup()
 {
    delete m_gdbServer;
    m_gdbServer = 0;
@@ -1199,12 +1199,12 @@ void TcfTrkGdbAdapter::cleanup()
    } //!m_trkIODevice.isNull()
 }

-void TcfTrkGdbAdapter::shutdownInferior()
+void CodaGdbAdapter::shutdownInferior()
 {
    m_engine->defaultInferiorShutdown("kill");
 }

-void TcfTrkGdbAdapter::shutdownAdapter()
+void CodaGdbAdapter::shutdownAdapter()
 {
    if (m_gdbProc.state() == QProcess::Running) {
        cleanup();
@@ -1218,18 +1218,18 @@ void TcfTrkGdbAdapter::shutdownAdapter()
    }
 }

-void TcfTrkGdbAdapter::trkReloadRegisters()
+void CodaGdbAdapter::trkReloadRegisters()
 {
    // Take advantage of direct access to cached register values.
    m_snapshot.syncRegisters(m_session.tid, m_engine->registerHandler());
 }

-void TcfTrkGdbAdapter::trkReloadThreads()
+void CodaGdbAdapter::trkReloadThreads()
 {
    m_snapshot.syncThreads(m_engine->threadsHandler());
 }

-void TcfTrkGdbAdapter::handleWriteRegister(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleWriteRegister(const CodaCommandResult &result)
 {
    const int registerNumber = result.cookie.toInt();
    if (result) {
@@ -1241,18 +1241,18 @@ void TcfTrkGdbAdapter::handleWriteRegister(const TcfTrkCommandResult &result)
    }
 }

-void TcfTrkGdbAdapter::sendRegistersGetMCommand()
+void CodaGdbAdapter::sendRegistersGetMCommand()
 {
    // Send off a register command, which requires the names to be present.
    QTC_ASSERT(!m_trkDevice->registerNames().isEmpty(), return )

    m_trkDevice->sendRegistersGetMRangeCommand(
-                TcfTrkCallback(this, &TcfTrkGdbAdapter::handleAndReportReadRegisters),
+                CodaCallback(this, &CodaGdbAdapter::handleAndReportReadRegisters),
                currentThreadContextId(), 0,
                Symbian::RegisterCount);
 }

-void TcfTrkGdbAdapter::reportRegisters()
+void CodaGdbAdapter::reportRegisters()
 {
    const int threadIndex = m_snapshot.indexOfThread(m_session.tid);
    QTC_ASSERT(threadIndex != -1, return);
@@ -1260,7 +1260,7 @@ void TcfTrkGdbAdapter::reportRegisters()
    sendGdbServerMessage(thread.gdbReportRegisters(), thread.gdbRegisterLogMessage(m_verbose));
 }

-void TcfTrkGdbAdapter::handleRegisterChildren(const tcftrk::TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleRegisterChildren(const Coda::CodaCommandResult &result)
 {
    const QByteArray contextId = result.cookie.toByteArray();
    if (!result) {
@@ -1271,9 +1271,9 @@ void TcfTrkGdbAdapter::handleRegisterChildren(const tcftrk::TcfTrkCommandResult
    // If this is a single 'pid.tid.rGPR' parent entry, recurse to get the actual registers,
    // ('pid.tid.rGPR.R0'..). At least 'pid.tid.rGPR' must have been retrieved to be
    // able to access the register contents.
-    QVector<QByteArray> registerNames = tcftrk::TcfTrkDevice::parseRegisterGetChildren(result);
+    QVector<QByteArray> registerNames = Coda::CodaDevice::parseRegisterGetChildren(result);
    if (registerNames.size() == 1) {
-        m_trkDevice->sendRegistersGetChildrenCommand(TcfTrkCallback(this, &TcfTrkGdbAdapter::handleRegisterChildren),
+        m_trkDevice->sendRegistersGetChildrenCommand(CodaCallback(this, &CodaGdbAdapter::handleRegisterChildren),
                                                     registerNames.front(), result.cookie);
        return;
    }
@@ -1304,7 +1304,7 @@ void TcfTrkGdbAdapter::handleRegisterChildren(const tcftrk::TcfTrkCommandResult
    }
 }

-void TcfTrkGdbAdapter::handleReadRegisters(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleReadRegisters(const CodaCommandResult &result)
 {
    // check for errors
    if (!result) {
@@ -1336,13 +1336,13 @@ void TcfTrkGdbAdapter::handleReadRegisters(const TcfTrkCommandResult &result)
        qDebug() << "handleReadRegisters: " << m_snapshot.toString();
 }

-void TcfTrkGdbAdapter::handleAndReportReadRegisters(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleAndReportReadRegisters(const CodaCommandResult &result)
 {
    handleReadRegisters(result);
    reportRegisters();
 }

-void TcfTrkGdbAdapter::handleAndReportReadRegister(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleAndReportReadRegister(const CodaCommandResult &result)
 {
    handleReadRegisters(result);
    const uint registerNumber = result.cookie.toUInt();
@@ -1353,7 +1353,7 @@ void TcfTrkGdbAdapter::handleAndReportReadRegister(const TcfTrkCommandResult &re
        thread.gdbSingleRegisterLogMessage(registerNumber));
 }

-QByteArray TcfTrkGdbAdapter::stopMessage() const
+QByteArray CodaGdbAdapter::stopMessage() const
 {
    QByteArray logMsg = "Stopped with registers in thread 0x";
    logMsg += QByteArray::number(m_session.tid, 16);
@@ -1374,7 +1374,7 @@ QByteArray TcfTrkGdbAdapter::stopMessage() const
    return logMsg;
 }

-void TcfTrkGdbAdapter::handleAndReportReadRegistersAfterStop(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleAndReportReadRegistersAfterStop(const CodaCommandResult &result)
 {
    handleReadRegisters(result);
    handleReadRegisters(result);
@@ -1382,7 +1382,7 @@ void TcfTrkGdbAdapter::handleAndReportReadRegistersAfterStop(const TcfTrkCommand
    sendGdbServerMessage(m_snapshot.gdbStopMessage(m_session.tid, m_stopReason, reportThread), stopMessage());
 }

-void TcfTrkGdbAdapter::handleAndReportSetBreakpoint(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleAndReportSetBreakpoint(const CodaCommandResult &result)
 {
    if (result) {
        sendGdbServerMessage("OK");
@@ -1392,7 +1392,7 @@ void TcfTrkGdbAdapter::handleAndReportSetBreakpoint(const TcfTrkCommandResult &r
    }
 }

-void TcfTrkGdbAdapter::handleClearBreakpoint(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleClearBreakpoint(const CodaCommandResult &result)
 {
    logMessage("CLEAR BREAKPOINT ");
    if (!result)
@@ -1400,7 +1400,7 @@ void TcfTrkGdbAdapter::handleClearBreakpoint(const TcfTrkCommandResult &result)
    sendGdbServerMessage("OK");
 }

-void TcfTrkGdbAdapter::readMemory(uint addr, uint len, bool buffered)
+void CodaGdbAdapter::readMemory(uint addr, uint len, bool buffered)
 {
    Q_ASSERT(len < (2 << 16));

@@ -1419,20 +1419,20 @@ static QString msgMemoryReadError(uint addr, uint len = 0)
    return _("Memory read error at: 0x%1 %2").arg(addr, 0, 16).arg(lenS);
 }

-void TcfTrkGdbAdapter::sendMemoryGetCommand(const MemoryRange &range, bool buffered)
+void CodaGdbAdapter::sendMemoryGetCommand(const MemoryRange &range, bool buffered)
 {
    const QVariant cookie = QVariant::fromValue(range);
-    const TcfTrkCallback cb = buffered ?
-      TcfTrkCallback(this, &TcfTrkGdbAdapter::handleReadMemoryBuffered) :
-      TcfTrkCallback(this, &TcfTrkGdbAdapter::handleReadMemoryUnbuffered);
+    const CodaCallback cb = buffered ?
+      CodaCallback(this, &CodaGdbAdapter::handleReadMemoryBuffered) :
+      CodaCallback(this, &CodaGdbAdapter::handleReadMemoryUnbuffered);
    m_trkDevice->sendMemoryGetCommand(cb, currentThreadContextId(), range.from, range.size(), cookie);
 }

-void TcfTrkGdbAdapter::handleReadMemoryBuffered(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleReadMemoryBuffered(const CodaCommandResult &result)
 {
    QTC_ASSERT(qVariantCanConvert<MemoryRange>(result.cookie), return);

-    const QByteArray memory = TcfTrkDevice::parseMemoryGet(result);
+    const QByteArray memory = CodaDevice::parseMemoryGet(result);
    const MemoryRange range = result.cookie.value<MemoryRange>();

    const bool error = !result;
@@ -1453,11 +1453,11 @@ void TcfTrkGdbAdapter::handleReadMemoryBuffered(const TcfTrkCommandResult &resul
    tryAnswerGdbMemoryRequest(true);
 }

-void TcfTrkGdbAdapter::handleReadMemoryUnbuffered(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleReadMemoryUnbuffered(const CodaCommandResult &result)
 {
    QTC_ASSERT(qVariantCanConvert<MemoryRange>(result.cookie), return);

-    const QByteArray memory = TcfTrkDevice::parseMemoryGet(result);
+    const QByteArray memory = CodaDevice::parseMemoryGet(result);
    const MemoryRange range = result.cookie.value<MemoryRange>();

    const bool error = !result;
@@ -1475,7 +1475,7 @@ void TcfTrkGdbAdapter::handleReadMemoryUnbuffered(const TcfTrkCommandResult &res
    tryAnswerGdbMemoryRequest(false);
 }

-void TcfTrkGdbAdapter::tryAnswerGdbMemoryRequest(bool buffered)
+void CodaGdbAdapter::tryAnswerGdbMemoryRequest(bool buffered)
 {
    //logMessage("TRYING TO ANSWER MEMORY REQUEST ");
    MemoryRange wanted = m_snapshot.wantedMemory;
@@ -1537,7 +1537,7 @@ void TcfTrkGdbAdapter::tryAnswerGdbMemoryRequest(bool buffered)
    }
 }

-void TcfTrkGdbAdapter::handleWriteMemory(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleWriteMemory(const CodaCommandResult &result)
 {
    if (result) {
        sendGdbServerMessage("OK", "Write memory");
@@ -1547,26 +1547,26 @@ void TcfTrkGdbAdapter::handleWriteMemory(const TcfTrkCommandResult &result)
    }
 }

-QByteArray TcfTrkGdbAdapter::mainThreadContextId() const
+QByteArray CodaGdbAdapter::mainThreadContextId() const
 {
    return RunControlContext::tcfId(m_session.pid, m_session.mainTid);
 }

-QByteArray TcfTrkGdbAdapter::currentThreadContextId() const
+QByteArray CodaGdbAdapter::currentThreadContextId() const
 {
    return RunControlContext::tcfId(m_session.pid, m_session.tid);
 }

-void TcfTrkGdbAdapter::sendTrkContinue()
+void CodaGdbAdapter::sendTrkContinue()
 {
    // Remove all but main thread as we do not know whether they will exist
    // at the next stop.
    if (m_snapshot.threadInfo.size() > 1)
        m_snapshot.threadInfo.remove(1, m_snapshot.threadInfo.size() - 1);
-    m_trkDevice->sendRunControlResumeCommand(TcfTrkCallback(), m_tcfProcessId);
+    m_trkDevice->sendRunControlResumeCommand(CodaCallback(), m_tcfProcessId);
 }

-void TcfTrkGdbAdapter::sendTrkStepRange()
+void CodaGdbAdapter::sendTrkStepRange()
 {
    uint from = m_snapshot.lineFromAddress;
    uint to = m_snapshot.lineToAddress;
@@ -1587,12 +1587,12 @@ void TcfTrkGdbAdapter::sendTrkStepRange()
    logMessage(_("Stepping from 0x%1 to 0x%2 (current PC=0x%3), mode %4").
               arg(from, 0, 16).arg(to, 0, 16).arg(pc).arg(int(mode)));
    m_trkDevice->sendRunControlResumeCommand(
-        TcfTrkCallback(this, &TcfTrkGdbAdapter::handleStep),
+        CodaCallback(this, &CodaGdbAdapter::handleStep),
        currentThreadContextId(),
        mode, 1, from, to);
 }

-void TcfTrkGdbAdapter::handleStep(const TcfTrkCommandResult &result)
+void CodaGdbAdapter::handleStep(const CodaCommandResult &result)
 {

    if (!result) { // Try fallback with Continue.
--- a/src/plugins/debugger/gdb/tcftrkgdbadapter.h
+++ b/src/plugins/debugger/gdb/tcftrkgdbadapter.h
@@ -31,8 +31,8 @@
 **
 **************************************************************************/

-#ifndef DEBUGGER_TCFTRKGDBADAPTER_H
-#define DEBUGGER_TCFTRKGDBADAPTER_H
+#ifndef DEBUGGER_CODAGDBADAPTER_H
+#define DEBUGGER_CODAGDBADAPTER_H

 #include "abstractgdbadapter.h"
 #include "localgdbprocess.h"
@@ -51,11 +51,11 @@ class QTcpSocket;
 class QIODevice;
 QT_END_NAMESPACE

-namespace tcftrk {
-    struct TcfTrkCommandResult;
-    class TcfTrkDevice;
-    class TcfTrkEvent;
-    class TcfTrkRunControlModuleLoadContextSuspendedEvent;
+namespace Coda {
+    struct CodaCommandResult;
+    class CodaDevice;
+    class CodaEvent;
+    class CodaRunControlModuleLoadContextSuspendedEvent;
 }

 namespace Debugger {
@@ -66,21 +66,21 @@ struct GdbResult;

 ///////////////////////////////////////////////////////////////////////
 //
-// TcfTrkGdbAdapter
+// CodaGdbAdapter
 //
 ///////////////////////////////////////////////////////////////////////

-class TcfTrkGdbAdapter : public AbstractGdbAdapter
+class CodaGdbAdapter : public AbstractGdbAdapter
 {
    Q_OBJECT

 public:
    typedef trk::Callback<const GdbResult &> GdbResultCallback;
-    typedef trk::Callback<const tcftrk::TcfTrkCommandResult &> TcfTrkCallback;
+    typedef trk::Callback<const Coda::CodaCommandResult &> CodaCallback;
    typedef trk::Callback<const GdbResponse &> GdbCallback;

-    explicit TcfTrkGdbAdapter(GdbEngine *engine);
-    virtual ~TcfTrkGdbAdapter();
+    explicit CodaGdbAdapter(GdbEngine *engine);
+    virtual ~CodaGdbAdapter();
    void setGdbServerName(const QString &name);
    QString gdbServerName() const { return m_gdbServerName; }

@@ -113,22 +113,22 @@ private:
    void shutdownInferior();
    void shutdownAdapter();
    void sendRunControlTerminateCommand();
-    void handleRunControlTerminate(const tcftrk::TcfTrkCommandResult &);
+    void handleRunControlTerminate(const Coda::CodaCommandResult &);
    void sendRegistersGetMCommand();
-    void handleWriteRegister(const tcftrk::TcfTrkCommandResult &result);
+    void handleWriteRegister(const Coda::CodaCommandResult &result);
    void reportRegisters();
-    void handleReadRegisters(const tcftrk::TcfTrkCommandResult &result);
-    void handleRegisterChildren(const tcftrk::TcfTrkCommandResult &result);
-    void handleAndReportReadRegisters(const tcftrk::TcfTrkCommandResult &result);
-    void handleAndReportReadRegister(const tcftrk::TcfTrkCommandResult &result);
-    void handleAndReportReadRegistersAfterStop(const tcftrk::TcfTrkCommandResult &result);
+    void handleReadRegisters(const Coda::CodaCommandResult &result);
+    void handleRegisterChildren(const Coda::CodaCommandResult &result);
+    void handleAndReportReadRegisters(const Coda::CodaCommandResult &result);
+    void handleAndReportReadRegister(const Coda::CodaCommandResult &result);
+    void handleAndReportReadRegistersAfterStop(const Coda::CodaCommandResult &result);
    QByteArray stopMessage() const;
-    void handleAndReportSetBreakpoint(const tcftrk::TcfTrkCommandResult &result);
-    void handleClearBreakpoint(const tcftrk::TcfTrkCommandResult &result);
+    void handleAndReportSetBreakpoint(const Coda::CodaCommandResult &result);
+    void handleClearBreakpoint(const Coda::CodaCommandResult &result);
    void readMemory(uint addr, uint len, bool buffered);
-    void handleReadMemoryBuffered(const tcftrk::TcfTrkCommandResult &result);
-    void handleReadMemoryUnbuffered(const tcftrk::TcfTrkCommandResult &result);
-    void handleWriteMemory(const tcftrk::TcfTrkCommandResult &result);
+    void handleReadMemoryBuffered(const Coda::CodaCommandResult &result);
+    void handleReadMemoryUnbuffered(const Coda::CodaCommandResult &result);
+    void handleWriteMemory(const Coda::CodaCommandResult &result);
    void tryAnswerGdbMemoryRequest(bool buffered);
    inline void sendMemoryGetCommand(const MemoryRange &range, bool buffered);
    void addThread(unsigned id);
@@ -144,7 +144,7 @@ private:
    QString m_gdbServerName; // 127.0.0.1:(2222+uid)
    bool m_running;
    int m_stopReason;
-    tcftrk::TcfTrkDevice *m_trkDevice;
+    Coda::CodaDevice *m_trkDevice;
    QSharedPointer<QIODevice> m_trkIODevice;

    //
@@ -152,14 +152,14 @@ private:
    //
    Q_SLOT void handleGdbConnection();
    Q_SLOT void readGdbServerCommand();
-    Q_SLOT void tcftrkDeviceError(const QString  &);
+    Q_SLOT void codaDeviceError(const QString  &);
    void startGdb();
-    Q_SLOT void tcftrkEvent(const tcftrk::TcfTrkEvent &knownEvent);
-    void handleTcfTrkRunControlModuleLoadContextSuspendedEvent(const tcftrk::TcfTrkRunControlModuleLoadContextSuspendedEvent &e);
+    Q_SLOT void codaEvent(const Coda::CodaEvent &knownEvent);
+    void handleCodaRunControlModuleLoadContextSuspendedEvent(const Coda::CodaRunControlModuleLoadContextSuspendedEvent &e);
    inline void sendTrkContinue();
    void sendTrkStepRange();
-    void handleStep(const tcftrk::TcfTrkCommandResult &result);
-    void handleCreateProcess(const tcftrk::TcfTrkCommandResult &result);
+    void handleStep(const Coda::CodaCommandResult &result);
+    void handleCreateProcess(const Coda::CodaCommandResult &result);

    void readGdbResponse();
    void handleGdbServerCommand(const QByteArray &cmd);
@@ -197,4 +197,4 @@ private:
 } // namespace Internal
 } // namespace Debugger

-#endif // DEBUGGER_TCFTRKGDBADAPTER_H
+#endif // DEBUGGER_CODAGDBADAPTER_H
--- a/src/plugins/debugger/gdb/gdb.pri
+++ b/src/plugins/debugger/gdb/gdb.pri
@@ -10,7 +10,7 @@ HEADERS += \
    $$PWD/termgdbadapter.h \
    $$PWD/remotegdbserveradapter.h \
    $$PWD/trkgdbadapter.h \
-    $$PWD/tcftrkgdbadapter.h \
+    $$PWD/codagdbadapter.h \
    $$PWD/s60debuggerbluetoothstarter.h \
    $$PWD/abstractgdbprocess.h \
    $$PWD/localgdbprocess.h \
@@ -33,7 +33,7 @@ SOURCES += \
    $$PWD/termgdbadapter.cpp \
    $$PWD/remotegdbserveradapter.cpp \
    $$PWD/trkgdbadapter.cpp \
-    $$PWD/tcftrkgdbadapter.cpp \
+    $$PWD/codagdbadapter.cpp \
    $$PWD/s60debuggerbluetoothstarter.cpp \
    $$PWD/abstractgdbprocess.cpp \
    $$PWD/localgdbprocess.cpp \
--- a/src/plugins/debugger/gdb/gdbengine.cpp
+++ b/src/plugins/debugger/gdb/gdbengine.cpp
@@ -44,7 +44,7 @@
 #include "remotegdbserveradapter.h"
 #include "remoteplaingdbadapter.h"
 #include "trkgdbadapter.h"
-#include "tcftrkgdbadapter.h"
+#include "codagdbadapter.h"

 #include "debuggeractions.h"
 #include "debuggerconstants.h"
@@ -1798,7 +1798,7 @@ AbstractGdbAdapter *GdbEngine::createAdapter()
    case ProjectExplorer::ToolChain_RVCT_ARMV5_GNUPOC:
    case ProjectExplorer::ToolChain_GCCE_GNUPOC:
        if (sp.debugClient == DebuggerStartParameters::DebugClientCoda)
-            return new TcfTrkGdbAdapter(this);
+            return new CodaGdbAdapter(this);
        else
            return new TrkGdbAdapter(this);
    default:
--- a/src/plugins/debugger/gdb/gdbengine.h
+++ b/src/plugins/debugger/gdb/gdbengine.h
@@ -100,7 +100,7 @@ private:
    friend class RemoteGdbServerAdapter;
    friend class RemotePlainGdbAdapter;
    friend class TrkGdbAdapter;
-    friend class TcfTrkGdbAdapter;
+    friend class CodaGdbAdapter;

 private: ////////// General Interface //////////

--- a/src/plugins/debugger/gdb/trkgdbadapter.cpp
+++ b/src/plugins/debugger/gdb/trkgdbadapter.cpp
@@ -1673,7 +1673,7 @@ void TrkGdbAdapter::handleCreateProcess(const TrkResult &result)
    logMessage(startMsg, LogMisc);
    // 26.8.2010: When paging occurs in S^3, bogus starting ROM addresses
    // like 0x500000 or 0x40000 are reported. Warn about symbol resolution errors.
-    // Code duplicated in TcfTrkAdapter. @TODO: Hopefully fixed in future TRK versions.
+    // Code duplicated in CodaAdapter. @TODO: Hopefully fixed in future TRK versions.
    if ((m_session.codeseg  & 0xFFFFF) == 0) {
        const QString warnMessage = tr("The reported code segment address (0x%1) might be invalid. Symbol resolution or setting breakoints may not work.").
                                    arg(m_session.codeseg, 0, 16);
--- a/src/plugins/qt4projectmanager/qt-s60/codaruncontrol.cpp
+++ b/src/plugins/qt4projectmanager/qt-s60/codaruncontrol.cpp
@@ -36,8 +36,8 @@
 #include "s60deployconfiguration.h"
 #include "s60devicerunconfiguration.h"

-#include "tcftrkdevice.h"
-#include "tcftrkmessage.h"
+#include "codadevice.h"
+#include "codamessage.h"

 #include "qt4buildconfiguration.h"
 #include "qt4symbiantarget.h"
@@ -63,13 +63,13 @@
 using namespace ProjectExplorer;
 using namespace Qt4ProjectManager;
 using namespace Qt4ProjectManager::Internal;
-using namespace tcftrk;
+using namespace Coda;

 enum { debug = 0 };

 CodaRunControl::CodaRunControl(RunConfiguration *runConfiguration, const QString &mode) :
    S60RunControlBase(runConfiguration, mode),
-    m_tcfTrkDevice(0),
+    m_codaDevice(0),
    m_port(0),
    m_state(StateUninit)
 {
@@ -91,8 +91,8 @@ CodaRunControl::CodaRunControl(RunConfiguration *runConfiguration, const QString

 CodaRunControl::~CodaRunControl()
 {
-    if (m_tcfTrkDevice)
-        m_tcfTrkDevice->deleteLater();
+    if (m_codaDevice)
+        m_codaDevice->deleteLater();
 }

 bool CodaRunControl::doStart()
@@ -115,22 +115,22 @@ bool CodaRunControl::isRunning() const

 bool CodaRunControl::setupLauncher()
 {
-    QTC_ASSERT(!m_tcfTrkDevice, return false);
+    QTC_ASSERT(!m_codaDevice, return false);

-    m_tcfTrkDevice = new TcfTrkDevice;
+    m_codaDevice = new CodaDevice;
    if (debug)
-        m_tcfTrkDevice->setVerbose(debug);
+        m_codaDevice->setVerbose(debug);

-    connect(m_tcfTrkDevice, SIGNAL(error(QString)), this, SLOT(slotError(QString)));
-    connect(m_tcfTrkDevice, SIGNAL(logMessage(QString)), this, SLOT(slotTrkLogMessage(QString)));
-    connect(m_tcfTrkDevice, SIGNAL(tcfEvent(tcftrk::TcfTrkEvent)), this, SLOT(slotTcftrkEvent(tcftrk::TcfTrkEvent)));
-    connect(m_tcfTrkDevice, SIGNAL(serialPong(QString)), this, SLOT(slotSerialPong(QString)));
+    connect(m_codaDevice, SIGNAL(error(QString)), this, SLOT(slotError(QString)));
+    connect(m_codaDevice, SIGNAL(logMessage(QString)), this, SLOT(slotTrkLogMessage(QString)));
+    connect(m_codaDevice, SIGNAL(tcfEvent(Coda::CodaEvent)), this, SLOT(slotCodaEvent(Coda::CodaEvent)));
+    connect(m_codaDevice, SIGNAL(serialPong(QString)), this, SLOT(slotSerialPong(QString)));

    if (m_serialPort.length()) {
        const QSharedPointer<SymbianUtils::VirtualSerialDevice> serialDevice(new SymbianUtils::VirtualSerialDevice(m_serialPort));
        appendMessage(tr("Conecting to '%2'...").arg(m_serialPort), NormalMessageFormat);
-        m_tcfTrkDevice->setSerialFrame(true);
-        m_tcfTrkDevice->setDevice(serialDevice);
+        m_codaDevice->setSerialFrame(true);
+        m_codaDevice->setDevice(serialDevice);
        bool ok = serialDevice->open(QIODevice::ReadWrite);
        if (!ok) {
            appendMessage(tr("Couldn't open serial device: %1").arg(serialDevice->errorString()), ErrorMessageFormat);
@@ -139,12 +139,12 @@ bool CodaRunControl::setupLauncher()
        connect(SymbianUtils::SymbianDeviceManager::instance(), SIGNAL(deviceRemoved(const SymbianUtils::SymbianDevice)),
                this, SLOT(deviceRemoved(SymbianUtils::SymbianDevice)));
        m_state = StateConnecting;
-        m_tcfTrkDevice->sendSerialPing(false);
+        m_codaDevice->sendSerialPing(false);
        QTimer::singleShot(4000, this, SLOT(checkForTimeout()));
    } else {
-        const QSharedPointer<QTcpSocket> tcfTrkSocket(new QTcpSocket);
-        m_tcfTrkDevice->setDevice(tcfTrkSocket);
-        tcfTrkSocket->connectToHost(m_address, m_port);
+        const QSharedPointer<QTcpSocket> codaSocket(new QTcpSocket);
+        m_codaDevice->setDevice(codaSocket);
+        codaSocket->connectToHost(m_address, m_port);
        m_state = StateConnecting;
        appendMessage(tr("Connecting to %1:%2...").arg(m_address).arg(m_port), NormalMessageFormat);
        QTimer::singleShot(4000, this, SLOT(checkForTimeout()));
@@ -162,7 +162,7 @@ void CodaRunControl::doStop()
        break;
    case StateProcessRunning:
        QTC_ASSERT(!m_runningProcessId.isEmpty(), return);
-        m_tcfTrkDevice->sendRunControlTerminateCommand(TcfTrkCallback(),
+        m_codaDevice->sendRunControlTerminateCommand(CodaCallback(),
                                                       m_runningProcessId.toAscii());
        break;
    }
@@ -187,34 +187,34 @@ void CodaRunControl::slotSerialPong(const QString &message)
        qDebug() << "CODA serial pong:" << message;
 }

-void CodaRunControl::slotTcftrkEvent(const TcfTrkEvent &event)
+void CodaRunControl::slotCodaEvent(const CodaEvent &event)
 {
    if (debug)
        qDebug() << "CODA event:" << "Type:" << event.type() << "Message:" << event.toString();

    switch (event.type()) {
-    case TcfTrkEvent::LocatorHello: { // Commands accepted now
+    case CodaEvent::LocatorHello: { // Commands accepted now
        m_state = StateConnected;
        appendMessage(tr("Connected."), NormalMessageFormat);
        setProgress(maxProgress()*0.80);
        initCommunication();
    }
    break;
-    case TcfTrkEvent::RunControlContextRemoved:
+    case CodaEvent::RunControlContextRemoved:
        handleContextRemoved(event);
        break;
-    case TcfTrkEvent::RunControlContextAdded:
+    case CodaEvent::RunControlContextAdded:
        m_state = StateProcessRunning;
        reportLaunchFinished();
        handleContextAdded(event);
        break;
-    case TcfTrkEvent::RunControlSuspended:
+    case CodaEvent::RunControlSuspended:
        handleContextSuspended(event);
        break;
-    case TcfTrkEvent::RunControlModuleLoadSuspended:
+    case CodaEvent::RunControlModuleLoadSuspended:
        handleModuleLoadSuspended(event);
        break;
-    case TcfTrkEvent::LoggingWriteEvent:
+    case CodaEvent::LoggingWriteEvent:
        handleLogging(event);
        break;
    default:
@@ -226,13 +226,13 @@ void CodaRunControl::slotTcftrkEvent(const TcfTrkEvent &event)

 void CodaRunControl::initCommunication()
 {
-    m_tcfTrkDevice->sendLoggingAddListenerCommand(TcfTrkCallback(this, &CodaRunControl::handleAddListener));
+    m_codaDevice->sendLoggingAddListenerCommand(CodaCallback(this, &CodaRunControl::handleAddListener));
 }

-void CodaRunControl::handleContextRemoved(const TcfTrkEvent &event)
+void CodaRunControl::handleContextRemoved(const CodaEvent &event)
 {
    const QVector<QByteArray> removedItems
-            = static_cast<const TcfTrkRunControlContextRemovedEvent &>(event).ids();
+            = static_cast<const CodaRunControlContextRemovedEvent &>(event).ids();
    if (!m_runningProcessId.isEmpty()
            && removedItems.contains(m_runningProcessId.toAscii())) {
        appendMessage(tr("Process has finished."), NormalMessageFormat);
@@ -240,9 +240,9 @@ void CodaRunControl::handleContextRemoved(const TcfTrkEvent &event)
    }
 }

-void CodaRunControl::handleContextAdded(const TcfTrkEvent &event)
+void CodaRunControl::handleContextAdded(const CodaEvent &event)
 {
-    typedef TcfTrkRunControlContextAddedEvent TcfAddedEvent;
+    typedef CodaRunControlContextAddedEvent TcfAddedEvent;

    const TcfAddedEvent &me = static_cast<const TcfAddedEvent &>(event);
    foreach (const RunControlContext &context, me.contexts()) {
@@ -251,9 +251,9 @@ void CodaRunControl::handleContextAdded(const TcfTrkEvent &event)
    }
 }

-void CodaRunControl::handleContextSuspended(const TcfTrkEvent &event)
+void CodaRunControl::handleContextSuspended(const CodaEvent &event)
 {
-    typedef TcfTrkRunControlContextSuspendedEvent TcfSuspendEvent;
+    typedef CodaRunControlContextSuspendedEvent TcfSuspendEvent;

    const TcfSuspendEvent &me = static_cast<const TcfSuspendEvent &>(event);

@@ -262,7 +262,7 @@ void CodaRunControl::handleContextSuspended(const TcfTrkEvent &event)
        appendMessage(tr("Thread has crashed: %1").arg(QString::fromLatin1(me.message())), ErrorMessageFormat);
        //If we get a crash report then we display it and stop the process.
        //Now sure if this should be the final solution but it works for now.
-        //m_tcfTrkDevice->sendRunControlResumeCommand(TcfTrkCallback(), me.id()); //TODO: Should I resume automaticly
+        //m_codaDevice->sendRunControlResumeCommand(CodaCallback(), me.id()); //TODO: Should I resume automaticly
        stop();
        break;
    default:
@@ -272,31 +272,31 @@ void CodaRunControl::handleContextSuspended(const TcfTrkEvent &event)
    }
 }

-void CodaRunControl::handleModuleLoadSuspended(const TcfTrkEvent &event)
+void CodaRunControl::handleModuleLoadSuspended(const CodaEvent &event)
 {
    // Debug mode start: Continue:
-    typedef TcfTrkRunControlModuleLoadContextSuspendedEvent TcfModuleLoadSuspendedEvent;
+    typedef CodaRunControlModuleLoadContextSuspendedEvent TcfModuleLoadSuspendedEvent;

    const TcfModuleLoadSuspendedEvent &me = static_cast<const TcfModuleLoadSuspendedEvent &>(event);
    if (me.info().requireResume)
-        m_tcfTrkDevice->sendRunControlResumeCommand(TcfTrkCallback(), me.id());
+        m_codaDevice->sendRunControlResumeCommand(CodaCallback(), me.id());
 }

-void CodaRunControl::handleLogging(const TcfTrkEvent &event)
+void CodaRunControl::handleLogging(const CodaEvent &event)
 {
-    const TcfTrkLoggingWriteEvent &me = static_cast<const TcfTrkLoggingWriteEvent &>(event);
+    const CodaLoggingWriteEvent &me = static_cast<const CodaLoggingWriteEvent &>(event);
    appendMessage(me.message(), StdOutFormat);
 }

-void CodaRunControl::handleAddListener(const TcfTrkCommandResult &result)
+void CodaRunControl::handleAddListener(const CodaCommandResult &result)
 {
    Q_UNUSED(result)
-    m_tcfTrkDevice->sendSymbianOsDataFindProcessesCommand(TcfTrkCallback(this, &CodaRunControl::handleFindProcesses),
+    m_codaDevice->sendSymbianOsDataFindProcessesCommand(CodaCallback(this, &CodaRunControl::handleFindProcesses),
                                                          QByteArray(),
                                                          QByteArray::number(executableUid(), 16));
 }

-void CodaRunControl::handleFindProcesses(const TcfTrkCommandResult &result)
+void CodaRunControl::handleFindProcesses(const CodaCommandResult &result)
 {
    if (result.values.size() && result.values.at(0).type() == JsonValue::Array && result.values.at(0).children().count()) {
        //there are processes running. Cannot run mine
@@ -304,15 +304,15 @@ void CodaRunControl::handleFindProcesses(const TcfTrkCommandResult &result)
        finishRunControl();
    } else {
        setProgress(maxProgress()*0.90);
-        m_tcfTrkDevice->sendProcessStartCommand(TcfTrkCallback(this, &CodaRunControl::handleCreateProcess),
+        m_codaDevice->sendProcessStartCommand(CodaCallback(this, &CodaRunControl::handleCreateProcess),
                                                executableName(), executableUid(), commandLineArguments().split(" "), QString(), true);
        appendMessage(tr("Launching: %1").arg(executableName()), NormalMessageFormat);
    }
 }

-void CodaRunControl::handleCreateProcess(const TcfTrkCommandResult &result)
+void CodaRunControl::handleCreateProcess(const CodaCommandResult &result)
 {
-    const bool ok = result.type == TcfTrkCommandResult::SuccessReply;
+    const bool ok = result.type == CodaCommandResult::SuccessReply;
    if (ok) {
        setProgress(maxProgress());
        appendMessage(tr("Launched."), NormalMessageFormat);
@@ -325,9 +325,9 @@ void CodaRunControl::handleCreateProcess(const TcfTrkCommandResult &result)
 void CodaRunControl::finishRunControl()
 {
    m_runningProcessId.clear();
-    if (m_tcfTrkDevice)
-        m_tcfTrkDevice->deleteLater();
-    m_tcfTrkDevice = 0;
+    if (m_codaDevice)
+        m_codaDevice->deleteLater();
+    m_codaDevice = 0;
    m_state = StateUninit;
    emit finished();
 }
@@ -366,7 +366,7 @@ void CodaRunControl::cancelConnection()

 void CodaRunControl::deviceRemoved(const SymbianUtils::SymbianDevice &device)
 {
-    if (m_tcfTrkDevice && device.portName() == m_serialPort) {
+    if (m_codaDevice && device.portName() == m_serialPort) {
        QString msg = tr("The device '%1' has been disconnected").arg(device.friendlyName());
        appendMessage(msg, ErrorMessageFormat);
        finishRunControl();
--- a/src/plugins/qt4projectmanager/qt-s60/codaruncontrol.h
+++ b/src/plugins/qt4projectmanager/qt-s60/codaruncontrol.h
@@ -41,10 +41,10 @@ class QMessageBox;
 class QWidget;
 QT_END_NAMESPACE

-namespace tcftrk {
-struct TcfTrkCommandResult;
-class TcfTrkDevice;
-class TcfTrkEvent;
+namespace Coda {
+struct CodaCommandResult;
+class CodaDevice;
+class CodaEvent;
 }

 namespace SymbianUtils {
@@ -54,7 +54,7 @@ class SymbianDevice;
 namespace Qt4ProjectManager {
 namespace Internal {

-// CodaRunControl configures tcftrk to run the application
+// CodaRunControl configures Coda to run the application
 class CodaRunControl : public S60RunControlBase
 {
    Q_OBJECT
@@ -79,22 +79,22 @@ protected slots:
 private slots:
    void slotError(const QString &error);
    void slotTrkLogMessage(const QString &log);
-    void slotTcftrkEvent(const tcftrk::TcfTrkEvent &event);
+    void slotCodaEvent(const Coda::CodaEvent &event);
    void slotSerialPong(const QString &message);

 private:
    void initCommunication();

-    void handleModuleLoadSuspended(const tcftrk::TcfTrkEvent &event);
-    void handleContextSuspended(const tcftrk::TcfTrkEvent &event);
-    void handleContextAdded(const tcftrk::TcfTrkEvent &event);
-    void handleContextRemoved(const tcftrk::TcfTrkEvent &event);
-    void handleLogging(const tcftrk::TcfTrkEvent &event);
+    void handleModuleLoadSuspended(const Coda::CodaEvent &event);
+    void handleContextSuspended(const Coda::CodaEvent &event);
+    void handleContextAdded(const Coda::CodaEvent &event);
+    void handleContextRemoved(const Coda::CodaEvent &event);
+    void handleLogging(const Coda::CodaEvent &event);

 private:
-    void handleCreateProcess(const tcftrk::TcfTrkCommandResult &result);
-    void handleAddListener(const tcftrk::TcfTrkCommandResult &result);
-    void handleFindProcesses(const tcftrk::TcfTrkCommandResult &result);
+    void handleCreateProcess(const Coda::CodaCommandResult &result);
+    void handleAddListener(const Coda::CodaCommandResult &result);
+    void handleFindProcesses(const Coda::CodaCommandResult &result);

 private:
    enum State {
@@ -104,7 +104,7 @@ private:
        StateProcessRunning
    };

-    tcftrk::TcfTrkDevice *m_tcfTrkDevice;
+    Coda::CodaDevice *m_codaDevice;

    QString m_address;
    unsigned short m_port;
--- a/src/plugins/qt4projectmanager/qt-s60/s60deploystep.cpp
+++ b/src/plugins/qt4projectmanager/qt-s60/s60deploystep.cpp
@@ -37,7 +37,7 @@
 #include "s60deployconfiguration.h"
 #include "s60devicerunconfiguration.h"
 #include "s60runconfigbluetoothstarter.h"
-#include "tcftrkdevice.h"
+#include "codadevice.h"
 #include "trkruncontrol.h"

 #include <coreplugin/icore.h>
@@ -295,7 +295,7 @@ void S60DeployStep::start()
    }
    if (!trkClient) {
        QTC_ASSERT(!m_trkDevice, return);
-        m_trkDevice = new tcftrk::TcfTrkDevice;
+        m_trkDevice = new Coda::CodaDevice;
        if (m_address.isEmpty() && !serialConnection) {
            errorMessage = tr("No address for a device has been defined. Please define an address and try again.");
            reportError(errorMessage);
@@ -347,7 +347,7 @@ void S60DeployStep::setupConnections()
    } else {
        connect(m_trkDevice, SIGNAL(error(QString)), this, SLOT(slotError(QString)));
        connect(m_trkDevice, SIGNAL(logMessage(QString)), this, SLOT(slotTrkLogMessage(QString)));
-        connect(m_trkDevice, SIGNAL(tcfEvent(tcftrk::TcfTrkEvent)), this, SLOT(slotTcftrkEvent(tcftrk::TcfTrkEvent)), Qt::DirectConnection);
+        connect(m_trkDevice, SIGNAL(tcfEvent(Coda::CodaEvent)), this, SLOT(slotCodaEvent(Coda::CodaEvent)), Qt::DirectConnection);
        connect(m_trkDevice, SIGNAL(serialPong(QString)), this, SLOT(slotSerialPong(QString)));
        connect(this, SIGNAL(manualInstallation()), this, SLOT(showManualInstallationInfo()));
    }
@@ -400,9 +400,9 @@ void S60DeployStep::startDeployment()
        m_trkDevice->sendSerialPing(false);
        QTimer::singleShot(4000, this, SLOT(checkForTimeout()));
    } else {
-        const QSharedPointer<QTcpSocket> tcfTrkSocket(new QTcpSocket);
-        m_trkDevice->setDevice(tcfTrkSocket);
-        tcfTrkSocket->connectToHost(m_address, m_port);
+        const QSharedPointer<QTcpSocket> codaSocket(new QTcpSocket);
+        m_trkDevice->setDevice(codaSocket);
+        codaSocket->connectToHost(m_address, m_port);
        m_state = StateConnecting;
        appendMessage(tr("Connecting to %1:%2...").arg(m_address).arg(m_port), false);
        QTimer::singleShot(4000, this, SLOT(checkForTimeout()));
@@ -466,13 +466,13 @@ void S60DeployStep::slotSerialPong(const QString &message)
        qDebug() << "CODA serial pong:" << message;
 }

-void S60DeployStep::slotTcftrkEvent (const tcftrk::TcfTrkEvent &event)
+void S60DeployStep::slotCodaEvent (const Coda::CodaEvent &event)
 {
    if (debug)
        qDebug() << "CODA event:" << "Type:" << event.type() << "Message:" << event.toString();

    switch (event.type()) {
-    case tcftrk::TcfTrkEvent::LocatorHello: {// Commands accepted now
+    case Coda::CodaEvent::LocatorHello: {// Commands accepted now
        m_state = StateConnected;
        emit codaConnected();
        startTransferring();
@@ -491,14 +491,14 @@ void S60DeployStep::initFileSending()
    QTC_ASSERT(m_currentFileIndex >= 0, return);

    const unsigned flags =
-            tcftrk::TcfTrkDevice::FileSystem_TCF_O_WRITE
-            |tcftrk::TcfTrkDevice::FileSystem_TCF_O_CREAT
-            |tcftrk::TcfTrkDevice::FileSystem_TCF_O_TRUNC;
+            Coda::CodaDevice::FileSystem_TCF_O_WRITE
+            |Coda::CodaDevice::FileSystem_TCF_O_CREAT
+            |Coda::CodaDevice::FileSystem_TCF_O_TRUNC;
    m_putWriteOk = false;

    QString packageName(QFileInfo(m_signedPackages.at(m_currentFileIndex)).fileName());
    QString remoteFileLocation = QString::fromLatin1("%1:\\Data\\%2").arg(m_installationDrive).arg(packageName);
-    m_trkDevice->sendFileSystemOpenCommand(tcftrk::TcfTrkCallback(this, &S60DeployStep::handleFileSystemOpen),
+    m_trkDevice->sendFileSystemOpenCommand(Coda::CodaCallback(this, &S60DeployStep::handleFileSystemOpen),
                                           remoteFileLocation.toAscii(), flags);
    appendMessage(tr("Copying \"%1\"...").arg(packageName), false);
 }
@@ -511,11 +511,11 @@ void S60DeployStep::initFileInstallation()
    QString packageName(QFileInfo(m_signedPackages.at(m_currentFileIndex)).fileName());
    QString remoteFileLocation = QString::fromLatin1("%1:\\Data\\%2").arg(m_installationDrive).arg(packageName);
    if (m_silentInstall) {
-        m_trkDevice->sendSymbianInstallSilentInstallCommand(tcftrk::TcfTrkCallback(this, &S60DeployStep::handleSymbianInstall),
+        m_trkDevice->sendSymbianInstallSilentInstallCommand(Coda::CodaCallback(this, &S60DeployStep::handleSymbianInstall),
                                                            remoteFileLocation.toAscii(), QString::fromLatin1("%1:").arg(m_installationDrive).toAscii());
        appendMessage(tr("Installing package \"%1\" on drive %2:...").arg(packageName).arg(m_installationDrive), false);
    } else {
-        m_trkDevice->sendSymbianInstallUIInstallCommand(tcftrk::TcfTrkCallback(this, &S60DeployStep::handleSymbianInstall),
+        m_trkDevice->sendSymbianInstallUIInstallCommand(Coda::CodaCallback(this, &S60DeployStep::handleSymbianInstall),
                                                        remoteFileLocation.toAscii());
        appendMessage(tr("Please continue the installation on your device."), false);
        emit manualInstallation();
@@ -536,9 +536,9 @@ void S60DeployStep::startInstalling()
    m_state = StateInstalling;
 }

-void S60DeployStep::handleFileSystemOpen(const tcftrk::TcfTrkCommandResult &result)
+void S60DeployStep::handleFileSystemOpen(const Coda::CodaCommandResult &result)
 {
-    if (result.type != tcftrk::TcfTrkCommandResult::SuccessReply) {
+    if (result.type != Coda::CodaCommandResult::SuccessReply) {
        reportError(tr("Open remote file failed: %1").arg(result.errorString()));
        return;
    }
@@ -558,9 +558,9 @@ void S60DeployStep::handleFileSystemOpen(const tcftrk::TcfTrkCommandResult &resu
    putSendNextChunk();
 }

-void S60DeployStep::handleSymbianInstall(const tcftrk::TcfTrkCommandResult &result)
+void S60DeployStep::handleSymbianInstall(const Coda::CodaCommandResult &result)
 {
-    if (result.type == tcftrk::TcfTrkCommandResult::SuccessReply) {
+    if (result.type == Coda::CodaCommandResult::SuccessReply) {
        appendMessage(tr("Installation has finished"), false);
        if (++m_currentFileIndex >= m_signedPackages.count())
            emit allFilesInstalled();
@@ -587,7 +587,7 @@ void S60DeployStep::putSendNextChunk()
            qDebug("Writing %llu bytes to remote file '%s' at %llu\n",
                   m_putLastChunkSize,
                   m_remoteFileHandle.constData(), pos);
-        m_trkDevice->sendFileSystemWriteCommand(tcftrk::TcfTrkCallback(this, &S60DeployStep::handleFileSystemWrite),
+        m_trkDevice->sendFileSystemWriteCommand(Coda::CodaCallback(this, &S60DeployStep::handleFileSystemWrite),
                                                m_remoteFileHandle, data, unsigned(pos));
        setCopyProgress((100*(m_putLastChunkSize+pos))/size);
    }
@@ -595,11 +595,11 @@ void S60DeployStep::putSendNextChunk()

 void S60DeployStep::closeRemoteFile()
 {
-    m_trkDevice->sendFileSystemCloseCommand(tcftrk::TcfTrkCallback(this, &S60DeployStep::handleFileSystemClose),
+    m_trkDevice->sendFileSystemCloseCommand(Coda::CodaCallback(this, &S60DeployStep::handleFileSystemClose),
                                            m_remoteFileHandle);
 }

-void S60DeployStep::handleFileSystemWrite(const tcftrk::TcfTrkCommandResult &result)
+void S60DeployStep::handleFileSystemWrite(const Coda::CodaCommandResult &result)
 {
    // Close remote file even if copy fails
    m_putWriteOk = result;
@@ -615,9 +615,9 @@ void S60DeployStep::handleFileSystemWrite(const tcftrk::TcfTrkCommandResult &res
    }
 }

-void S60DeployStep::handleFileSystemClose(const tcftrk::TcfTrkCommandResult &result)
+void S60DeployStep::handleFileSystemClose(const Coda::CodaCommandResult &result)
 {
-    if (result.type == tcftrk::TcfTrkCommandResult::SuccessReply) {
+    if (result.type == Coda::CodaCommandResult::SuccessReply) {
        if (debug)
            qDebug("File closed.\n");
        if (++m_currentFileIndex >= m_signedPackages.count())
--- a/src/plugins/qt4projectmanager/qt-s60/s60deploystep.h
+++ b/src/plugins/qt4projectmanager/qt-s60/s60deploystep.h
@@ -49,10 +49,10 @@ namespace trk{
 class Launcher;
 }

-namespace tcftrk {
-    struct TcfTrkCommandResult;
-    class TcfTrkDevice;
-    class TcfTrkEvent;
+namespace Coda {
+    struct CodaCommandResult;
+    class CodaDevice;
+    class CodaEvent;
 }

 namespace ProjectExplorer {
@@ -129,7 +129,7 @@ private slots:
    void slotError(const QString &error);
    void slotTrkLogMessage(const QString &log);
    void slotSerialPong(const QString &message);
-    void slotTcftrkEvent(const tcftrk::TcfTrkEvent &event);
+    void slotCodaEvent(const Coda::CodaEvent &event);

    void startInstalling();
    void startTransferring();
@@ -167,12 +167,12 @@ private:
    void appendMessage(const QString &error, bool isError);
    void reportError(const QString &error);

-    void handleSymbianInstall(const tcftrk::TcfTrkCommandResult &result);
-    void handleFileSystemOpen(const tcftrk::TcfTrkCommandResult &result);
-    void handleFileSystemWrite(const tcftrk::TcfTrkCommandResult &result);
+    void handleSymbianInstall(const Coda::CodaCommandResult &result);
+    void handleFileSystemOpen(const Coda::CodaCommandResult &result);
+    void handleFileSystemWrite(const Coda::CodaCommandResult &result);
    void closeRemoteFile();
    void putSendNextChunk();
-    void handleFileSystemClose(const tcftrk::TcfTrkCommandResult &result);
+    void handleFileSystemClose(const Coda::CodaCommandResult &result);

    void initFileSending();
    void initFileInstallation();
@@ -201,7 +201,7 @@ private:
    QFutureInterface<bool> *m_futureInterface; //not owned

    trk::Launcher *m_launcher;
-    tcftrk::TcfTrkDevice *m_trkDevice;
+    Coda::CodaDevice *m_trkDevice;

    QEventLoop *m_eventLoop;
    bool m_deployResult;
--- a/src/shared/symbianutils/tcftrkdevice.cpp
+++ b/src/shared/symbianutils/tcftrkdevice.cpp
@@ -31,7 +31,7 @@
 **
 **************************************************************************/

-#include "tcftrkdevice.h"
+#include "codadevice.h"
 #include "json.h"
 #include "trkutils.h"

@@ -106,18 +106,18 @@ static inline QByteArray encodeUsbSerialMessage(const QByteArray &dataIn)
        pos = chunkEnd;
    }
    if (debug > 1)
-        qDebug("Serial chunked:\n%s", qPrintable(tcftrk::formatData(frame)));
+        qDebug("Serial chunked:\n%s", qPrintable(Coda::formatData(frame)));
    return frame;
 }

-namespace tcftrk {
-// ------------- TcfTrkCommandError
+namespace Coda {
+// ------------- CodaCommandError

-TcfTrkCommandError::TcfTrkCommandError() : timeMS(0), code(0), alternativeCode(0)
+CodaCommandError::CodaCommandError() : timeMS(0), code(0), alternativeCode(0)
 {
 }

-void TcfTrkCommandError::clear()
+void CodaCommandError::clear()
 {
    timeMS = 0;
    code = alternativeCode = 0;
@@ -125,17 +125,17 @@ void TcfTrkCommandError::clear()
    alternativeOrganization.clear();
 }

-QDateTime TcfTrkCommandResult::tcfTimeToQDateTime(quint64 tcfTimeMS)
+QDateTime CodaCommandResult::tcfTimeToQDateTime(quint64 tcfTimeMS)
 {
    const QDateTime time(QDate(1970, 1, 1));
    return time.addMSecs(tcfTimeMS);
 }

-void TcfTrkCommandError::write(QTextStream &str) const
+void CodaCommandError::write(QTextStream &str) const
 {
    if (isError()) {
        if (timeMS)
-            str << TcfTrkCommandResult::tcfTimeToQDateTime(timeMS).toString(Qt::ISODate) << ": ";
+            str << CodaCommandResult::tcfTimeToQDateTime(timeMS).toString(Qt::ISODate) << ": ";
        str << "Error code: " << code
                << " '" << format << '\'';
        if (!alternativeOrganization.isEmpty())
@@ -145,7 +145,7 @@ void TcfTrkCommandError::write(QTextStream &str) const
    }
 }

-QString TcfTrkCommandError::toString() const
+QString CodaCommandError::toString() const
 {
    QString rc;
    QTextStream str(&rc);
@@ -153,13 +153,13 @@ QString TcfTrkCommandError::toString() const
    return rc;
 }

-bool TcfTrkCommandError::isError() const
+bool CodaCommandError::isError() const
 {
    return timeMS != 0 || code != 0 || !format.isEmpty() || alternativeCode != 0;
 }

 /* {"Time":1277459762255,"Code":1,"AltCode":-6,"AltOrg":"POSIX","Format":"Unknown error: -6"} */
-bool TcfTrkCommandError::parse(const QVector<JsonValue> &values)
+bool CodaCommandError::parse(const QVector<JsonValue> &values)
 {
    // Parse an arbitrary hash (that could as well be a command response)
    // and check for error elements. It looks like sometimes errors are appended
@@ -199,21 +199,21 @@ bool TcfTrkCommandError::parse(const QVector<JsonValue> &values)
    if (!errorFound)
        clear();
    if (debug) {
-        qDebug("TcfTrkCommandError::parse: Found error %d (%u): ", errorFound, errorKeyCount);
+        qDebug("CodaCommandError::parse: Found error %d (%u): ", errorFound, errorKeyCount);
        if (!values.isEmpty())
            qDebug() << values.back().toString();
    }
    return errorFound;
 }

-// ------------ TcfTrkCommandResult
+// ------------ CodaCommandResult

-TcfTrkCommandResult::TcfTrkCommandResult(Type t) :
+CodaCommandResult::CodaCommandResult(Type t) :
    type(t), service(LocatorService)
 {
 }

-TcfTrkCommandResult::TcfTrkCommandResult(char typeChar, Services s,
+CodaCommandResult::CodaCommandResult(char typeChar, Services s,
                                         const QByteArray &r,
                                         const QVector<JsonValue> &v,
                                         const QVariant &ck) :
@@ -234,7 +234,7 @@ TcfTrkCommandResult::TcfTrkCommandResult(char typeChar, Services s,
    }
 }

-QString TcfTrkCommandResult::errorString() const
+QString CodaCommandResult::errorString() const
 {
    QString rc;
    QTextStream str(&rc);
@@ -259,7 +259,7 @@ QString TcfTrkCommandResult::errorString() const
    return rc;
 }

-QString TcfTrkCommandResult::toString() const
+QString CodaCommandResult::toString() const
 {
    QString rc;
    QTextStream str(&rc);
@@ -292,19 +292,19 @@ QString TcfTrkCommandResult::toString() const
    return rc;
 }

-TcfTrkStatResponse::TcfTrkStatResponse() : size(0)
+CodaStatResponse::CodaStatResponse() : size(0)
 {
 }

-struct TcfTrkSendQueueEntry
+struct CodaSendQueueEntry
 {
-    typedef TcfTrkDevice::MessageType MessageType;
+    typedef CodaDevice::MessageType MessageType;

-    explicit TcfTrkSendQueueEntry(MessageType mt,
+    explicit CodaSendQueueEntry(MessageType mt,
                                  int tok,
                                  Services s,
                                  const QByteArray &d,
-                                  const TcfTrkCallback &cb= TcfTrkCallback(),
+                                  const CodaCallback &cb= CodaCallback(),
                                  const QVariant &ck = QVariant()) :
        messageType(mt), service(s), data(d), token(tok), cookie(ck), callback(cb) {}

@@ -313,15 +313,15 @@ struct TcfTrkSendQueueEntry
    QByteArray data;
    int token;
    QVariant cookie;
-    TcfTrkCallback callback;
+    CodaCallback callback;
    unsigned specialHandling;
 };

-struct TcfTrkDevicePrivate {
-    typedef TcfTrkDevice::IODevicePtr IODevicePtr;
-    typedef QHash<int, TcfTrkSendQueueEntry> TokenWrittenMessageMap;
+struct CodaDevicePrivate {
+    typedef CodaDevice::IODevicePtr IODevicePtr;
+    typedef QHash<int, CodaSendQueueEntry> TokenWrittenMessageMap;

-    TcfTrkDevicePrivate();
+    CodaDevicePrivate();

    const QByteArray m_tcpMessageTerminator;

@@ -330,7 +330,7 @@ struct TcfTrkDevicePrivate {
    QByteArray m_readBuffer;
    QByteArray m_serialBuffer; // for chunked messages
    int m_token;
-    QQueue<TcfTrkSendQueueEntry> m_sendQueue;
+    QQueue<CodaSendQueueEntry> m_sendQueue;
    TokenWrittenMessageMap m_writtenMessages;
    QVector<QByteArray> m_registerNames;
    QVector<QByteArray> m_fakeGetMRegisterValues;
@@ -338,28 +338,28 @@ struct TcfTrkDevicePrivate {
    bool m_serialPingOnly;
 };

-TcfTrkDevicePrivate::TcfTrkDevicePrivate() :
+CodaDevicePrivate::CodaDevicePrivate() :
    m_tcpMessageTerminator(tcpMessageTerminatorC),
    m_verbose(0), m_token(0), m_serialFrame(false), m_serialPingOnly(false)
 {
 }

-TcfTrkDevice::TcfTrkDevice(QObject *parent) :
-    QObject(parent), d(new TcfTrkDevicePrivate)
+CodaDevice::CodaDevice(QObject *parent) :
+    QObject(parent), d(new CodaDevicePrivate)
 {
 }

-TcfTrkDevice::~TcfTrkDevice()
+CodaDevice::~CodaDevice()
 {
    delete d;
 }

-QVector<QByteArray> TcfTrkDevice::registerNames() const
+QVector<QByteArray> CodaDevice::registerNames() const
 {
    return d->m_registerNames;
 }

-void TcfTrkDevice::setRegisterNames(const QVector<QByteArray>& n)
+void CodaDevice::setRegisterNames(const QVector<QByteArray>& n)
 {
    d->m_registerNames = n;
    if (d->m_verbose) {
@@ -373,12 +373,12 @@ void TcfTrkDevice::setRegisterNames(const QVector<QByteArray>& n)
    }
 }

-TcfTrkDevice::IODevicePtr TcfTrkDevice::device() const
+CodaDevice::IODevicePtr CodaDevice::device() const
 {
    return d->m_device;
 }

-TcfTrkDevice::IODevicePtr TcfTrkDevice::takeDevice()
+CodaDevice::IODevicePtr CodaDevice::takeDevice()
 {
    const IODevicePtr old = d->m_device;
    if (!old.isNull()) {
@@ -391,7 +391,7 @@ TcfTrkDevice::IODevicePtr TcfTrkDevice::takeDevice()
    return old;
 }

-void TcfTrkDevice::setDevice(const IODevicePtr &dp)
+void CodaDevice::setDevice(const IODevicePtr &dp)
 {
    if (dp.data() == d->m_device.data())
        return;
@@ -408,14 +408,14 @@ void TcfTrkDevice::setDevice(const IODevicePtr &dp)
    }
 }

-void TcfTrkDevice::slotDeviceError()
+void CodaDevice::slotDeviceError()
 {
    const QString message = d->m_device->errorString();
    emitLogMessage(message);
    emit error(message);
 }

-void TcfTrkDevice::slotDeviceSocketStateChanged()
+void CodaDevice::slotDeviceSocketStateChanged()
 {
    if (const QAbstractSocket *s = qobject_cast<const QAbstractSocket *>(d->m_device.data())) {
        const QAbstractSocket::SocketState st = s->state();
@@ -455,7 +455,7 @@ static inline QString debugMessage(QByteArray  message, const char *prefix = 0)
            (QLatin1String(prefix) + messageS) :  messageS;
 }

-void TcfTrkDevice::slotDeviceReadyRead()
+void CodaDevice::slotDeviceReadyRead()
 {
    const QByteArray newData = d->m_device->readAll();
    d->m_readBuffer += newData;
@@ -492,7 +492,7 @@ static inline QPair<int, int> findSerialHeader(const QByteArray &in)
    return QPair<int, int>(-1, -1);
 }

-void TcfTrkDevice::deviceReadyReadSerial()
+void CodaDevice::deviceReadyReadSerial()
 {
    do {
        // Extract message (pos,len)
@@ -509,7 +509,7 @@ void TcfTrkDevice::deviceReadyReadSerial()
    checkSendQueue(); // Send off further messages
 }

-void TcfTrkDevice::processSerialMessage(const QByteArray &message)
+void CodaDevice::processSerialMessage(const QByteArray &message)
 {
    if (debug > 1)
        qDebug("Serial message: %s",qPrintable(trk::stringFromArray(message)));
@@ -551,7 +551,7 @@ void TcfTrkDevice::processSerialMessage(const QByteArray &message)
    }
 }

-void TcfTrkDevice::deviceReadyReadTcp()
+void CodaDevice::deviceReadyReadTcp()
 {
    // Take complete message off front of readbuffer.
    do {
@@ -569,7 +569,7 @@ void TcfTrkDevice::deviceReadyReadTcp()
    checkSendQueue(); // Send off further messages
 }

-void TcfTrkDevice::processMessage(const QByteArray &message)
+void CodaDevice::processMessage(const QByteArray &message)
 {
    if (debug)
        qDebug("Read %d bytes:\n%s", message.size(), qPrintable(formatData(message)));
@@ -598,7 +598,7 @@ static inline QVector<QByteArray> splitMessage(const QByteArray &message)
    return tokens;
 }

-int TcfTrkDevice::parseMessage(const QByteArray &message)
+int CodaDevice::parseMessage(const QByteArray &message)
 {
    if (d->m_verbose)
        emitLogMessage(debugMessage(message, "TCF ->"));
@@ -630,9 +630,9 @@ int TcfTrkDevice::parseMessage(const QByteArray &message)
    return 0;
 }

-int TcfTrkDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tokens)
+int CodaDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tokens)
 {
-    typedef TcfTrkDevicePrivate::TokenWrittenMessageMap::iterator TokenWrittenMessageMapIterator;
+    typedef CodaDevicePrivate::TokenWrittenMessageMap::iterator TokenWrittenMessageMapIterator;
    // Find the corresponding entry in the written messages hash.
    const int tokenCount = tokens.size();
    if (tokenCount < 1)
@@ -643,7 +643,7 @@ int TcfTrkDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tok
        return 235;
    const TokenWrittenMessageMapIterator it = d->m_writtenMessages.find(token);
    if (it == d->m_writtenMessages.end()) {
-        qWarning("TcfTrkDevice: Internal error: token %d not found for '%s'",
+        qWarning("CodaDevice: Internal error: token %d not found for '%s'",
                 token, qPrintable(joinByteArrays(tokens)));
        return 236;
    }
@@ -670,7 +670,7 @@ int TcfTrkDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tok
        }
    }
    // Construct result and invoke callback, remove entry from map.
-    TcfTrkCommandResult result(type, it.value().service, it.value().data,
+    CodaCommandResult result(type, it.value().service, it.value().data,
                               values, it.value().cookie);

    if (it.value().callback)
@@ -679,7 +679,7 @@ int TcfTrkDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tok
    return 0;
 }

-int TcfTrkDevice::parseTcfEvent(const QVector<QByteArray> &tokens)
+int CodaDevice::parseTcfEvent(const QVector<QByteArray> &tokens)
 {
    // Event: Ignore the periodical heartbeat event, answer 'Hello',
    // emit signal for the rest
@@ -696,10 +696,10 @@ int TcfTrkDevice::parseTcfEvent(const QVector<QByteArray> &tokens)
        values.push_back(value);
    }
    // Parse known events, emit signals
-    QScopedPointer<TcfTrkEvent> knownEvent(TcfTrkEvent::parseEvent(service, tokens.at(1), values));
+    QScopedPointer<CodaEvent> knownEvent(CodaEvent::parseEvent(service, tokens.at(1), values));
    if (!knownEvent.isNull()) {
        // Answer hello event (WLAN)
-        if (knownEvent->type() == TcfTrkEvent::LocatorHello)
+        if (knownEvent->type() == CodaEvent::LocatorHello)
            if (!d->m_serialFrame)
                writeMessage(QByteArray(locatorAnswerC, sizeof(locatorAnswerC)));
        emit tcfEvent(*knownEvent);
@@ -722,47 +722,47 @@ int TcfTrkDevice::parseTcfEvent(const QVector<QByteArray> &tokens)
    return 0;
 }

-unsigned TcfTrkDevice::verbose() const
+unsigned CodaDevice::verbose() const
 {
    return d->m_verbose;
 }

-bool TcfTrkDevice::serialFrame() const
+bool CodaDevice::serialFrame() const
 {
    return d->m_serialFrame;
 }

-void TcfTrkDevice::setSerialFrame(bool s)
+void CodaDevice::setSerialFrame(bool s)
 {
    d->m_serialFrame = s;
 }

-void TcfTrkDevice::setVerbose(unsigned v)
+void CodaDevice::setVerbose(unsigned v)
 {
    d->m_verbose = v;
 }

-void TcfTrkDevice::emitLogMessage(const QString &m)
+void CodaDevice::emitLogMessage(const QString &m)
 {
    if (debug)
        qWarning("%s", qPrintable(m));
    emit logMessage(m);
 }

-bool TcfTrkDevice::checkOpen()
+bool CodaDevice::checkOpen()
 {
    if (d->m_device.isNull()) {
-        emitLogMessage(QLatin1String("Internal error: No device set on TcfTrkDevice."));
+        emitLogMessage(QLatin1String("Internal error: No device set on CodaDevice."));
        return false;
    }
    if (!d->m_device->isOpen()) {
-        emitLogMessage(QLatin1String("Internal error: Device not open in TcfTrkDevice."));
+        emitLogMessage(QLatin1String("Internal error: Device not open in CodaDevice."));
        return false;
    }
    return true;
 }

-void TcfTrkDevice::sendSerialPing(bool pingOnly)
+void CodaDevice::sendSerialPing(bool pingOnly)
 {
    if (!checkOpen())
        return;
@@ -774,10 +774,10 @@ void TcfTrkDevice::sendSerialPing(bool pingOnly)
        emitLogMessage(QLatin1String("Ping..."));
 }

-void TcfTrkDevice::sendTcfTrkMessage(MessageType mt, Services service, const char *command,
+void CodaDevice::sendCodaMessage(MessageType mt, Services service, const char *command,
                                     const char *commandParameters, // may contain '\0'
                                     int commandParametersLength,
-                                     const TcfTrkCallback &callBack,
+                                     const CodaCallback &callBack,
                                     const QVariant &cookie)

 {
@@ -797,22 +797,22 @@ void TcfTrkDevice::sendTcfTrkMessage(MessageType mt, Services service, const cha
    data.append('\0');
    if (commandParametersLength)
        data.append(commandParameters, commandParametersLength);
-    const TcfTrkSendQueueEntry entry(mt, token, service, data, callBack, cookie);
+    const CodaSendQueueEntry entry(mt, token, service, data, callBack, cookie);
    d->m_sendQueue.enqueue(entry);
    checkSendQueue();
 }

-void TcfTrkDevice::sendTcfTrkMessage(MessageType mt, Services service, const char *command,
+void CodaDevice::sendCodaMessage(MessageType mt, Services service, const char *command,
                                     const QByteArray &commandParameters,
-                                     const TcfTrkCallback &callBack,
+                                     const CodaCallback &callBack,
                                     const QVariant &cookie)
 {
-    sendTcfTrkMessage(mt, service, command, commandParameters.constData(), commandParameters.size(),
+    sendCodaMessage(mt, service, command, commandParameters.constData(), commandParameters.size(),
                      callBack, cookie);
 }

 // Enclose in message frame and write.
-void TcfTrkDevice::writeMessage(QByteArray data, bool ensureTerminating0)
+void CodaDevice::writeMessage(QByteArray data, bool ensureTerminating0)
 {
    if (!checkOpen())
        return;
@@ -844,14 +844,14 @@ void TcfTrkDevice::writeMessage(QByteArray data, bool ensureTerminating0)
        as->flush();
 }

-void TcfTrkDevice::checkSendQueue()
+void CodaDevice::checkSendQueue()
 {
    // Fire off messages or invoke noops until a message with reply is found
    // and an entry to writtenMessages is made.
    while (d->m_writtenMessages.empty()) {
        if (d->m_sendQueue.isEmpty())
            break;
-        TcfTrkSendQueueEntry entry = d->m_sendQueue.dequeue();
+        CodaSendQueueEntry entry = d->m_sendQueue.dequeue();
        switch (entry.messageType) {
        case MessageWithReply:
            d->m_writtenMessages.insert(entry.token, entry);
@@ -862,7 +862,7 @@ void TcfTrkDevice::checkSendQueue()
            break;
        case NoopMessage: // Invoke the noop-callback for synchronization
            if (entry.callback) {
-                TcfTrkCommandResult noopResult(TcfTrkCommandResult::SuccessReply);
+                CodaCommandResult noopResult(CodaCommandResult::SuccessReply);
                noopResult.cookie = entry.cookie;
                entry.callback(noopResult);
            }
@@ -879,7 +879,7 @@ static inline QString fixFileName(QString in)
 }

 // Start a process (consisting of a non-reply setSettings and start).
-void TcfTrkDevice::sendProcessStartCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendProcessStartCommand(const CodaCallback &callBack,
                                                 const QString &binaryIn,
                                                 unsigned uid,
                                                 QStringList arguments,
@@ -911,7 +911,7 @@ void TcfTrkDevice::sendProcessStartCommand(const TcfTrkCallback &callBack,
                << '{' << binaryFileName << ':' << QString::number(uid, 16) << '}' << ','
                << additionalLibraries << ',' << true
            << ']';
-    sendTcfTrkMessage(
+    sendCodaMessage(
 #if 1
                MessageWithReply,    // TCF TRK 4.0.5 onwards
 #else
@@ -925,10 +925,10 @@ void TcfTrkDevice::sendProcessStartCommand(const TcfTrkCallback &callBack,
            << '\0' << binaryFileName << '\0' << arguments << '\0'
            << QStringList() << '\0' // Env is an array ["PATH=value"] (non-standard)
            << debugControl;
-    sendTcfTrkMessage(MessageWithReply, ProcessesService, "start", startData, callBack, cookie);
+    sendCodaMessage(MessageWithReply, ProcessesService, "start", startData, callBack, cookie);
 }

-void TcfTrkDevice::sendSettingsEnableLogCommand()
+void CodaDevice::sendSettingsEnableLogCommand()
 {

    QByteArray setData;
@@ -938,7 +938,7 @@ void TcfTrkDevice::sendSettingsEnableLogCommand()
            << '\0' << '['
            << true
            << ']';
-    sendTcfTrkMessage(
+    sendCodaMessage(
 #if 1
                MessageWithReply,    // TCF TRK 4.0.5 onwards
 #else
@@ -947,28 +947,28 @@ void TcfTrkDevice::sendSettingsEnableLogCommand()
                SettingsService, "set", setData);
 }

-void TcfTrkDevice::sendProcessTerminateCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendProcessTerminateCommand(const CodaCallback &callBack,
                                               const QByteArray &id,
                                               const QVariant &cookie)
 {
    QByteArray data;
    JsonInputStream str(data);
    str << id;
-    sendTcfTrkMessage(MessageWithReply, ProcessesService, "terminate", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, ProcessesService, "terminate", data, callBack, cookie);
 }

-void TcfTrkDevice::sendRunControlTerminateCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendRunControlTerminateCommand(const CodaCallback &callBack,
                                                  const QByteArray &id,
                                                  const QVariant &cookie)
 {
    QByteArray data;
    JsonInputStream str(data);
    str << id;
-    sendTcfTrkMessage(MessageWithReply, RunControlService, "terminate", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, RunControlService, "terminate", data, callBack, cookie);
 }

 // Non-standard: Remove executable from settings
-void TcfTrkDevice::sendSettingsRemoveExecutableCommand(const QString &binaryIn,
+void CodaDevice::sendSettingsRemoveExecutableCommand(const QString &binaryIn,
                                                       unsigned uid,
                                                       const QStringList &additionalLibraries,
                                                       const QVariant &cookie)
@@ -981,10 +981,10 @@ void TcfTrkDevice::sendSettingsRemoveExecutableCommand(const QString &binaryIn,
                << '{' << QFileInfo(binaryIn).fileName() << ':' << QString::number(uid, 16) << '}' << ','
                << additionalLibraries
            << ']';
-    sendTcfTrkMessage(MessageWithoutReply, SettingsService, "set", setData, TcfTrkCallback(), cookie);
+    sendCodaMessage(MessageWithoutReply, SettingsService, "set", setData, CodaCallback(), cookie);
 }

-void TcfTrkDevice::sendRunControlResumeCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendRunControlResumeCommand(const CodaCallback &callBack,
                                               const QByteArray &id,
                                               RunControlResumeMode mode,
                                               unsigned count,
@@ -1006,54 +1006,54 @@ void TcfTrkDevice::sendRunControlResumeCommand(const TcfTrkCallback &callBack,
    default:
        break;
    }
-    sendTcfTrkMessage(MessageWithReply, RunControlService, "resume", resumeData, callBack, cookie);
+    sendCodaMessage(MessageWithReply, RunControlService, "resume", resumeData, callBack, cookie);
 }

-void TcfTrkDevice::sendRunControlSuspendCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendRunControlSuspendCommand(const CodaCallback &callBack,
                                                const QByteArray &id,
                                                const QVariant &cookie)
 {
    QByteArray data;
    JsonInputStream str(data);
    str << id;
-    sendTcfTrkMessage(MessageWithReply, RunControlService, "suspend", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, RunControlService, "suspend", data, callBack, cookie);
 }

-void TcfTrkDevice::sendRunControlResumeCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendRunControlResumeCommand(const CodaCallback &callBack,
                                               const QByteArray &id,
                                               const QVariant &cookie)
 {
    sendRunControlResumeCommand(callBack, id, RM_RESUME, 1, 0, 0, cookie);
 }

-void TcfTrkDevice::sendBreakpointsAddCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendBreakpointsAddCommand(const CodaCallback &callBack,
                                             const Breakpoint &bp,
                                             const QVariant &cookie)
 {
    QByteArray data;
    JsonInputStream str(data);
    str << bp;
-    sendTcfTrkMessage(MessageWithReply, BreakpointsService, "add", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, BreakpointsService, "add", data, callBack, cookie);
 }

-void TcfTrkDevice::sendBreakpointsRemoveCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendBreakpointsRemoveCommand(const CodaCallback &callBack,
                                                const QByteArray &id,
                                                const QVariant &cookie)
 {
    sendBreakpointsRemoveCommand(callBack, QVector<QByteArray>(1, id), cookie);
 }

-void TcfTrkDevice::sendBreakpointsRemoveCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendBreakpointsRemoveCommand(const CodaCallback &callBack,
                                                const QVector<QByteArray> &ids,
                                                const QVariant &cookie)
 {
    QByteArray data;
    JsonInputStream str(data);
    str << ids;
-    sendTcfTrkMessage(MessageWithReply, BreakpointsService, "remove", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, BreakpointsService, "remove", data, callBack, cookie);
 }

-void TcfTrkDevice::sendBreakpointsEnableCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendBreakpointsEnableCommand(const CodaCallback &callBack,
                                                const QByteArray &id,
                                                bool enable,
                                                const QVariant &cookie)
@@ -1061,7 +1061,7 @@ void TcfTrkDevice::sendBreakpointsEnableCommand(const TcfTrkCallback &callBack,
    sendBreakpointsEnableCommand(callBack, QVector<QByteArray>(1, id), enable, cookie);
 }

-void TcfTrkDevice::sendBreakpointsEnableCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendBreakpointsEnableCommand(const CodaCallback &callBack,
                                                const QVector<QByteArray> &ids,
                                                bool enable,
                                                const QVariant &cookie)
@@ -1069,12 +1069,12 @@ void TcfTrkDevice::sendBreakpointsEnableCommand(const TcfTrkCallback &callBack,
    QByteArray data;
    JsonInputStream str(data);
    str << ids;
-    sendTcfTrkMessage(MessageWithReply, BreakpointsService,
+    sendCodaMessage(MessageWithReply, BreakpointsService,
                      enable ? "enable" : "disable",
                      data, callBack, cookie);
 }

-void TcfTrkDevice::sendMemorySetCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendMemorySetCommand(const CodaCallback &callBack,
                                        const QByteArray &contextId,
                                        quint64 start, const QByteArray& data,
                                        const QVariant &cookie)
@@ -1084,10 +1084,10 @@ void TcfTrkDevice::sendMemorySetCommand(const TcfTrkCallback &callBack,
    // start/word size/mode. Mode should ideally be 1 (continue on error?)
    str << contextId << '\0' << start << '\0' << 1 << '\0' << data.size() << '\0' << 1
        << '\0' << data.toBase64();
-    sendTcfTrkMessage(MessageWithReply, MemoryService, "set", getData, callBack, cookie);
+    sendCodaMessage(MessageWithReply, MemoryService, "set", getData, callBack, cookie);
 }

-void TcfTrkDevice::sendMemoryGetCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendMemoryGetCommand(const CodaCallback &callBack,
                                        const QByteArray &contextId,
                                        quint64 start, quint64 size,
                                        const QVariant &cookie)
@@ -1096,12 +1096,12 @@ void TcfTrkDevice::sendMemoryGetCommand(const TcfTrkCallback &callBack,
    JsonInputStream str(data);
    // start/word size/mode. Mode should ideally be 1 (continue on error?)
    str << contextId << '\0' << start << '\0' << 1 << '\0' << size << '\0' << 1;
-    sendTcfTrkMessage(MessageWithReply, MemoryService, "get", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, MemoryService, "get", data, callBack, cookie);
 }

-QByteArray TcfTrkDevice::parseMemoryGet(const TcfTrkCommandResult &r)
+QByteArray CodaDevice::parseMemoryGet(const CodaCommandResult &r)
 {
-    if (r.type != TcfTrkCommandResult::SuccessReply || r.values.size() < 1)
+    if (r.type != CodaCommandResult::SuccessReply || r.values.size() < 1)
        return QByteArray();
    const JsonValue &memoryV = r.values.front();

@@ -1112,18 +1112,18 @@ QByteArray TcfTrkDevice::parseMemoryGet(const TcfTrkCommandResult &r)
    // R.4."TlVMTA==".{"Time":1276786871255,"Code":1,"AltCode":-38,"AltOrg":"POSIX","Format":"BadDescriptor"}
    // Not sure what to make of it.
    if (r.values.size() >= 2 && r.values.at(1).type() == JsonValue::Object)
-        qWarning("TcfTrkDevice::parseMemoryGet(): Error retrieving memory: %s", r.values.at(1).toString(false).constData());
+        qWarning("CodaDevice::parseMemoryGet(): Error retrieving memory: %s", r.values.at(1).toString(false).constData());
    // decode
    const QByteArray memory = QByteArray::fromBase64(memoryV.data());
    if (memory.isEmpty())
        qWarning("Base64 decoding of %s failed.", memoryV.data().constData());
    if (debug)
-        qDebug("TcfTrkDevice::parseMemoryGet: received %d bytes", memory.size());
+        qDebug("CodaDevice::parseMemoryGet: received %d bytes", memory.size());
    return memory;
 }

 // Parse register children (array of names)
-QVector<QByteArray> TcfTrkDevice::parseRegisterGetChildren(const TcfTrkCommandResult &r)
+QVector<QByteArray> CodaDevice::parseRegisterGetChildren(const CodaCommandResult &r)
 {
    QVector<QByteArray> rc;
    if (!r || r.values.size() < 1 || r.values.front().type() != JsonValue::Array)
@@ -1135,9 +1135,9 @@ QVector<QByteArray> TcfTrkDevice::parseRegisterGetChildren(const TcfTrkCommandRe
    return rc;
 }

-TcfTrkStatResponse TcfTrkDevice::parseStat(const TcfTrkCommandResult &r)
+CodaStatResponse CodaDevice::parseStat(const CodaCommandResult &r)
 {
-    TcfTrkStatResponse rc;
+    CodaStatResponse rc;
    if (!r || r.values.size() < 1 || r.values.front().type() != JsonValue::Object)
        return rc;
    foreach(const JsonValue &v, r.values.front().children()) {
@@ -1145,23 +1145,23 @@ TcfTrkStatResponse TcfTrkDevice::parseStat(const TcfTrkCommandResult &r)
            rc.size = v.data().toULongLong();
        } else if (v.name() == "ATime") {
            if (const quint64 atime = v.data().toULongLong())
-                rc.accessTime = TcfTrkCommandResult::tcfTimeToQDateTime(atime);
+                rc.accessTime = CodaCommandResult::tcfTimeToQDateTime(atime);
        } else if (v.name() == "MTime") {
            if (const quint64 mtime = v.data().toULongLong())
-                rc.modTime = TcfTrkCommandResult::tcfTimeToQDateTime(mtime);
+                rc.modTime = CodaCommandResult::tcfTimeToQDateTime(mtime);
        }
    }
    return rc;
 }

-void TcfTrkDevice::sendRegistersGetChildrenCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendRegistersGetChildrenCommand(const CodaCallback &callBack,
                                     const QByteArray &contextId,
                                     const QVariant &cookie)
 {
    QByteArray data;
    JsonInputStream str(data);
    str << contextId;
-    sendTcfTrkMessage(MessageWithReply, RegistersService, "getChildren", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, RegistersService, "getChildren", data, callBack, cookie);
 }

 // Format id of register get request (needs contextId containing process and thread)
@@ -1183,16 +1183,16 @@ static inline QByteArray registerGetData(const QByteArray &contextId, QByteArray
    return data;
 }

-void TcfTrkDevice::sendRegistersGetCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendRegistersGetCommand(const CodaCallback &callBack,
                                            const QByteArray &contextId,
                                            QByteArray id,
                                            const QVariant &cookie)
 {
-    sendTcfTrkMessage(MessageWithReply, RegistersService, "get",
+    sendCodaMessage(MessageWithReply, RegistersService, "get",
                      registerGetData(contextId, id), callBack, cookie);
 }

-void TcfTrkDevice::sendRegistersGetMCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendRegistersGetMCommand(const CodaCallback &callBack,
                                            const QByteArray &contextId,
                                            const QVector<QByteArray> &ids,
                                            const QVariant &cookie)
@@ -1209,16 +1209,16 @@ void TcfTrkDevice::sendRegistersGetMCommand(const TcfTrkCallback &callBack,
        str << '[' << registerId(contextId, ids.at(r)) << ',' << '0' << ',' << '4' << ']';
    }
    str << ']';
-    sendTcfTrkMessage(MessageWithReply, RegistersService, "getm", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, RegistersService, "getm", data, callBack, cookie);
 }

-void TcfTrkDevice::sendRegistersGetMRangeCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendRegistersGetMRangeCommand(const CodaCallback &callBack,
                                                 const QByteArray &contextId,
                                                 unsigned start, unsigned count)
 {
    const unsigned end = start + count;
    if (end > (unsigned)d->m_registerNames.size()) {
-        qWarning("TcfTrkDevice: No register name set for index %u (size: %d).", end, d->m_registerNames.size());
+        qWarning("CodaDevice: No register name set for index %u (size: %d).", end, d->m_registerNames.size());
        return;
    }

@@ -1230,7 +1230,7 @@ void TcfTrkDevice::sendRegistersGetMRangeCommand(const TcfTrkCallback &callBack,
 }

 // Set register
-void TcfTrkDevice::sendRegistersSetCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendRegistersSetCommand(const CodaCallback &callBack,
                                           const QByteArray &contextId,
                                           QByteArray id,
                                           const QByteArray &value,
@@ -1243,18 +1243,18 @@ void TcfTrkDevice::sendRegistersSetCommand(const TcfTrkCallback &callBack,
        id.prepend(contextId);
    }
    str << id << '\0' << value.toBase64();
-    sendTcfTrkMessage(MessageWithReply, RegistersService, "set", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, RegistersService, "set", data, callBack, cookie);
 }

 // Set register
-void TcfTrkDevice::sendRegistersSetCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendRegistersSetCommand(const CodaCallback &callBack,
                                           const QByteArray &contextId,
                                           unsigned registerNumber,
                                           const QByteArray &value,
                                           const QVariant &cookie)
 {
    if (registerNumber >= (unsigned)d->m_registerNames.size()) {
-        qWarning("TcfTrkDevice: No register name set for index %u (size: %d).", registerNumber, d->m_registerNames.size());
+        qWarning("CodaDevice: No register name set for index %u (size: %d).", registerNumber, d->m_registerNames.size());
        return;
    }
    sendRegistersSetCommand(callBack, contextId,
@@ -1265,23 +1265,23 @@ void TcfTrkDevice::sendRegistersSetCommand(const TcfTrkCallback &callBack,
 //static const char outputListenerIDC[] = "org.eclipse.cdt.debug.edc.ui.ProgramOutputConsoleLogger";
 static const char outputListenerIDC[] = "ProgramOutputConsoleLogger"; //TODO: this one might be the correct one

-void TcfTrkDevice::sendLoggingAddListenerCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendLoggingAddListenerCommand(const CodaCallback &callBack,
                                                 const QVariant &cookie)
 {
    QByteArray data;
    JsonInputStream str(data);
    str << outputListenerIDC;
-    sendTcfTrkMessage(MessageWithReply, LoggingService, "addListener", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, LoggingService, "addListener", data, callBack, cookie);
 }

-void TcfTrkDevice::sendSymbianOsDataGetThreadsCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendSymbianOsDataGetThreadsCommand(const CodaCallback &callBack,
                                                 const QVariant &cookie)
 {
    QByteArray data;
-    sendTcfTrkMessage(MessageWithReply, SymbianOSData, "getThreads", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, SymbianOSData, "getThreads", data, callBack, cookie);
 }

-void TcfTrkDevice::sendSymbianOsDataFindProcessesCommand(const TcfTrkCallback &callBack,
+void CodaDevice::sendSymbianOsDataFindProcessesCommand(const CodaCallback &callBack,
                                            const QByteArray &processName,
                                            const QByteArray &uid,
                                            const QVariant &cookie)
@@ -1289,10 +1289,10 @@ void TcfTrkDevice::sendSymbianOsDataFindProcessesCommand(const TcfTrkCallback &c
    QByteArray data;
    JsonInputStream str(data);
    str << processName << '\0' << uid;
-    sendTcfTrkMessage(MessageWithReply, SymbianOSData, "findRunningProcesses", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, SymbianOSData, "findRunningProcesses", data, callBack, cookie);
 }

-void tcftrk::TcfTrkDevice::sendFileSystemOpenCommand(const tcftrk::TcfTrkCallback &callBack,
+void Coda::CodaDevice::sendFileSystemOpenCommand(const Coda::CodaCallback &callBack,
                                                     const QByteArray &name,
                                                     unsigned flags,
                                                     const QVariant &cookie)
@@ -1300,20 +1300,20 @@ void tcftrk::TcfTrkDevice::sendFileSystemOpenCommand(const tcftrk::TcfTrkCallbac
    QByteArray data;
    JsonInputStream str(data);
    str << name << '\0' << flags << '\0' << '{' << '}';
-    sendTcfTrkMessage(MessageWithReply, FileSystemService, "open", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, FileSystemService, "open", data, callBack, cookie);
 }

-void tcftrk::TcfTrkDevice::sendFileSystemFstatCommand(const TcfTrkCallback &callBack,
+void Coda::CodaDevice::sendFileSystemFstatCommand(const CodaCallback &callBack,
                                                      const QByteArray &handle,
                                                      const QVariant &cookie)
 {
    QByteArray data;
    JsonInputStream str(data);
    str << handle;
-    sendTcfTrkMessage(MessageWithReply, FileSystemService, "fstat", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, FileSystemService, "fstat", data, callBack, cookie);
 }

-void tcftrk::TcfTrkDevice::sendFileSystemWriteCommand(const tcftrk::TcfTrkCallback &callBack,
+void Coda::CodaDevice::sendFileSystemWriteCommand(const Coda::CodaCallback &callBack,
                                                      const QByteArray &handle,
                                                      const QByteArray &dataIn,
                                                      unsigned offset,
@@ -1322,20 +1322,20 @@ void tcftrk::TcfTrkDevice::sendFileSystemWriteCommand(const tcftrk::TcfTrkCallba
    QByteArray data;
    JsonInputStream str(data);
    str << handle << '\0' << offset << '\0' << dataIn.toBase64();
-    sendTcfTrkMessage(MessageWithReply, FileSystemService, "write", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, FileSystemService, "write", data, callBack, cookie);
 }

-void tcftrk::TcfTrkDevice::sendFileSystemCloseCommand(const tcftrk::TcfTrkCallback &callBack,
+void Coda::CodaDevice::sendFileSystemCloseCommand(const Coda::CodaCallback &callBack,
                                                      const QByteArray &handle,
                                                      const QVariant &cookie)
 {
    QByteArray data;
    JsonInputStream str(data);
    str << handle;
-    sendTcfTrkMessage(MessageWithReply, FileSystemService, "close", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, FileSystemService, "close", data, callBack, cookie);
 }

-void tcftrk::TcfTrkDevice::sendSymbianInstallSilentInstallCommand(const tcftrk::TcfTrkCallback &callBack,
+void Coda::CodaDevice::sendSymbianInstallSilentInstallCommand(const Coda::CodaCallback &callBack,
                                                                  const QByteArray &file,
                                                                  const QByteArray &targetDrive,
                                                                  const QVariant &cookie)
@@ -1343,16 +1343,16 @@ void tcftrk::TcfTrkDevice::sendSymbianInstallSilentInstallCommand(const tcftrk::
    QByteArray data;
    JsonInputStream str(data);
    str << file << '\0' << targetDrive;
-    sendTcfTrkMessage(MessageWithReply, SymbianInstallService, "install", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, SymbianInstallService, "install", data, callBack, cookie);
 }

-void tcftrk::TcfTrkDevice::sendSymbianInstallUIInstallCommand(const tcftrk::TcfTrkCallback &callBack,
+void Coda::CodaDevice::sendSymbianInstallUIInstallCommand(const Coda::CodaCallback &callBack,
                                                              const QByteArray &file,
                                                              const QVariant &cookie)
 {
    QByteArray data;
    JsonInputStream str(data);
    str << file;
-    sendTcfTrkMessage(MessageWithReply, SymbianInstallService, "installWithUI", data, callBack, cookie);
+    sendCodaMessage(MessageWithReply, SymbianInstallService, "installWithUI", data, callBack, cookie);
 }
-} // namespace tcftrk
+} // namespace Coda
--- a/src/shared/symbianutils/tcftrkdevice.h
+++ b/src/shared/symbianutils/tcftrkdevice.h
@@ -31,11 +31,11 @@
 **
 **************************************************************************/

-#ifndef TCFTRKENGINE_H
-#define TCFTRKENGINE_H
+#ifndef CODAENGINE_H
+#define CODAENGINE_H

 #include "symbianutils_global.h"
-#include "tcftrkmessage.h"
+#include "Codamessage.h"
 #include "callback.h"
 #include "json.h"

@@ -51,9 +51,9 @@ class QIODevice;
 class QTextStream;
 QT_END_NAMESPACE

-namespace tcftrk {
+namespace Coda {

-struct TcfTrkDevicePrivate;
+struct CodaDevicePrivate;
 struct Breakpoint;

 /* Command error handling in TCF:
@@ -61,12 +61,12 @@ struct Breakpoint;
 *     nonstandard message (\3\2 error parameters) and closes the connection.
 * 2) Protocol errors: 'N' without error message is returned.
 * 3) Errors in command execution: 'R' with a TCF error hash is returned
- *    (see TcfTrkCommandError). */
+ *    (see CodaCommandError). */

 /* Error code return in 'R' reply to command
 * (see top of 'Services' documentation). */
-struct SYMBIANUTILS_EXPORT TcfTrkCommandError {
-    TcfTrkCommandError();
+struct SYMBIANUTILS_EXPORT CodaCommandError {
+    CodaCommandError();
    void clear();
    bool isError() const;
    operator bool() const { return isError(); }
@@ -83,17 +83,17 @@ struct SYMBIANUTILS_EXPORT TcfTrkCommandError {
 };

 /* Answer to a Tcf command passed to the callback. */
-struct SYMBIANUTILS_EXPORT TcfTrkCommandResult {
+struct SYMBIANUTILS_EXPORT CodaCommandResult {
    enum Type
    {
        SuccessReply,       // 'R' and no error -> all happy.
-        CommandErrorReply,  // 'R' with TcfTrkCommandError received
+        CommandErrorReply,  // 'R' with CodaCommandError received
        ProgressReply,      // 'P', progress indicator
        FailReply           // 'N' Protocol NAK, severe error
    };

-    explicit TcfTrkCommandResult(Type t = SuccessReply);
-    explicit TcfTrkCommandResult(char typeChar, Services service,
+    explicit CodaCommandResult(Type t = SuccessReply);
+    explicit CodaCommandResult(char typeChar, Services service,
                                 const QByteArray &request,
                                 const QVector<JsonValue> &values,
                                 const QVariant &cookie);
@@ -107,32 +107,32 @@ struct SYMBIANUTILS_EXPORT TcfTrkCommandResult {
    Type type;
    Services service;
    QByteArray request;
-    TcfTrkCommandError commandError;
+    CodaCommandError commandError;
    QVector<JsonValue> values;
    QVariant cookie;
 };

 // Response to stat/fstat
-struct SYMBIANUTILS_EXPORT TcfTrkStatResponse
+struct SYMBIANUTILS_EXPORT CodaStatResponse
 {
-    TcfTrkStatResponse();
+    CodaStatResponse();

    quint64 size;
    QDateTime modTime;
    QDateTime accessTime;
 };

-typedef trk::Callback<const TcfTrkCommandResult &> TcfTrkCallback;
+typedef trk::Callback<const CodaCommandResult &> CodaCallback;

-/* TcfTrkDevice: TCF communication helper using an asynchronous QIODevice
+/* CodaDevice: TCF communication helper using an asynchronous QIODevice
 * implementing the TCF protocol according to:
 http://dev.eclipse.org/svnroot/dsdp/org.eclipse.tm.tcf/trunk/docs/TCF%20Specification.html
 http://dev.eclipse.org/svnroot/dsdp/org.eclipse.tm.tcf/trunk/docs/TCF%20Services.html
 * Commands can be sent along with callbacks that are passed a
- * TcfTrkCommandResult and an opaque QVariant cookie. In addition, events are emitted.
+ * CodaCommandResult and an opaque QVariant cookie. In addition, events are emitted.
 *
 * Note: As of 11.8.2010, TCF Trk 4.0.5 does not currently support 'Registers::getm'
- * (get multiple registers). So, TcfTrkDevice emulates it by sending a sequence of
+ * (get multiple registers). So, CodaDevice emulates it by sending a sequence of
 * single commands. As soon as 'Registers::getm' is natively supported, all code
 * related to 'FakeRegisterGetm' should be removed. The workaround requires that
 * the register name is known.
@@ -146,7 +146,7 @@ http://dev.eclipse.org/svnroot/dsdp/org.eclipse.tm.tcf/trunk/docs/TCF%20Services
 *     Receive Locator Hello Event from CODA -> Commands are accepted.
 */

-class SYMBIANUTILS_EXPORT TcfTrkDevice : public QObject
+class SYMBIANUTILS_EXPORT CodaDevice : public QObject
 {
    Q_PROPERTY(unsigned verbose READ verbose WRITE setVerbose)
    Q_PROPERTY(bool serialFrame READ serialFrame WRITE setSerialFrame)
@@ -172,8 +172,8 @@ public:

    typedef QSharedPointer<QIODevice> IODevicePtr;

-    explicit TcfTrkDevice(QObject *parent = 0);
-    virtual ~TcfTrkDevice();
+    explicit CodaDevice(QObject *parent = 0);
+    virtual ~CodaDevice();

    unsigned verbose() const;
    bool serialFrame() const;
@@ -193,18 +193,18 @@ public:
    void sendSerialPing(bool pingOnly = false);

    // Send with parameters from string (which may contain '\0').
-    void sendTcfTrkMessage(MessageType mt, Services service, const char *command,
+    void sendCodaMessage(MessageType mt, Services service, const char *command,
                           const char *commandParameters, int commandParametersLength,
-                           const TcfTrkCallback &callBack = TcfTrkCallback(),
+                           const CodaCallback &callBack = CodaCallback(),
                           const QVariant &cookie = QVariant());

-    void sendTcfTrkMessage(MessageType mt, Services service, const char *command,
+    void sendCodaMessage(MessageType mt, Services service, const char *command,
                           const QByteArray &commandParameters,
-                           const TcfTrkCallback &callBack = TcfTrkCallback(),
+                           const CodaCallback &callBack = CodaCallback(),
                           const QVariant &cookie = QVariant());

    // Convenience messages: Start a process
-    void sendProcessStartCommand(const TcfTrkCallback &callBack,
+    void sendProcessStartCommand(const CodaCallback &callBack,
                                 const QString &binary,
                                 unsigned uid,
                                 QStringList arguments = QStringList(),
@@ -214,11 +214,11 @@ public:
                                 const QVariant &cookie = QVariant());

    // Preferred over Processes:Terminate by TCF TRK.
-    void sendRunControlTerminateCommand(const TcfTrkCallback &callBack,
+    void sendRunControlTerminateCommand(const CodaCallback &callBack,
                                        const QByteArray &id,
                                        const QVariant &cookie = QVariant());

-    void sendProcessTerminateCommand(const TcfTrkCallback &callBack,
+    void sendProcessTerminateCommand(const CodaCallback &callBack,
                                     const QByteArray &id,
                                     const QVariant &cookie = QVariant());

@@ -229,12 +229,12 @@ public:
                                             const QStringList &additionalLibraries = QStringList(),
                                             const QVariant &cookie = QVariant());

-    void sendRunControlSuspendCommand(const TcfTrkCallback &callBack,
+    void sendRunControlSuspendCommand(const CodaCallback &callBack,
                                      const QByteArray &id,
                                      const QVariant &cookie = QVariant());

    // Resume / Step (see RunControlResumeMode).
-    void sendRunControlResumeCommand(const TcfTrkCallback &callBack,
+    void sendRunControlResumeCommand(const CodaCallback &callBack,
                                     const QByteArray &id,
                                     RunControlResumeMode mode,
                                     unsigned count /* = 1, currently ignored. */,
@@ -242,117 +242,117 @@ public:
                                     const QVariant &cookie = QVariant());

    // Convenience to resume a suspended process
-    void sendRunControlResumeCommand(const TcfTrkCallback &callBack,
+    void sendRunControlResumeCommand(const CodaCallback &callBack,
                                     const QByteArray &id,
                                     const QVariant &cookie = QVariant());

-    void sendBreakpointsAddCommand(const TcfTrkCallback &callBack,
+    void sendBreakpointsAddCommand(const CodaCallback &callBack,
                                   const Breakpoint &b,
                                   const QVariant &cookie = QVariant());

-    void sendBreakpointsRemoveCommand(const TcfTrkCallback &callBack,
+    void sendBreakpointsRemoveCommand(const CodaCallback &callBack,
                                      const QByteArray &id,
                                      const QVariant &cookie = QVariant());

-    void sendBreakpointsRemoveCommand(const TcfTrkCallback &callBack,
+    void sendBreakpointsRemoveCommand(const CodaCallback &callBack,
                                      const QVector<QByteArray> &id,
                                      const QVariant &cookie = QVariant());

-    void sendBreakpointsEnableCommand(const TcfTrkCallback &callBack,
+    void sendBreakpointsEnableCommand(const CodaCallback &callBack,
                                      const QByteArray &id,
                                      bool enable,
                                      const QVariant &cookie = QVariant());

-    void sendBreakpointsEnableCommand(const TcfTrkCallback &callBack,
+    void sendBreakpointsEnableCommand(const CodaCallback &callBack,
                                      const QVector<QByteArray> &id,
                                      bool enable,
                                      const QVariant &cookie = QVariant());


-    void sendMemoryGetCommand(const TcfTrkCallback &callBack,
+    void sendMemoryGetCommand(const CodaCallback &callBack,
                              const QByteArray &contextId,
                              quint64 start, quint64 size,
                              const QVariant &cookie = QVariant());

-    void sendMemorySetCommand(const TcfTrkCallback &callBack,
+    void sendMemorySetCommand(const CodaCallback &callBack,
                              const QByteArray &contextId,
                              quint64 start, const QByteArray& data,
                              const QVariant &cookie = QVariant());

    // Get register names (children of context).
    // It is possible to recurse from  thread id down to single registers.
-    void sendRegistersGetChildrenCommand(const TcfTrkCallback &callBack,
+    void sendRegistersGetChildrenCommand(const CodaCallback &callBack,
                                         const QByteArray &contextId,
                                         const QVariant &cookie = QVariant());

    // Register get
-    void sendRegistersGetCommand(const TcfTrkCallback &callBack,
+    void sendRegistersGetCommand(const CodaCallback &callBack,
                                 const QByteArray &contextId,
                                 QByteArray id,
                                 const QVariant &cookie);

-    void sendRegistersGetMCommand(const TcfTrkCallback &callBack,
+    void sendRegistersGetMCommand(const CodaCallback &callBack,
                                  const QByteArray &contextId,
                                  const QVector<QByteArray> &ids,
                                  const QVariant &cookie = QVariant());

    // Convenience to get a range of register "R0" .. "R<n>".
    // Cookie will be an int containing "start".
-    void sendRegistersGetMRangeCommand(const TcfTrkCallback &callBack,
+    void sendRegistersGetMRangeCommand(const CodaCallback &callBack,
                                 const QByteArray &contextId,
                                  unsigned start, unsigned count);

    // Set register
-    void sendRegistersSetCommand(const TcfTrkCallback &callBack,
+    void sendRegistersSetCommand(const CodaCallback &callBack,
                                 const QByteArray &contextId,
                                 QByteArray ids,
                                 const QByteArray &value, // binary value
                                 const QVariant &cookie = QVariant());
    // Set register
-    void sendRegistersSetCommand(const TcfTrkCallback &callBack,
+    void sendRegistersSetCommand(const CodaCallback &callBack,
                                 const QByteArray &contextId,
                                 unsigned registerNumber,
                                 const QByteArray &value, // binary value
                                 const QVariant &cookie = QVariant());

    // File System
-    void sendFileSystemOpenCommand(const TcfTrkCallback &callBack,
+    void sendFileSystemOpenCommand(const CodaCallback &callBack,
                                   const QByteArray &name,
                                   unsigned flags = FileSystem_TCF_O_READ,
                                   const QVariant &cookie = QVariant());

-    void sendFileSystemFstatCommand(const TcfTrkCallback &callBack,
+    void sendFileSystemFstatCommand(const CodaCallback &callBack,
                                   const QByteArray &handle,
                                   const QVariant &cookie = QVariant());

-    void sendFileSystemWriteCommand(const TcfTrkCallback &callBack,
+    void sendFileSystemWriteCommand(const CodaCallback &callBack,
                                    const QByteArray &handle,
                                    const QByteArray &data,
                                    unsigned offset = 0,
                                    const QVariant &cookie = QVariant());

-    void sendFileSystemCloseCommand(const TcfTrkCallback &callBack,
+    void sendFileSystemCloseCommand(const CodaCallback &callBack,
                                   const QByteArray &handle,
                                   const QVariant &cookie = QVariant());

    // Symbian Install
-    void sendSymbianInstallSilentInstallCommand(const TcfTrkCallback &callBack,
+    void sendSymbianInstallSilentInstallCommand(const CodaCallback &callBack,
                                                const QByteArray &file,
                                                const QByteArray &targetDrive,
                                                const QVariant &cookie = QVariant());

-    void sendSymbianInstallUIInstallCommand(const TcfTrkCallback &callBack,
+    void sendSymbianInstallUIInstallCommand(const CodaCallback &callBack,
                                            const QByteArray &file,
                                            const QVariant &cookie = QVariant());

-    void sendLoggingAddListenerCommand(const TcfTrkCallback &callBack,
+    void sendLoggingAddListenerCommand(const CodaCallback &callBack,
                                       const QVariant &cookie = QVariant());

    // SymbianOs Data
-    void sendSymbianOsDataGetThreadsCommand(const TcfTrkCallback &callBack,
+    void sendSymbianOsDataGetThreadsCommand(const CodaCallback &callBack,
                                            const QVariant &cookie = QVariant());

-    void sendSymbianOsDataFindProcessesCommand(const TcfTrkCallback &callBack,
+    void sendSymbianOsDataFindProcessesCommand(const CodaCallback &callBack,
                                                const QByteArray &processName,
                                                const QByteArray &uid,
                                                const QVariant &cookie = QVariant());
@@ -360,13 +360,13 @@ public:
    // Settings
    void sendSettingsEnableLogCommand();

-    static QByteArray parseMemoryGet(const TcfTrkCommandResult &r);
-    static QVector<QByteArray> parseRegisterGetChildren(const TcfTrkCommandResult &r);
-    static TcfTrkStatResponse parseStat(const TcfTrkCommandResult &r);
+    static QByteArray parseMemoryGet(const CodaCommandResult &r);
+    static QVector<QByteArray> parseRegisterGetChildren(const CodaCommandResult &r);
+    static CodaStatResponse parseStat(const CodaCommandResult &r);

 signals:
-    void genericTcfEvent(int service, const QByteArray &name, const QVector<tcftrk::JsonValue> &value);
-    void tcfEvent(const tcftrk::TcfTrkEvent &knownEvent);
+    void genericTcfEvent(int service, const QByteArray &name, const QVector<JsonValue> &value);
+    void tcfEvent(const Coda::CodaEvent &knownEvent);
    void serialPong(const QString &codaVersion);

    void logMessage(const QString &);
@@ -393,9 +393,9 @@ private:
    inline void processSerialMessage(const QByteArray &message);
    int parseTcfCommandReply(char type, const QVector<QByteArray> &tokens);
    int parseTcfEvent(const QVector<QByteArray> &tokens);
-    TcfTrkDevicePrivate *d;
+    CodaDevicePrivate *d;
 };

-} // namespace tcftrk
+} // namespace Coda

-#endif // TCFTRKENGINE_H
+#endif // CODAENGINE_H
--- a/src/shared/symbianutils/tcftrkmessage.cpp
+++ b/src/shared/symbianutils/tcftrkmessage.cpp
@@ -31,7 +31,7 @@
 **
 **************************************************************************/

-#include "tcftrkmessage.h"
+#include "codamessage.h"
 #include "json.h"

 #include <QtCore/QString>
@@ -43,7 +43,7 @@ static const char *serviceNamesC[] =
  "Registers", "Logging", "FileSystem", "SymbianInstall", "SymbianOSData",
  "UnknownService"};

-namespace tcftrk {
+namespace Coda {

 SYMBIANUTILS_EXPORT QString joinByteArrays(const QVector<QByteArray> &a, char sep)
 {
@@ -333,7 +333,7 @@ QString Breakpoint::toString() const
 JsonInputStream &operator<<(JsonInputStream &str, const Breakpoint &b)
 {
    if (b.contextIds.isEmpty())
-        qWarning("tcftrk::Breakpoint: No context ids specified");
+        qWarning("Coda::Breakpoint: No context ids specified");

    str << '{' << "ID" << ':' << QString::fromUtf8(b.id) << ','
        << "BreakpointType" << ':' << breakPointTypesC[b.type] << ','
@@ -348,27 +348,27 @@ JsonInputStream &operator<<(JsonInputStream &str, const Breakpoint &b)
 }

 // --- Events
-TcfTrkEvent::TcfTrkEvent(Type type) : m_type(type)
+CodaEvent::CodaEvent(Type type) : m_type(type)
 {
 }

-TcfTrkEvent::~TcfTrkEvent()
+CodaEvent::~CodaEvent()
 {
 }

-TcfTrkEvent::Type TcfTrkEvent::type() const
+CodaEvent::Type CodaEvent::type() const
 {
    return m_type;
 }

-QString TcfTrkEvent::toString() const
+QString CodaEvent::toString() const
 {
    return QString();
 }

 static const char sharedLibrarySuspendReasonC[] = "Shared Library";

-TcfTrkEvent *TcfTrkEvent::parseEvent(Services s, const QByteArray &nameBA, const QVector<JsonValue> &values)
+CodaEvent *CodaEvent::parseEvent(Services s, const QByteArray &nameBA, const QVector<JsonValue> &values)
 {
    switch (s) {
    case LocatorService:
@@ -376,7 +376,7 @@ TcfTrkEvent *TcfTrkEvent::parseEvent(Services s, const QByteArray &nameBA, const
            QStringList services;
            foreach (const JsonValue &jv, values.front().children())
                services.push_back(QString::fromUtf8(jv.data()));
-            return new TcfTrkLocatorHelloEvent(services);
+            return new CodaLocatorHelloEvent(services);
        }
        break;
    case RunControlService:
@@ -393,27 +393,27 @@ TcfTrkEvent *TcfTrkEvent::parseEvent(Services s, const QByteArray &nameBA, const
                ModuleLoadEventInfo info;
                if (!info.parse(values.at(3)))
                    return 0;
-                return new TcfTrkRunControlModuleLoadContextSuspendedEvent(idBA, reasonBA, pc, info);
+                return new CodaRunControlModuleLoadContextSuspendedEvent(idBA, reasonBA, pc, info);
            } else {
                // hash containing a 'message'-key with a verbose crash message.
                if (values.at(3).type() == JsonValue::Object && values.at(3).childCount()
                    && values.at(3).children().at(0).type() == JsonValue::String)
                    messageBA = values.at(3).children().at(0).data();
            }
-            return new TcfTrkRunControlContextSuspendedEvent(idBA, reasonBA, messageBA, pc);
+            return new CodaRunControlContextSuspendedEvent(idBA, reasonBA, messageBA, pc);
        } // "contextSuspended"
        if (nameBA == "contextAdded")
-            return TcfTrkRunControlContextAddedEvent::parseEvent(values);
+            return CodaRunControlContextAddedEvent::parseEvent(values);
        if (nameBA == "contextRemoved" && values.front().type() == JsonValue::Array) {
            QVector<QByteArray> ids;
            foreach(const JsonValue &c, values.front().children())
                ids.push_back(c.data());
-            return new TcfTrkRunControlContextRemovedEvent(ids);
+            return new CodaRunControlContextRemovedEvent(ids);
        }
        break;
    case LoggingService:
        if ((nameBA == "writeln" || nameBA == "write" /*not yet used*/) && values.size() >= 2)
-            return new TcfTrkLoggingWriteEvent(values.at(0).data(), values.at(1).data());
+            return new CodaLoggingWriteEvent(values.at(0).data(), values.at(1).data());
        break;
   default:
        break;
@@ -421,26 +421,26 @@ TcfTrkEvent *TcfTrkEvent::parseEvent(Services s, const QByteArray &nameBA, const
    return 0;
 }

-// -------------- TcfTrkServiceHelloEvent
-TcfTrkLocatorHelloEvent::TcfTrkLocatorHelloEvent(const QStringList &s) :
-    TcfTrkEvent(LocatorHello),
+// -------------- CodaServiceHelloEvent
+CodaLocatorHelloEvent::CodaLocatorHelloEvent(const QStringList &s) :
+    CodaEvent(LocatorHello),
    m_services(s)
 {
 }

-QString TcfTrkLocatorHelloEvent::toString() const
+QString CodaLocatorHelloEvent::toString() const
 {
    return QLatin1String("ServiceHello: ") + m_services.join(QLatin1String(", "));
 }

 // --------------  Logging event

-TcfTrkLoggingWriteEvent::TcfTrkLoggingWriteEvent(const QByteArray &console, const QByteArray &message) :
-    TcfTrkEvent(LoggingWriteEvent), m_console(console), m_message(message)
+CodaLoggingWriteEvent::CodaLoggingWriteEvent(const QByteArray &console, const QByteArray &message) :
+    CodaEvent(LoggingWriteEvent), m_console(console), m_message(message)
 {
 }

-QString TcfTrkLoggingWriteEvent::toString() const
+QString CodaLoggingWriteEvent::toString() const
 {
    QByteArray msgBA = m_console;
    msgBA += ": ";
@@ -448,31 +448,31 @@ QString TcfTrkLoggingWriteEvent::toString() const
    return QString::fromUtf8(msgBA);
 }

-// -------------- TcfTrkIdEvent
-TcfTrkIdEvent::TcfTrkIdEvent(Type t, const QByteArray &id) :
-   TcfTrkEvent(t), m_id(id)
+// -------------- CodaIdEvent
+CodaIdEvent::CodaIdEvent(Type t, const QByteArray &id) :
+   CodaEvent(t), m_id(id)
 {
 }

-// ---------- TcfTrkIdsEvent
-TcfTrkIdsEvent::TcfTrkIdsEvent(Type t, const QVector<QByteArray> &ids) :
-    TcfTrkEvent(t), m_ids(ids)
+// ---------- CodaIdsEvent
+CodaIdsEvent::CodaIdsEvent(Type t, const QVector<QByteArray> &ids) :
+    CodaEvent(t), m_ids(ids)
 {
 }

-QString TcfTrkIdsEvent::joinedIdString(const char sep) const
+QString CodaIdsEvent::joinedIdString(const char sep) const
 {
    return joinByteArrays(m_ids, sep);
 }

-//  ---------------- TcfTrkRunControlContextAddedEvent
-TcfTrkRunControlContextAddedEvent::TcfTrkRunControlContextAddedEvent(const RunControlContexts &c) :
-        TcfTrkEvent(RunControlContextAdded), m_contexts(c)
+//  ---------------- CodaRunControlContextAddedEvent
+CodaRunControlContextAddedEvent::CodaRunControlContextAddedEvent(const RunControlContexts &c) :
+        CodaEvent(RunControlContextAdded), m_contexts(c)
 {
 }

-TcfTrkRunControlContextAddedEvent
-        *TcfTrkRunControlContextAddedEvent::parseEvent(const QVector<JsonValue> &values)
+CodaRunControlContextAddedEvent
+        *CodaRunControlContextAddedEvent::parseEvent(const QVector<JsonValue> &values)
 {
    // Parse array of contexts
    if (values.size() < 1 || values.front().type() != JsonValue::Array)
@@ -484,10 +484,10 @@ TcfTrkRunControlContextAddedEvent
        if (context.parse(v))
            contexts.push_back(context);
    }
-    return new TcfTrkRunControlContextAddedEvent(contexts);
+    return new CodaRunControlContextAddedEvent(contexts);
 }

-QString TcfTrkRunControlContextAddedEvent::toString() const
+QString CodaRunControlContextAddedEvent::toString() const
 {
    QString rc;
    QTextStream str(&rc);
@@ -501,35 +501,35 @@ QString TcfTrkRunControlContextAddedEvent::toString() const
    return rc;
 }

-// --------------- TcfTrkRunControlContextRemovedEvent
-TcfTrkRunControlContextRemovedEvent::TcfTrkRunControlContextRemovedEvent(const QVector<QByteArray> &ids) :
-        TcfTrkIdsEvent(RunControlContextRemoved, ids)
+// --------------- CodaRunControlContextRemovedEvent
+CodaRunControlContextRemovedEvent::CodaRunControlContextRemovedEvent(const QVector<QByteArray> &ids) :
+        CodaIdsEvent(RunControlContextRemoved, ids)
 {
 }

-QString TcfTrkRunControlContextRemovedEvent::toString() const
+QString CodaRunControlContextRemovedEvent::toString() const
 {
    return QLatin1String("RunControl: Removed contexts '") + joinedIdString() + ("'.");
 }

-// --------------- TcfTrkRunControlContextSuspendedEvent
-TcfTrkRunControlContextSuspendedEvent::TcfTrkRunControlContextSuspendedEvent(const QByteArray &id,
+// --------------- CodaRunControlContextSuspendedEvent
+CodaRunControlContextSuspendedEvent::CodaRunControlContextSuspendedEvent(const QByteArray &id,
                                                                             const QByteArray &reason,
                                                                             const QByteArray &message,
                                                                             quint64 pc) :
-        TcfTrkIdEvent(RunControlSuspended, id), m_pc(pc), m_reason(reason), m_message(message)
+        CodaIdEvent(RunControlSuspended, id), m_pc(pc), m_reason(reason), m_message(message)
 {
 }

-TcfTrkRunControlContextSuspendedEvent::TcfTrkRunControlContextSuspendedEvent(Type t,
+CodaRunControlContextSuspendedEvent::CodaRunControlContextSuspendedEvent(Type t,
                                                                             const QByteArray &id,
                                                                             const QByteArray &reason,
                                                                             quint64 pc) :
-        TcfTrkIdEvent(t, id), m_pc(pc), m_reason(reason)
+        CodaIdEvent(t, id), m_pc(pc), m_reason(reason)
 {
 }

-void TcfTrkRunControlContextSuspendedEvent::format(QTextStream &str) const
+void CodaRunControlContextSuspendedEvent::format(QTextStream &str) const
 {
    str.setIntegerBase(16);
    str << "RunControl: '" << idString()  << "' suspended at 0x"
@@ -539,7 +539,7 @@ void TcfTrkRunControlContextSuspendedEvent::format(QTextStream &str) const
        str << " (" <<m_message << ')';
 }

-QString TcfTrkRunControlContextSuspendedEvent::toString() const
+QString CodaRunControlContextSuspendedEvent::toString() const
 {
    QString rc;
    QTextStream str(&rc);
@@ -547,7 +547,7 @@ QString TcfTrkRunControlContextSuspendedEvent::toString() const
    return rc;
 }

-TcfTrkRunControlContextSuspendedEvent::Reason TcfTrkRunControlContextSuspendedEvent::reason() const
+CodaRunControlContextSuspendedEvent::Reason CodaRunControlContextSuspendedEvent::reason() const
 {
    if (m_reason == sharedLibrarySuspendReasonC)
        return ModuleLoad;
@@ -559,24 +559,24 @@ TcfTrkRunControlContextSuspendedEvent::Reason TcfTrkRunControlContextSuspendedEv
    return Other;
 }

-TcfTrkRunControlModuleLoadContextSuspendedEvent::TcfTrkRunControlModuleLoadContextSuspendedEvent(const QByteArray &id,
+CodaRunControlModuleLoadContextSuspendedEvent::CodaRunControlModuleLoadContextSuspendedEvent(const QByteArray &id,
                                                                                                 const QByteArray &reason,
                                                                                                 quint64 pc,
                                                                                                 const ModuleLoadEventInfo &mi) :
-    TcfTrkRunControlContextSuspendedEvent(RunControlModuleLoadSuspended, id, reason, pc),
+    CodaRunControlContextSuspendedEvent(RunControlModuleLoadSuspended, id, reason, pc),
    m_mi(mi)
 {
 }

-QString TcfTrkRunControlModuleLoadContextSuspendedEvent::toString() const
+QString CodaRunControlModuleLoadContextSuspendedEvent::toString() const
 {
    QString rc;
    QTextStream str(&rc);
-    TcfTrkRunControlContextSuspendedEvent::format(str);
+    CodaRunControlContextSuspendedEvent::format(str);
    str <<  ' ';
    m_mi.format(str);
    return rc;
 }


-} // namespace tcftrk
+} // namespace Coda
--- a/src/shared/symbianutils/tcftrkmessage.h
+++ b/src/shared/symbianutils/tcftrkmessage.h
@@ -43,7 +43,7 @@ QT_BEGIN_NAMESPACE
 class QTextStream;
 QT_END_NAMESPACE

-namespace tcftrk {
+namespace Coda {

 class JsonValue;
 class JsonInputStream;
@@ -133,7 +133,7 @@ struct SYMBIANUTILS_EXPORT ModuleLoadEventInfo {
    bool requireResume;
 };

-// Breakpoint as supported by TcfTrk source June 2010
+// Breakpoint as supported by Coda source June 2010
 // TODO: Add watchpoints,etc once they are implemented
 struct SYMBIANUTILS_EXPORT Breakpoint {
    enum Type { Software, Hardware, Auto };
@@ -157,8 +157,8 @@ struct SYMBIANUTILS_EXPORT Breakpoint {
 SYMBIANUTILS_EXPORT JsonInputStream &operator<<(JsonInputStream &str, const Breakpoint &b);

 // Event hierarchy
-class SYMBIANUTILS_EXPORT TcfTrkEvent {
-    Q_DISABLE_COPY(TcfTrkEvent)
+class SYMBIANUTILS_EXPORT CodaEvent {
+    Q_DISABLE_COPY(CodaEvent)
 public:
    enum Type { None,
                LocatorHello,
@@ -171,24 +171,24 @@ public:
                LoggingWriteEvent // Non-standard
              };

-    virtual ~TcfTrkEvent();
+    virtual ~CodaEvent();

    Type type() const;
    virtual QString toString() const;

-    static TcfTrkEvent *parseEvent(Services s, const QByteArray &name, const QVector<JsonValue> &val);
+    static CodaEvent *parseEvent(Services s, const QByteArray &name, const QVector<JsonValue> &val);

 protected:
-    explicit TcfTrkEvent(Type type = None);
+    explicit CodaEvent(Type type = None);

 private:
    const Type m_type;
 };

 // ServiceHello
-class SYMBIANUTILS_EXPORT TcfTrkLocatorHelloEvent : public TcfTrkEvent {
+class SYMBIANUTILS_EXPORT CodaLocatorHelloEvent : public CodaEvent {
 public:
-    explicit TcfTrkLocatorHelloEvent(const QStringList &);
+    explicit CodaLocatorHelloEvent(const QStringList &);

    const QStringList &services() { return m_services; }
    virtual QString toString() const;
@@ -198,9 +198,9 @@ private:
 };

 // Logging event (non-standard, trk specific)
-class SYMBIANUTILS_EXPORT TcfTrkLoggingWriteEvent : public TcfTrkEvent {
+class SYMBIANUTILS_EXPORT CodaLoggingWriteEvent : public CodaEvent {
 public:
-    explicit TcfTrkLoggingWriteEvent(const QByteArray &console, const QByteArray &message);
+    explicit CodaLoggingWriteEvent(const QByteArray &console, const QByteArray &message);

    QByteArray message() const { return m_message; }
    QByteArray console() const { return m_console; }
@@ -214,9 +214,9 @@ private:

 // Base for events that just have one id as parameter
 // (simple suspend)
-class SYMBIANUTILS_EXPORT TcfTrkIdEvent : public TcfTrkEvent {
+class SYMBIANUTILS_EXPORT CodaIdEvent : public CodaEvent {
 protected:
-    explicit TcfTrkIdEvent(Type t, const QByteArray &id);
+    explicit CodaIdEvent(Type t, const QByteArray &id);
 public:
    QByteArray id() const { return m_id; }
    QString idString() const { return QString::fromUtf8(m_id); }
@@ -227,9 +227,9 @@ private:

 // Base for events that just have some ids as parameter
 // (context removed)
-class SYMBIANUTILS_EXPORT TcfTrkIdsEvent : public TcfTrkEvent {
+class SYMBIANUTILS_EXPORT CodaIdsEvent : public CodaEvent {
 protected:
-    explicit TcfTrkIdsEvent(Type t, const QVector<QByteArray> &ids);
+    explicit CodaIdsEvent(Type t, const QVector<QByteArray> &ids);

 public:
    QVector<QByteArray> ids() const { return m_ids; }
@@ -240,34 +240,34 @@ private:
 };

 // RunControlContextAdded
-class SYMBIANUTILS_EXPORT TcfTrkRunControlContextAddedEvent : public TcfTrkEvent {
+class SYMBIANUTILS_EXPORT CodaRunControlContextAddedEvent : public CodaEvent {
 public:
    typedef QVector<RunControlContext> RunControlContexts;

-    explicit TcfTrkRunControlContextAddedEvent(const RunControlContexts &c);
+    explicit CodaRunControlContextAddedEvent(const RunControlContexts &c);

    const RunControlContexts &contexts() const { return m_contexts; }
    virtual QString toString() const;

-    static TcfTrkRunControlContextAddedEvent *parseEvent(const QVector<JsonValue> &val);
+    static CodaRunControlContextAddedEvent *parseEvent(const QVector<JsonValue> &val);

 private:
    const RunControlContexts m_contexts;
 };

 // RunControlContextRemoved
-class SYMBIANUTILS_EXPORT TcfTrkRunControlContextRemovedEvent : public TcfTrkIdsEvent {
+class SYMBIANUTILS_EXPORT CodaRunControlContextRemovedEvent : public CodaIdsEvent {
 public:
-    explicit TcfTrkRunControlContextRemovedEvent(const QVector<QByteArray> &id);
+    explicit CodaRunControlContextRemovedEvent(const QVector<QByteArray> &id);
    virtual QString toString() const;
 };

 // Simple RunControlContextSuspended (process/thread)
-class SYMBIANUTILS_EXPORT TcfTrkRunControlContextSuspendedEvent : public TcfTrkIdEvent {
+class SYMBIANUTILS_EXPORT CodaRunControlContextSuspendedEvent : public CodaIdEvent {
 public:
    enum Reason  { BreakPoint, ModuleLoad, Crash, Other } ;

-    explicit TcfTrkRunControlContextSuspendedEvent(const QByteArray &id,
+    explicit CodaRunControlContextSuspendedEvent(const QByteArray &id,
                                                   const QByteArray &reason,
                                                   const QByteArray &message,
                                                   quint64 pc = 0);
@@ -279,7 +279,7 @@ public:
    QByteArray message() const { return m_message; }

 protected:
-    explicit TcfTrkRunControlContextSuspendedEvent(Type t,
+    explicit CodaRunControlContextSuspendedEvent(Type t,
                                                   const QByteArray &id,
                                                   const QByteArray &reason,
                                                   quint64 pc = 0);
@@ -292,9 +292,9 @@ private:
 };

 // RunControlContextSuspended due to module load
-class SYMBIANUTILS_EXPORT TcfTrkRunControlModuleLoadContextSuspendedEvent : public TcfTrkRunControlContextSuspendedEvent {
+class SYMBIANUTILS_EXPORT CodaRunControlModuleLoadContextSuspendedEvent : public CodaRunControlContextSuspendedEvent {
 public:
-    explicit TcfTrkRunControlModuleLoadContextSuspendedEvent(const QByteArray &id,
+    explicit CodaRunControlModuleLoadContextSuspendedEvent(const QByteArray &id,
                                                             const QByteArray &reason,
                                                             quint64 pc,
                                                             const ModuleLoadEventInfo &mi);
@@ -306,5 +306,5 @@ private:
    const ModuleLoadEventInfo m_mi;
 };

-} // namespace tcftrk
+} // namespace Coda
 #endif // TRCFTRKMESSAGE_H
--- a/src/shared/symbianutils/json.cpp
+++ b/src/shared/symbianutils/json.cpp
@@ -51,7 +51,7 @@
 #define JDEBUG(s)
 #endif

-namespace tcftrk {
+namespace Coda {

 static void skipSpaces(const char *&from, const char *to)
 {
@@ -497,5 +497,5 @@ JsonInputStream &JsonInputStream::operator<<(bool b)
    return *this;
 }

-} // namespace tcftrk
+} // namespace Coda

--- a/src/shared/symbianutils/json.h
+++ b/src/shared/symbianutils/json.h
@@ -40,7 +40,7 @@
 #include <QtCore/QStringList>
 #include <QtCore/QVector>

-namespace tcftrk {
+namespace Coda {

 class SYMBIANUTILS_EXPORT JsonValue
 {
@@ -136,6 +136,6 @@ private:
    QByteArray &m_target;
 };

-} // namespace tcftrk
+} // namespace Coda

 #endif // SYMBIANUTILS_JSON_H
--- a/src/shared/symbianutils/symbianutils.pri
+++ b/src/shared/symbianutils/symbianutils.pri
@@ -12,8 +12,8 @@ HEADERS += $$PWD/symbianutils_global.h \
    $$PWD/bluetoothlistener.h \
    $$PWD/communicationstarter.h \
    $$PWD/symbiandevicemanager.h \
-    $$PWD/tcftrkdevice.h \
-    $$PWD/tcftrkmessage.h \
+    $$PWD/codadevice.h \
+    $$PWD/codamessage.h \
    $$PWD/json.h \
 	$$PWD/virtualserialdevice.h

@@ -23,8 +23,8 @@ SOURCES += $$PWD/trkutils.cpp \
    $$PWD/bluetoothlistener.cpp \
    $$PWD/communicationstarter.cpp \
    $$PWD/symbiandevicemanager.cpp \
-    $$PWD/tcftrkdevice.cpp \
-    $$PWD/tcftrkmessage.cpp \
+    $$PWD/codadevice.cpp \
+    $$PWD/codamessage.cpp \
    $$PWD/json.cpp \
    $$PWD/virtualserialdevice.cpp