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>