cxTrackingServiceProxy.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/

#include "cxTrackingServiceProxy.h"

#include <boost/bind.hpp>
#include <ctkPluginContext.h>
#include "cxNullDeleter.h"


namespace cx
{

TrackingServicePtr TrackingServiceProxy::create(ctkPluginContext *pluginContext)
{
        return TrackingServicePtr(new TrackingServiceProxy(pluginContext));
}

TrackingServiceProxy::TrackingServiceProxy(ctkPluginContext *pluginContext) :
        mPluginContext(pluginContext),
        mTrackingService(TrackingService::getNullObject())
{
        this->initServiceListener();
}

void TrackingServiceProxy::initServiceListener()
{
        mServiceListener.reset(new ServiceTrackerListener<TrackingService>(
                                                                 mPluginContext,
                                                                 boost::bind(&TrackingServiceProxy::onServiceAdded, this, _1),
                                                                 boost::function<void (TrackingService*)>(),
                                                                 boost::bind(&TrackingServiceProxy::onServiceRemoved, this, _1)
                                                                 ));
        mServiceListener->open();
}
void TrackingServiceProxy::onServiceAdded(TrackingService* service)
{
        mTrackingService.reset(service, null_deleter());

        connect(mTrackingService.get(), &TrackingService::stateChanged, this, &TrackingService::stateChanged);
        connect(mTrackingService.get(), &TrackingService::activeToolChanged, this, &TrackingService::activeToolChanged);

        emit stateChanged();
        emit activeToolChanged(mTrackingService->getActiveTool()->getUid());
}

void TrackingServiceProxy::onServiceRemoved(TrackingService *service)
{
        disconnect(mTrackingService.get(), &TrackingService::stateChanged, this, &TrackingService::stateChanged);
        disconnect(mTrackingService.get(), &TrackingService::activeToolChanged, this, &TrackingService::activeToolChanged);

        mTrackingService = TrackingService::getNullObject();

        emit stateChanged();
        emit activeToolChanged("");
}

bool TrackingServiceProxy::isNull()
{
        return mTrackingService->isNull();
}

Tool::State TrackingServiceProxy::getState() const
{
        return mTrackingService->getState();
}

void TrackingServiceProxy::setState(const Tool::State val)
{
        mTrackingService->setState(val);
}

ToolPtr TrackingServiceProxy::getTool(const QString& uid)
{
        return mTrackingService->getTool(uid);
}

ToolPtr TrackingServiceProxy::getActiveTool()
{
        return mTrackingService->getActiveTool();
}

void TrackingServiceProxy::setActiveTool(const QString& uid)
{
        mTrackingService->setActiveTool(uid);
}

void TrackingServiceProxy::clearActiveTool()
{
        mTrackingService->clearActiveTool();
}

ToolPtr TrackingServiceProxy::getFirstProbe()
{
        return mTrackingService->getFirstProbe();
}

ToolPtr TrackingServiceProxy::getReferenceTool() const
{
        return mTrackingService->getReferenceTool();
}

ToolPtr TrackingServiceProxy::getManualTool()
{
        return mTrackingService->getManualTool();
}

TrackingService::ToolMap TrackingServiceProxy::getTools()
{
        return mTrackingService->getTools();
}

bool TrackingServiceProxy::isPlaybackMode() const
{
        return mTrackingService->isPlaybackMode();
}

void TrackingServiceProxy::setPlaybackMode(PlaybackTimePtr controller)
{
        mTrackingService->setPlaybackMode(controller);
}

SessionToolHistoryMap TrackingServiceProxy::getSessionHistory(double startTime, double stopTime)
{
        return mTrackingService->getSessionHistory(startTime, stopTime);
}

void TrackingServiceProxy::runDummyTool(DummyToolPtr tool)
{
        mTrackingService->runDummyTool(tool);
}

std::vector<TrackerConfigurationPtr> TrackingServiceProxy::getConfigurations()
{
        return mTrackingService->getConfigurations();
}

/*TrackerConfigurationPtr TrackingServiceProxy::getConfiguration(QString trackingSystemImplementation)
{
        return mTrackingService->getConfiguration(trackingSystemImplementation);
}*/

TrackerConfigurationPtr TrackingServiceProxy::getConfiguration()
{
        return mTrackingService->getConfiguration();
}

void TrackingServiceProxy::setCurrentTrackingSystemImplementation(QString trackingSystemImplementation)
{
        mTrackingService->setCurrentTrackingSystemImplementation(trackingSystemImplementation);
}

QString TrackingServiceProxy::getCurrentTrackingSystemImplementation()
{
        return mTrackingService->getCurrentTrackingSystemImplementation();
}

void TrackingServiceProxy::installTrackingSystem(TrackingSystemServicePtr system)
{
        mTrackingService->installTrackingSystem(system);
}

void TrackingServiceProxy::unInstallTrackingSystem(TrackingSystemServicePtr system)
{
        mTrackingService->unInstallTrackingSystem(system);
}

std::vector<TrackingSystemServicePtr> TrackingServiceProxy::getTrackingSystems()
{
        return mTrackingService->getTrackingSystems();
}

void TrackingServiceProxy::resetTimeSynchronization()
{
        return mTrackingService->resetTimeSynchronization();
}

} //cx