diff --git a/Modules/OpenIGTLink/mitkIGTLDevice.cpp b/Modules/OpenIGTLink/mitkIGTLDevice.cpp
index e8e38e7119..ed9c901106 100644
--- a/Modules/OpenIGTLink/mitkIGTLDevice.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLDevice.cpp
@@ -1,562 +1,563 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkIGTLDevice.h"
//#include "mitkIGTException.h"
//#include "mitkIGTTimeStamp.h"
#include <itkMutexLockHolder.h>
#include <itksys/SystemTools.hxx>
#include <cstring>
#include <igtlTransformMessage.h>
#include <mitkIGTLMessageCommon.h>
#include <igtl_status.h>
//remove later
#include <igtlTrackingDataMessage.h>
//TODO: Which timeout is acceptable and also needed to transmit image data? Is there a maximum data limit?
static const int SOCKET_SEND_RECEIVE_TIMEOUT_MSEC = 100;
typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
mitk::IGTLDevice::IGTLDevice(bool ReadFully) :
// m_Data(mitk::DeviceDataUnspecified),
m_State(mitk::IGTLDevice::Setup),
m_Name("Unspecified Device"),
m_StopCommunication(false),
+m_LogMessages(false),
m_Hostname("127.0.0.1"),
m_PortNumber(-1),
m_MultiThreader(nullptr), m_SendThreadID(0), m_ReceiveThreadID(0), m_ConnectThreadID(0)
{
m_ReadFully = ReadFully;
m_StopCommunicationMutex = itk::FastMutexLock::New();
m_StateMutex = itk::FastMutexLock::New();
// m_LatestMessageMutex = itk::FastMutexLock::New();
m_SendingFinishedMutex = itk::FastMutexLock::New();
m_ReceivingFinishedMutex = itk::FastMutexLock::New();
m_ConnectingFinishedMutex = itk::FastMutexLock::New();
// execution rights are owned by the application thread at the beginning
m_SendingFinishedMutex->Lock();
m_ReceivingFinishedMutex->Lock();
m_ConnectingFinishedMutex->Lock();
m_MultiThreader = itk::MultiThreader::New();
// m_Data = mitk::DeviceDataUnspecified;
// m_LatestMessage = igtl::MessageBase::New();
m_MessageFactory = mitk::IGTLMessageFactory::New();
m_MessageQueue = mitk::IGTLMessageQueue::New();
}
mitk::IGTLDevice::~IGTLDevice()
{
/* stop communication and disconnect from igtl device */
if (GetState() == Running)
{
this->StopCommunication();
this->CloseConnection();
}
else if (GetState() == Ready)
{
this->CloseConnection();
}
/* cleanup tracking thread */
if (m_MultiThreader.IsNotNull())
{
if ((m_SendThreadID != 0))
{
m_MultiThreader->TerminateThread(m_SendThreadID);
}
if ((m_ReceiveThreadID != 0))
{
m_MultiThreader->TerminateThread(m_ReceiveThreadID);
}
if ((m_ConnectThreadID != 0))
{
m_MultiThreader->TerminateThread(m_ConnectThreadID);
}
}
m_MultiThreader = nullptr;
}
mitk::IGTLDevice::IGTLDeviceState mitk::IGTLDevice::GetState() const
{
MutexLockHolder lock(*m_StateMutex);
return m_State;
}
void mitk::IGTLDevice::SetState(IGTLDeviceState state)
{
itkDebugMacro("setting m_State to " << state);
m_StateMutex->Lock();
// MutexLockHolder lock(*m_StateMutex); // lock and unlock the mutex
if (m_State == state)
{
m_StateMutex->Unlock();
return;
}
m_State = state;
m_StateMutex->Unlock();
this->Modified();
}
bool mitk::IGTLDevice::TestConnection()
{
return true;
}
unsigned int mitk::IGTLDevice::ReceivePrivate(igtl::Socket* socket)
{
// Create a message buffer to receive header
igtl::MessageHeader::Pointer headerMsg;
headerMsg = igtl::MessageHeader::New();
// Initialize receive buffer
headerMsg->InitPack();
// Receive generic header from the socket
int r =
socket->Receive(headerMsg->GetPackPointer(), headerMsg->GetPackSize(), 0);
//MITK_INFO << "Server received r = " << r;
//MITK_INFO << "Received r = " << r;
if (r == 0) //connection error
{
// an error was received, therefore the communication with this socket
// must be stoppedy
return IGTL_STATUS_NOT_PRESENT;
}
else if (r == -1) //timeout
{
// a timeout was received, this is no error state, thus, do nothing
return IGTL_STATUS_TIME_OUT;
}
else if (r == headerMsg->GetPackSize())
{
// Deserialize the header and check the CRC
// ERROR HERE: This probably means the header data is corrupted...
int crcCheck = headerMsg->Unpack(1);
if (crcCheck & igtl::MessageHeader::UNPACK_HEADER)
{
// Allocate a time stamp
igtl::TimeStamp::Pointer ts;
ts = igtl::TimeStamp::New();
// Get time stamp
igtlUint32 sec;
igtlUint32 nanosec;
headerMsg->GetTimeStamp(ts);
ts->GetTimeStamp(&sec, &nanosec);
// std::cerr << "Time stamp: "
// << sec << "."
// << nanosec << std::endl;
// std::cerr << "Dev type and name: " << headerMsg->GetDeviceType() << " "
// << headerMsg->GetDeviceName() << std::endl;
// headerMsg->Print(std::cout);
//check the type of the received message
//if it is a GET_, STP_ or RTS_ command push it into the command queue
//otherwise continue reading the whole message from the socket
const char* curDevType = headerMsg->GetDeviceType();
if (std::strstr(curDevType, "GET_") != nullptr ||
std::strstr(curDevType, "STP_") != nullptr ||
std::strstr(curDevType, "RTS_") != nullptr)
{
this->m_MessageQueue->PushCommandMessage(headerMsg);
this->InvokeEvent(CommandReceivedEvent());
return IGTL_STATUS_OK;
}
//Create a message according to the header message
igtl::MessageBase::Pointer curMessage;
curMessage = m_MessageFactory->CreateInstance(headerMsg);
//check if the curMessage is created properly, if not the message type is
//not supported and the message has to be skipped
if (curMessage.IsNull())
{
socket->Skip(headerMsg->GetBodySizeToRead(), 0);
// MITK_ERROR("IGTLDevice") << "The received type is not supported. Please "
// "add it to the message factory.";
return IGTL_STATUS_NOT_FOUND;
}
//insert the header to the message and allocate the pack
curMessage->SetMessageHeader(headerMsg);
curMessage->AllocatePack();
// Receive transform data from the socket
int receiveCheck = 0;
receiveCheck = socket->Receive(curMessage->GetPackBodyPointer(),
curMessage->GetPackBodySize(), m_ReadFully);
if (receiveCheck > 0)
{
int c = curMessage->Unpack(1);
if (!(c & igtl::MessageHeader::UNPACK_BODY))
{
return IGTL_STATUS_CHECKSUM_ERROR;
}
//check the type of the received message
//if it is a command push it into the command queue
//otherwise into the normal receive queue
//STP_ commands are handled here because they implemented additional
//member variables that are not stored in the header message
if (std::strstr(curDevType, "STT_") != nullptr)
{
this->m_MessageQueue->PushCommandMessage(curMessage);
this->InvokeEvent(CommandReceivedEvent());
}
else
{
if(m_LogMessages)
MITK_INFO << "Received Message: " << mitk::IGTLMessage::New(curMessage)->ToString();
this->m_MessageQueue->PushMessage(curMessage);
this->InvokeEvent(MessageReceivedEvent());
}
return IGTL_STATUS_OK;
}
else
{
MITK_WARN("IGTLDevice") << "Received a valid header but could not "
<< "read the whole message.";
return IGTL_STATUS_UNKNOWN_ERROR;
}
}
else
{
//CRC check failed
MITK_WARN << "CRC Check failed";
return IGTL_STATUS_CHECKSUM_ERROR;
}
}
else
{
//Message size information and actual data size don't match.
//this state is not suppossed to be reached, return unknown error
MITK_WARN << "IGTL status unknown";
return IGTL_STATUS_UNKNOWN_ERROR;
}
}
void mitk::IGTLDevice::SendMessage(mitk::IGTLMessage::Pointer msg)
{
m_MessageQueue->PushSendMessage(msg);
}
unsigned int mitk::IGTLDevice::SendMessagePrivate(mitk::IGTLMessage::Pointer msg,
igtl::Socket::Pointer socket)
{
//check the input message
if (msg.IsNull())
{
MITK_ERROR("IGTLDevice") << "Could not send message because message is not "
"valid. Please check.";
return false;
}
igtl::MessageBase* sendMessage = msg->GetMessage();
// Pack (serialize) and send
sendMessage->Pack();
int sendSuccess = socket->Send(sendMessage->GetPackPointer(), sendMessage->GetPackSize());
if (sendSuccess)
{
if (m_LogMessages) { MITK_INFO << "Send IGTL message: " << msg->ToString(); }
this->InvokeEvent(MessageSentEvent());
return IGTL_STATUS_OK;
}
else
{
return IGTL_STATUS_UNKNOWN_ERROR;
}
}
void mitk::IGTLDevice::RunCommunication(void (IGTLDevice::*ComFunction)(void), itk::FastMutexLock* mutex)
{
if (this->GetState() != Running)
return;
try
{
// keep lock until end of scope
MutexLockHolder communicationFinishedLockHolder(*mutex);
// Because m_StopCommunication is used by two threads, access has to be guarded
// by a mutex. To minimize thread locking, a local copy is used here
bool localStopCommunication;
// update the local copy of m_StopCommunication
this->m_StopCommunicationMutex->Lock();
localStopCommunication = this->m_StopCommunication;
this->m_StopCommunicationMutex->Unlock();
while ((this->GetState() == Running) && (localStopCommunication == false))
{
(this->*ComFunction)();
/* Update the local copy of m_StopCommunication */
this->m_StopCommunicationMutex->Lock();
localStopCommunication = m_StopCommunication;
this->m_StopCommunicationMutex->Unlock();
// time to relax, this sets the maximum ever possible framerate to 1000 Hz
itksys::SystemTools::Delay(1);
}
}
catch (...)
{
mutex->Unlock();
this->StopCommunication();
MITK_ERROR("IGTLDevice::RunCommunication") << "Error while communicating. Thread stopped.";
//mitkThrowException(mitk::IGTException) << "Error while communicating. Thread stopped.";
}
// StopCommunication was called, thus the mode should be changed back to Ready now
// that the tracking loop has ended.
//this->SetState(Ready); //this is done elsewhere
MITK_DEBUG("IGTLDevice::RunCommunication") << "Reached end of communication.";
// returning from this function (and ThreadStartCommunication())
// this will end the thread
return;
}
bool mitk::IGTLDevice::StartCommunication()
{
if (this->GetState() != Ready)
return false;
// go to mode Running
this->SetState(Running);
// set a timeout for the sending and receiving
this->m_Socket->SetTimeout(SOCKET_SEND_RECEIVE_TIMEOUT_MSEC);
// update the local copy of m_StopCommunication
this->m_StopCommunicationMutex->Lock();
this->m_StopCommunication = false;
this->m_StopCommunicationMutex->Unlock();
// transfer the execution rights to tracking thread
m_SendingFinishedMutex->Unlock();
m_ReceivingFinishedMutex->Unlock();
m_ConnectingFinishedMutex->Unlock();
// start new threads that execute the communication
m_SendThreadID =
m_MultiThreader->SpawnThread(this->ThreadStartSending, this);
m_ReceiveThreadID =
m_MultiThreader->SpawnThread(this->ThreadStartReceiving, this);
m_ConnectThreadID =
m_MultiThreader->SpawnThread(this->ThreadStartConnecting, this);
// mitk::IGTTimeStamp::GetInstance()->Start(this);
return true;
}
bool mitk::IGTLDevice::StopCommunication()
{
if (this->GetState() == Running) // Only if the object is in the correct state
{
// m_StopCommunication is used by two threads, so we have to ensure correct
// thread handling
m_StopCommunicationMutex->Lock();
m_StopCommunication = true;
m_StopCommunicationMutex->Unlock();
// we have to wait here that the other thread recognizes the STOP-command
// and executes it
m_SendingFinishedMutex->Lock();
m_ReceivingFinishedMutex->Lock();
m_ConnectingFinishedMutex->Lock();
// mitk::IGTTimeStamp::GetInstance()->Stop(this); // notify realtime clock
// StopCommunication was called, thus the mode should be changed back
// to Ready now that the tracking loop has ended.
this->SetState(Ready);
}
return true;
}
bool mitk::IGTLDevice::CloseConnection()
{
if (this->GetState() == Setup)
{
return true;
}
else if (this->GetState() == Running)
{
this->StopCommunication();
}
m_Socket->CloseSocket();
/* return to setup mode */
this->SetState(Setup);
// this->InvokeEvent(mitk::LostConnectionEvent());
return true;
}
bool mitk::IGTLDevice::SendRTSMessage(const char* type)
{
//construct the device type for the return message, it starts with RTS_ and
//continues with the requested type
std::string returnType("RTS_");
returnType.append(type);
//create a return message
igtl::MessageBase::Pointer rtsMsg =
this->m_MessageFactory->CreateInstance(returnType);
//if retMsg is nullptr there is no return message defined and thus it is not
//necessary to send one back
if (rtsMsg.IsNotNull())
{
this->SendMessage(mitk::IGTLMessage::New(rtsMsg));
return true;
}
else
{
return false;
}
}
void mitk::IGTLDevice::Connect()
{
MITK_DEBUG << "mitk::IGTLDevice::Connect();";
}
igtl::ImageMessage::Pointer mitk::IGTLDevice::GetNextImage2dMessage()
{
return this->m_MessageQueue->PullImage2dMessage();
}
igtl::ImageMessage::Pointer mitk::IGTLDevice::GetNextImage3dMessage()
{
return this->m_MessageQueue->PullImage3dMessage();
}
igtl::TransformMessage::Pointer mitk::IGTLDevice::GetNextTransformMessage()
{
return this->m_MessageQueue->PullTransformMessage();
}
igtl::TrackingDataMessage::Pointer mitk::IGTLDevice::GetNextTrackingDataMessage()
{
igtl::TrackingDataMessage::Pointer msg = this->m_MessageQueue->PullTrackingMessage();
return msg;
}
igtl::StringMessage::Pointer mitk::IGTLDevice::GetNextStringMessage()
{
return this->m_MessageQueue->PullStringMessage();
}
igtl::MessageBase::Pointer mitk::IGTLDevice::GetNextMiscMessage()
{
return this->m_MessageQueue->PullMiscMessage();
}
igtl::MessageBase::Pointer mitk::IGTLDevice::GetNextCommand()
{
return m_MessageQueue->PullCommandMessage();
}
void mitk::IGTLDevice::EnableNoBufferingMode(bool enable)
{
m_MessageQueue->EnableNoBufferingMode(enable);
}
void mitk::IGTLDevice::EnableNoBufferingMode(
mitk::IGTLMessageQueue::Pointer queue,
bool enable)
{
queue->EnableNoBufferingMode(enable);
}
ITK_THREAD_RETURN_TYPE mitk::IGTLDevice::ThreadStartSending(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo =
(struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
IGTLDevice *igtlDevice = (IGTLDevice*)pInfo->UserData;
if (igtlDevice != nullptr)
{
igtlDevice->RunCommunication(&mitk::IGTLDevice::Send, igtlDevice->m_SendingFinishedMutex);
}
igtlDevice->m_SendThreadID = 0; // erase thread id because thread will end.
return ITK_THREAD_RETURN_VALUE;
}
ITK_THREAD_RETURN_TYPE mitk::IGTLDevice::ThreadStartReceiving(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo =
(struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
IGTLDevice *igtlDevice = (IGTLDevice*)pInfo->UserData;
if (igtlDevice != nullptr)
{
igtlDevice->RunCommunication(&mitk::IGTLDevice::Receive,
igtlDevice->m_ReceivingFinishedMutex);
}
igtlDevice->m_ReceiveThreadID = 0; // erase thread id because thread will end.
return ITK_THREAD_RETURN_VALUE;
}
ITK_THREAD_RETURN_TYPE mitk::IGTLDevice::ThreadStartConnecting(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo =
(struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
IGTLDevice *igtlDevice = (IGTLDevice*)pInfo->UserData;
if (igtlDevice != nullptr)
{
igtlDevice->RunCommunication(&mitk::IGTLDevice::Connect,
igtlDevice->m_ConnectingFinishedMutex);
}
igtlDevice->m_ConnectThreadID = 0; // erase thread id because thread will end.
return ITK_THREAD_RETURN_VALUE;
}
diff --git a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp
index 7e4801aebc..984a97a282 100644
--- a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp
+++ b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp
@@ -1,410 +1,438 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkIGTLDeviceSetupConnectionWidget.h"
//mitk headers
#include <mitkSurface.h>
#include <mitkIGTLDeviceSource.h>
#include <mitkDataStorage.h>
#include <mitkIGTLMessageFactory.h>
//qt headers
#include <qfiledialog.h>
#include <qinputdialog.h>
#include <qmessagebox.h>
#include <qscrollbar.h>
//igtl
#include <igtlStringMessage.h>
#include <igtlBindMessage.h>
#include <igtlQuaternionTrackingDataMessage.h>
#include <igtlTrackingDataMessage.h>
//poco headers
#include <Poco/Path.h>
const std::string QmitkIGTLDeviceSetupConnectionWidget::VIEW_ID =
"org.mitk.views.igtldevicesetupconnectionwidget";
QmitkIGTLDeviceSetupConnectionWidget::QmitkIGTLDeviceSetupConnectionWidget(
QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f), m_IsClient(false)
{
m_Controls = nullptr;
this->m_IGTLDevice = nullptr;
CreateQtPartControl(this);
m_NumSentFramesSinceLastUpdate = 0;
m_NumReceivedFramesSinceLastUpdate = 0;
}
QmitkIGTLDeviceSetupConnectionWidget::~QmitkIGTLDeviceSetupConnectionWidget()
{
this->RemoveObserver();
}
void QmitkIGTLDeviceSetupConnectionWidget::RemoveObserver()
{
if (this->m_IGTLDevice.IsNotNull())
{
this->m_IGTLDevice->RemoveObserver(m_MessageReceivedObserverTag);
this->m_IGTLDevice->RemoveObserver(m_MessageSentObserverTag);
this->m_IGTLDevice->RemoveObserver(m_CommandReceivedObserverTag);
this->m_IGTLDevice->RemoveObserver(m_LostConnectionObserverTag);
this->m_IGTLDevice->RemoveObserver(m_NewConnectionObserverTag);
this->m_IGTLDevice->RemoveObserver(m_StateModifiedObserverTag);
}
}
void QmitkIGTLDeviceSetupConnectionWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkIGTLDeviceSetupConnectionWidgetControls;
// setup GUI widgets
m_Controls->setupUi(parent);
}
// set the validator for the ip edit box (values must be between 0 and 255 and
// there are four of them, seperated with a point
QRegExpValidator *v = new QRegExpValidator(this);
QRegExp rx("((1{0,1}[0-9]{0,2}|2[0-4]{1,1}[0-9]{1,1}|25[0-5]{1,1})\\.){3,3}(1{0,1}[0-9]{0,2}|2[0-4]{1,1}[0-9]{1,1}|25[0-5]{1,1})");
v->setRegExp(rx);
m_Controls->editIP->setValidator(v);
// set the validator for the port edit box (values must be between 1 and 65535)
m_Controls->editPort->setValidator(new QIntValidator(1, 65535, this));
m_FPSCalculationTimer.start(1000);
//connect slots with signals
CreateConnections();
}
void QmitkIGTLDeviceSetupConnectionWidget::CreateConnections()
{
if (m_Controls)
{
// connect the widget items with the methods
connect(m_Controls->butConnect, SIGNAL(clicked()),
this, SLOT(OnConnect()));
connect(m_Controls->editPort, SIGNAL(editingFinished()),
this, SLOT(OnPortChanged()));
connect(m_Controls->editIP, SIGNAL(editingFinished()),
this, SLOT(OnHostnameChanged()));
connect(m_Controls->bufferInMsgCheckBox, SIGNAL(stateChanged(int)),
this, SLOT(OnBufferIncomingMessages(int)));
connect(m_Controls->bufferOutMsgCheckBox, SIGNAL(stateChanged(int)),
this, SLOT(OnBufferOutgoingMessages(int)));
connect(&m_FPSCalculationTimer, SIGNAL(timeout()),
this, SLOT(OnUpdateFPSLabel()));
+ connect(m_Controls->logMessageDetailsCheckBox, SIGNAL(clicked()),
+ this, SLOT(OnLogMessageDetailsCheckBoxClicked()));
}
//this is used for thread seperation, otherwise the worker thread would change the ui elements
//which would cause an exception
connect(this, SIGNAL(AdaptGUIToStateSignal()), this, SLOT(AdaptGUIToState()));
}
void QmitkIGTLDeviceSetupConnectionWidget::OnDeviceStateChanged()
{
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceSetupConnectionWidget::AdaptGUIToState()
{
//check the validity of the device
if (this->m_IGTLDevice.IsNull())
{
return;
}
//check the state of the device
mitk::IGTLDevice::IGTLDeviceState state = this->m_IGTLDevice->GetState();
switch (state) {
case mitk::IGTLDevice::Setup:
if (!m_IsClient)
{
m_Controls->butConnect->setText("Go Online");
this->m_Controls->editIP->setEnabled(false);
}
else
{
m_Controls->butConnect->setText("Connect");
this->m_Controls->editIP->setEnabled(true);
}
this->m_Controls->editPort->setEnabled(true);
- this->m_Controls->logIncomingMsg->setEnabled(false);
- this->m_Controls->logOutgoingMsg->setEnabled(false);
+ this->m_Controls->logMessageStatusCheckBox->setChecked(false);
+ this->m_Controls->logMessageDetailsCheckBox->setChecked(false);
+ this->m_Controls->logMessageStatusCheckBox->setEnabled(false);
+ this->m_Controls->logMessageDetailsCheckBox->setEnabled(false);
this->m_Controls->bufferInMsgCheckBox->setEnabled(false);
this->m_Controls->bufferOutMsgCheckBox->setEnabled(false);
this->m_Controls->butConnect->setEnabled(true);
this->m_Controls->fpsInLabel->setEnabled(false);
this->m_Controls->fpsOutLabel->setEnabled(false);
this->m_Controls->fpsInDescrLabel->setEnabled(false);
this->m_Controls->fpsOutDescrLabel->setEnabled(false);
+
+ if( this->m_IGTLDevice.IsNotNull() )
+ {
+ this->m_IGTLDevice->SetLogMessages(false);
+ }
+
break;
case mitk::IGTLDevice::Ready:
if (m_IsClient)
{
this->m_Controls->butConnect->setText("Disconnect");
}
else
{
this->m_Controls->butConnect->setText("Go Offline");
}
this->m_Controls->editIP->setEnabled(false);
this->m_Controls->editPort->setEnabled(false);
- this->m_Controls->logIncomingMsg->setEnabled(true);
- this->m_Controls->logOutgoingMsg->setEnabled(true);
+ this->m_Controls->logMessageStatusCheckBox->setEnabled(true);
+ this->m_Controls->logMessageDetailsCheckBox->setEnabled(true);
this->m_Controls->bufferInMsgCheckBox->setEnabled(true);
this->m_Controls->bufferOutMsgCheckBox->setEnabled(true);
this->m_Controls->butConnect->setEnabled(true);
this->m_Controls->fpsInLabel->setEnabled(true);
this->m_Controls->fpsOutLabel->setEnabled(true);
this->m_Controls->fpsInDescrLabel->setEnabled(true);
this->m_Controls->fpsOutDescrLabel->setEnabled(true);
break;
case mitk::IGTLDevice::Running:
if (m_IsClient)
{
this->m_Controls->butConnect->setText("Disconnect");
}
else
{
this->m_Controls->butConnect->setText("Go Offline");
}
this->m_Controls->editIP->setEnabled(false);
this->m_Controls->editPort->setEnabled(false);
- this->m_Controls->logIncomingMsg->setEnabled(true);
- this->m_Controls->logOutgoingMsg->setEnabled(true);
+ this->m_Controls->logMessageStatusCheckBox->setEnabled(true);
+ this->m_Controls->logMessageDetailsCheckBox->setEnabled(true);
this->m_Controls->bufferInMsgCheckBox->setEnabled(true);
this->m_Controls->bufferOutMsgCheckBox->setEnabled(true);
this->m_Controls->butConnect->setEnabled(true);
this->m_Controls->fpsInLabel->setEnabled(true);
this->m_Controls->fpsOutLabel->setEnabled(true);
this->m_Controls->fpsInDescrLabel->setEnabled(true);
this->m_Controls->fpsOutDescrLabel->setEnabled(true);
break;
default:
mitkThrow() << "Invalid Device State";
break;
}
}
void QmitkIGTLDeviceSetupConnectionWidget::Initialize(
mitk::IGTLDevice::Pointer device)
{
//reset the GUI
DisableSourceControls();
//reset the observers
this->RemoveObserver();
if (device.IsNotNull())
{
this->m_IGTLDevice = device;
//check if the device is a server or a client
if (dynamic_cast<mitk::IGTLClient*>(
this->m_IGTLDevice.GetPointer()) == nullptr)
{
m_IsClient = false;
}
else
{
m_IsClient = true;
}
this->AdaptGUIToState();
typedef itk::SimpleMemberCommand< QmitkIGTLDeviceSetupConnectionWidget > CurCommandType;
CurCommandType::Pointer messageSentCommand = CurCommandType::New();
messageSentCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnMessageSent);
this->m_MessageSentObserverTag = this->m_IGTLDevice->AddObserver(
mitk::MessageSentEvent(), messageSentCommand);
CurCommandType::Pointer messageReceivedCommand = CurCommandType::New();
messageReceivedCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnMessageReceived);
this->m_MessageReceivedObserverTag = this->m_IGTLDevice->AddObserver(
mitk::MessageReceivedEvent(), messageReceivedCommand);
CurCommandType::Pointer commandReceivedCommand = CurCommandType::New();
commandReceivedCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnCommandReceived);
this->m_CommandReceivedObserverTag = this->m_IGTLDevice->AddObserver(
mitk::CommandReceivedEvent(), commandReceivedCommand);
CurCommandType::Pointer connectionLostCommand = CurCommandType::New();
connectionLostCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnLostConnection);
this->m_LostConnectionObserverTag = this->m_IGTLDevice->AddObserver(
mitk::LostConnectionEvent(), connectionLostCommand);
CurCommandType::Pointer newConnectionCommand = CurCommandType::New();
newConnectionCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnNewConnection);
this->m_NewConnectionObserverTag = this->m_IGTLDevice->AddObserver(
mitk::NewClientConnectionEvent(), newConnectionCommand);
CurCommandType::Pointer stateModifiedCommand = CurCommandType::New();
stateModifiedCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnDeviceStateChanged);
this->m_StateModifiedObserverTag = this->m_IGTLDevice->AddObserver(
itk::ModifiedEvent(), stateModifiedCommand);
OnBufferIncomingMessages(m_Controls->bufferInMsgCheckBox->isChecked());
OnBufferOutgoingMessages(m_Controls->bufferOutMsgCheckBox->isChecked());
}
else
{
m_IGTLDevice = nullptr;
}
}
void QmitkIGTLDeviceSetupConnectionWidget::DisableSourceControls()
{
m_Controls->editIP->setEnabled(false);
m_Controls->editPort->setEnabled(false);
m_Controls->butConnect->setEnabled(false);
m_Controls->bufferInMsgCheckBox->setEnabled(false);
m_Controls->bufferOutMsgCheckBox->setEnabled(false);
- m_Controls->logIncomingMsg->setEnabled(false);
- m_Controls->logOutgoingMsg->setEnabled(false);
+ this->m_Controls->logMessageStatusCheckBox->setChecked(false);
+ this->m_Controls->logMessageDetailsCheckBox->setChecked(false);
+ this->m_Controls->logMessageStatusCheckBox->setEnabled(false);
+ this->m_Controls->logMessageDetailsCheckBox->setEnabled(false);
+
+ if( this->m_IGTLDevice.IsNotNull() )
+ {
+ this->m_IGTLDevice->SetLogMessages(false);
+ }
}
void QmitkIGTLDeviceSetupConnectionWidget::OnConnect()
{
if (m_IGTLDevice->GetState() == mitk::IGTLDevice::Setup)
{
QString port = m_Controls->editPort->text();
m_IGTLDevice->SetPortNumber(port.toInt());
std::string hostname = m_Controls->editIP->text().toStdString();
m_IGTLDevice->SetHostname(hostname);
//connect with the other OpenIGTLink device => changes the state from Setup
//to Ready
if (m_IGTLDevice->OpenConnection())
{
//starts the communication thread => changes the state from Ready to
//Running
if (m_IGTLDevice->StartCommunication())
{
if (this->m_IsClient)
{
MITK_INFO("IGTLDeviceSourceManagementWidget")
<< "Successfully connected to " << hostname
<< " on port " << port.toStdString();
}
}
else
{
MITK_ERROR("QmitkIGTLDeviceSetupConnectionWidget") <<
"Could not start a communication with the"
"server because the client is in the wrong state";
}
}
else
{
MITK_ERROR("QmitkIGTLDeviceSetupConnectionWidget") <<
"Could not connect to the server. "
"Please check the hostname and port.";
}
}
else if (m_IGTLDevice->GetState() == mitk::IGTLDevice::Ready || m_IGTLDevice->GetState() == mitk::IGTLDevice::Running)
{
m_IGTLDevice->CloseConnection();
MITK_INFO("QmitkIGTLDeviceSetupConnectionWidget") << "Closed connection";
}
else
{
mitkThrow() << "Invalid state of IGTLDevice";
}
this->AdaptGUIToState();
}
void QmitkIGTLDeviceSetupConnectionWidget::OnPortChanged()
{
}
void QmitkIGTLDeviceSetupConnectionWidget::OnHostnameChanged()
{
}
void QmitkIGTLDeviceSetupConnectionWidget::OnLostConnection()
{
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceSetupConnectionWidget::OnNewConnection()
{
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceSetupConnectionWidget::OnMessageReceived()
{
- if (this->m_Controls->logIncomingMsg->isChecked())
+ if( this->m_Controls->logMessageStatusCheckBox->isChecked() )
{
- MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Received a message: "
- << this->m_IGTLDevice->GetMessageQueue()->GetLatestMsgInformationString();
+ MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Received a message.";
}
m_NumReceivedFramesSinceLastUpdate++;
}
void QmitkIGTLDeviceSetupConnectionWidget::OnMessageSent()
{
- if (this->m_Controls->logOutgoingMsg->isChecked())
+ if( this->m_Controls->logMessageStatusCheckBox->isChecked() )
{
MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Sent a message.";
}
m_NumSentFramesSinceLastUpdate++;
}
void QmitkIGTLDeviceSetupConnectionWidget::OnCommandReceived()
{
- if (this->m_Controls->logIncomingMsg->isChecked())
+ if( this->m_Controls->logMessageStatusCheckBox->isChecked() )
{
- MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Received a command: "
- << this->m_IGTLDevice->GetMessageQueue()->GetLatestMsgInformationString();
+ MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Received a command.";
}
}
void QmitkIGTLDeviceSetupConnectionWidget::OnBufferIncomingMessages(int state)
{
if (this->m_IGTLDevice.IsNotNull())
{
this->m_IGTLDevice->EnableNoBufferingMode(
this->m_IGTLDevice->GetMessageQueue(), (bool)state);
}
}
void QmitkIGTLDeviceSetupConnectionWidget::OnBufferOutgoingMessages(int state)
{
if (this->m_IGTLDevice.IsNotNull())
{
this->m_IGTLDevice->EnableNoBufferingMode(
this->m_IGTLDevice->GetMessageQueue(), (bool)state);
}
}
void QmitkIGTLDeviceSetupConnectionWidget::OnUpdateFPSLabel()
{
double fpsIn = m_NumReceivedFramesSinceLastUpdate / 1.0;
double fpsOut = m_NumSentFramesSinceLastUpdate / 1.0;
this->m_Controls->fpsInLabel->setText(QString::number(fpsIn));
this->m_Controls->fpsOutLabel->setText(QString::number(fpsOut));
m_NumReceivedFramesSinceLastUpdate = 0;
m_NumSentFramesSinceLastUpdate = 0;
}
+
+void QmitkIGTLDeviceSetupConnectionWidget::OnLogMessageDetailsCheckBoxClicked()
+{
+ if( this->m_IGTLDevice.IsNull() )
+ {
+ MITK_WARN << "Logging information not passed down to Message Provider.";
+ return;
+ }
+ else
+ {
+ this->m_IGTLDevice->SetLogMessages( this->m_Controls->logMessageDetailsCheckBox->isChecked() );
+ }
+}
diff --git a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.h b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.h
index dab9020c04..b1dacabfa5 100644
--- a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.h
+++ b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.h
@@ -1,180 +1,185 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkIGTLDeviceSetupConnectionWidget_H
#define QmitkIGTLDeviceSetupConnectionWidget_H
//QT headers
#include <QWidget>
#include <QTimer>
//mitk headers
#include "MitkOpenIGTLinkUIExports.h"
#include "mitkIGTLDeviceSource.h"
#include "mitkIGTLClient.h"
#include "mitkDataStorage.h"
//itk
#include <itkCommand.h>
//ui header
#include "ui_QmitkIGTLDeviceSetupConnectionWidgetControls.h"
/** Documentation:
* \brief An object of this class offers an UI to setup the connection of an
* OpenIGTLink device.
*
*
* \ingroup OpenIGTLinkUI
*/
class MITKOPENIGTLINKUI_EXPORT QmitkIGTLDeviceSetupConnectionWidget : public QWidget
{
Q_OBJECT
public:
static const std::string VIEW_ID;
/**
* \brief Initializes the widget with the given device.
*
* The old device is
* dropped, so be careful, if the source is not saved somewhere else it might
* be lost. You might want to ask the user if he wants to save the changes
* before calling this method.
* \param device The widget will be initialized corresponding to the state of
* this device.
*/
void Initialize(mitk::IGTLDevice::Pointer device);
QmitkIGTLDeviceSetupConnectionWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
~QmitkIGTLDeviceSetupConnectionWidget() override;
// /**
// * \brief Is called when the current device received a message
// */
// void OnMessageReceived(itk::Object* caller, const itk::EventObject&);
// /**
// * \brief Is called when the current device received a command
// */
// void OnCommandReceived(itk::Object* caller, const itk::EventObject&);
/**
* \brief Is called when the current device lost a connection to one of its
* sockets
*/
void OnLostConnection();
/**
* \brief Is called when the current device connected to another device
*/
void OnNewConnection();
/**
* \brief Is called when the current device received a message
*/
void OnMessageReceived();
/**
* \brief Is called when the current device received a message
*/
void OnMessageSent();
/**
* \brief Is called when the current device received a command
*/
void OnCommandReceived();
protected slots:
void OnConnect();
void OnPortChanged();
void OnHostnameChanged();
void OnUpdateFPSLabel();
+ /**
+ * \brief Enables/Disables the detailed logging of incoming/outgoing messages
+ */
+ void OnLogMessageDetailsCheckBoxClicked();
+
/**
* \brief Enables/Disables the buffering of incoming messages
*/
void OnBufferIncomingMessages(int state);
/**
* \brief Enables/Disables the buffering of outgoing messages
*
* This can be necessary when the data is faster produced then sent
*/
void OnBufferOutgoingMessages(int state);
/**
* \brief Adapts the GUI to the state of the device
*/
void AdaptGUIToState();
signals:
/**
* \brief used for thread seperation, the worker thread must not call AdaptGUIToState directly.
* QT signals are thread safe and seperate the threads
*/
void AdaptGUIToStateSignal();
protected:
/**
* \brief Calls AdaptGUIToState()
*/
void OnDeviceStateChanged();
/** \brief Creation of the connections */
virtual void CreateConnections();
virtual void CreateQtPartControl(QWidget *parent);
Ui::QmitkIGTLDeviceSetupConnectionWidgetControls* m_Controls;
/** @brief holds the OpenIGTLink device */
mitk::IGTLDevice::Pointer m_IGTLDevice;
/** @brief flag to indicate if the IGTL device is a client or a server */
bool m_IsClient;
unsigned long m_MessageSentObserverTag;
unsigned long m_MessageReceivedObserverTag;
unsigned long m_CommandReceivedObserverTag;
unsigned long m_LostConnectionObserverTag;
unsigned long m_NewConnectionObserverTag;
unsigned long m_StateModifiedObserverTag;
/** @brief the number of received frames (messages) since the last fps calculation update
*
* This counter is incremented every time a message is received. When the timer
* m_FPSCalculationTimer is fired it is reset to 0 and the number is used to calculate the FPS
*/
unsigned int m_NumReceivedFramesSinceLastUpdate;
/** @brief the number of sent frames (messages) since the last fps calculation update
*
* This counter is incremented every time a message is sent. When the timer
* m_FPSCalculationTimer is fired it is reset to 0 and the number is used to calculate the FPS
*/
unsigned int m_NumSentFramesSinceLastUpdate;
/** @brief the timer used to calculate the frames per second */
QTimer m_FPSCalculationTimer;
//############## private help methods #######################
void DisableSourceControls();
// void EnableSourceControls();
void RemoveObserver();
};
#endif
diff --git a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidgetControls.ui b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidgetControls.ui
index c976d33c47..ad460f826f 100644
--- a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidgetControls.ui
+++ b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidgetControls.ui
@@ -1,209 +1,212 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkIGTLDeviceSetupConnectionWidgetControls</class>
<widget class="QWidget" name="QmitkIGTLDeviceSetupConnectionWidgetControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>443</width>
<height>169</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout_3">
<item row="4" column="0">
<widget class="QPushButton" name="butConnect">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string>Connect with the host/Start server</string>
</property>
<property name="text">
<string>Connect</string>
</property>
<property name="checkable">
<bool>false</bool>
</property>
<property name="checked">
<bool>false</bool>
</property>
<property name="autoDefault">
<bool>false</bool>
</property>
<property name="default">
<bool>false</bool>
</property>
<property name="flat">
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="0">
<layout class="QGridLayout" name="gridLayout_2">
<item row="2" column="0">
<widget class="QLabel" name="label_3">
<property name="text">
<string>Port</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_4">
<property name="text">
<string>Server-IP</string>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QLineEdit" name="editPort">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string>Enter the port number of the host</string>
</property>
<property name="text">
<string>18944</string>
</property>
<property name="maxLength">
<number>5</number>
</property>
<property name="frame">
<bool>true</bool>
</property>
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
<property name="placeholderText">
<string>Port</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLineEdit" name="editIP">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string>Enter the IP address of the host</string>
</property>
<property name="text">
<string>127.0.0.1</string>
</property>
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
</widget>
</item>
</layout>
</item>
<item row="5" column="0">
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
- <widget class="QCheckBox" name="logIncomingMsg">
+ <widget class="QCheckBox" name="logMessageDetailsCheckBox">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
- <string>Enable this checkbox to log the send and receive message events</string>
+ <string>Enable/Disable the logging of incoming and outgoing messages in detail</string>
</property>
<property name="text">
- <string>Log Incoming Messages</string>
+ <string>Log Message Details</string>
</property>
</widget>
</item>
<item row="2" column="0">
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="fpsInDescrLabel">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Incoming FPS:</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="fpsInLabel">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>0</string>
</property>
</widget>
</item>
</layout>
</item>
<item row="0" column="1">
- <widget class="QCheckBox" name="logOutgoingMsg">
+ <widget class="QCheckBox" name="logMessageStatusCheckBox">
<property name="enabled">
<bool>false</bool>
</property>
+ <property name="toolTip">
+ <string>Enable/Disable the logging of short status messages (i.e.: Sent/received message).</string>
+ </property>
<property name="text">
- <string>Log Outgoing Messages</string>
+ <string>Log Short Status Messages</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QCheckBox" name="bufferOutMsgCheckBox">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Buffer Outgoing Messages</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QCheckBox" name="bufferInMsgCheckBox">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string>If this checkbox is set the device stores all incoming messages in the queue. If it is not set it always overwrites the current value.</string>
</property>
<property name="text">
<string>Buffer Incoming Messages</string>
</property>
<property name="checked">
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="1">
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<widget class="QLabel" name="fpsOutDescrLabel">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Outgoing FPS:</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="fpsOutLabel">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>0</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>
diff --git a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.cpp b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.cpp
index 29dc0c5b06..238bf79625 100644
--- a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.cpp
+++ b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.cpp
@@ -1,100 +1,87 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
//
#include "OpenIGTLinkManager.h"
const std::string OpenIGTLinkManager::VIEW_ID =
"org.mitk.views.openigtlinkmanager";
OpenIGTLinkManager::OpenIGTLinkManager()
: QmitkAbstractView()
{
}
OpenIGTLinkManager::~OpenIGTLinkManager()
{
for(unsigned int i=0; i < m_AllSourcesHandledByThisWidget.size(); i++)
m_AllSourcesHandledByThisWidget.at(i)->UnRegisterMicroservice();
}
void OpenIGTLinkManager::SetFocus()
{
}
void OpenIGTLinkManager::CreateQtPartControl( QWidget *parent )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi( parent );
// create GUI widgets from the Qt Designer's .ui file
// connect( (QObject*)(m_Controls.m_SourceManagerWidget),
// SIGNAL(NewSourceAdded(mitk::IGTLDeviceSource::Pointer, std::string)),
// this,
// SLOT(NewSourceByWidget(mitk::IGTLDeviceSource::Pointer,std::string)) );
connect( (QObject*)(m_Controls.m_SourceListWidget),
SIGNAL(IGTLDeviceSourceSelected(mitk::IGTLDeviceSource::Pointer)),
this,
SLOT(SourceSelected(mitk::IGTLDeviceSource::Pointer)) );
- connect(m_Controls.checkBoxLogMessages, SIGNAL(clicked()), this, SLOT(LogMessagesClicked()));
-
- logMessages = m_Controls.checkBoxLogMessages->isChecked();
}
void OpenIGTLinkManager::NewSourceByWidget(
mitk::IGTLDeviceSource::Pointer source,std::string /*sourceName*/)
{
source->RegisterAsMicroservice(/*sourceName*/);
m_AllSourcesHandledByThisWidget.push_back(source);
}
-void OpenIGTLinkManager::LogMessagesClicked()
-{
- logMessages = m_Controls.checkBoxLogMessages->isChecked();
- if(m_CurrentIGTLDevice.IsNotNull())
- m_CurrentIGTLDevice->SetLogMessages(logMessages);
- else
- MITK_WARN << "Logging information not passed down to Message Provider.";
-}
-
void OpenIGTLinkManager::SourceSelected(
mitk::IGTLDeviceSource::Pointer source)
{
if (source.IsNull()) //no source selected
{
//reset everything
return;
}
m_CurrentIGTLDevice = source->GetIGTLDevice();
- m_CurrentIGTLDevice->SetLogMessages(logMessages);
this->m_Controls.m_SourceManagerWidget->LoadSource(source);
//check if the current selected source is also a message provider
mitk::IGTLMessageProvider::Pointer currentMsgProvider =
mitk::IGTLMessageProvider::New();
currentMsgProvider = dynamic_cast<mitk::IGTLMessageProvider*>(source.GetPointer());
if(currentMsgProvider.IsNull())
return;
this->m_Controls.m_StreamManagerWidget->LoadSource(currentMsgProvider);
}
diff --git a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.h b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.h
index 6e5765f4a4..259daf2f09 100644
--- a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.h
+++ b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.h
@@ -1,76 +1,73 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef OpenIGTLinkManager_h
#define OpenIGTLinkManager_h
#include <berryISelectionListener.h>
#include <QmitkAbstractView.h>
#include "ui_OpenIGTLinkManagerControls.h"
#include "mitkIGTLClient.h"
#include "mitkIGTLDeviceSource.h"
/**
\brief OpenIGTLinkManager
\warning This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
\sa QmitkAbstractView
\ingroup ${plugin_target}_internal
*/
class OpenIGTLinkManager : public QmitkAbstractView
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const std::string VIEW_ID;
OpenIGTLinkManager();
virtual ~OpenIGTLinkManager();
public slots:
void NewSourceByWidget(mitk::IGTLDeviceSource::Pointer source, std::string);
void SourceSelected(mitk::IGTLDeviceSource::Pointer source);
- void LogMessagesClicked();
protected:
virtual void CreateQtPartControl(QWidget *parent) override;
virtual void SetFocus() override;
void CreatePipeline();
void DestroyPipeline();
Ui::OpenIGTLinkManagerControls m_Controls;
/** Someone needs to hold the smart pointers of new sources, otherwise the
* objects will be lost although they are listed as microservice.
*/
std::vector<mitk::IGTLDeviceSource::Pointer> m_AllSourcesHandledByThisWidget;
- bool logMessages;
-
mitk::IGTLDevice::Pointer m_CurrentIGTLDevice;
};
#endif // OpenIGTLinkManager_h
diff --git a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManagerControls.ui b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManagerControls.ui
index e83ddbb914..c112355b49 100644
--- a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManagerControls.ui
+++ b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManagerControls.ui
@@ -1,105 +1,98 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>OpenIGTLinkManagerControls</class>
<widget class="QWidget" name="OpenIGTLinkManagerControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>668</width>
<height>392</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="windowTitle">
<string>QmitkTemplate</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QLabel" name="label_2">
<property name="font">
<font>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Select OpenIGTLink device source:</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkIGTLDeviceSourceSelectionWidget" name="m_SourceListWidget"/>
</item>
<item>
<widget class="QLabel" name="label">
<property name="font">
<font>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Manage device:</string>
</property>
</widget>
</item>
- <item>
- <widget class="QCheckBox" name="checkBoxLogMessages">
- <property name="text">
- <string>Log incoming / outgoing messages</string>
- </property>
- </widget>
- </item>
<item>
<widget class="QmitkIGTLDeviceSourceManagementWidget" name="m_SourceManagerWidget" native="true"/>
</item>
<item>
<widget class="QLabel" name="label_3">
<property name="font">
<font>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Manage streams of selected device source:</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkIGTLStreamingManagementWidget" name="m_StreamManagerWidget" native="true"/>
</item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
<customwidget>
<class>QmitkIGTLDeviceSourceSelectionWidget</class>
<extends>QTextEdit</extends>
<header>QmitkIGTLDeviceSourceSelectionWidget.h</header>
</customwidget>
<customwidget>
<class>QmitkIGTLDeviceSourceManagementWidget</class>
<extends>QWidget</extends>
<header>QmitkIGTLDeviceSourceManagementWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkIGTLStreamingManagementWidget</class>
<extends>QWidget</extends>
<header>QmitkIGTLStreamingManagementWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>