QmitkTrackingDeviceConfigurationWidget.cpp

Go to the documentation of this file.

/*===================================================================

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 "QmitkTrackingDeviceConfigurationWidget.h"

#include "mitkNDIPolarisTypeInformation.h"

#include <QSettings>

const std::string QmitkTrackingDeviceConfigurationWidget::VIEW_ID = "org.mitk.views.trackingdeviceconfigurationwidget";

QmitkTrackingDeviceConfigurationWidget::QmitkTrackingDeviceConfigurationWidget(QWidget* parent, Qt::WindowFlags f)
  : QWidget(parent, f)
  , m_Controls(nullptr)
  , m_TrackingDevice(nullptr)
  , m_DeviceToWidgetIndexMap()
{
  //initializations
  CreateQtPartControl(this);
  CreateConnections();

  RefreshTrackingDeviceCollection();

  //initialize a few UI elements
  AddOutput("<br>First Element selected"); //Order from Collection List

  //reset a few things
  ResetOutput();

  //restore old UI settings
  LoadUISettings();
}

QmitkTrackingDeviceConfigurationWidget::~QmitkTrackingDeviceConfigurationWidget()
{
  StoreUISettings();
  delete m_Controls;
  m_TrackingDevice = nullptr;
}

void QmitkTrackingDeviceConfigurationWidget::CreateQtPartControl(QWidget *parent)
{
  if (!m_Controls)
  {
    // create GUI widgets
    m_Controls = new Ui::QmitkTrackingDeviceConfigurationWidgetControls;
    m_Controls->setupUi(parent);
  }
}

void QmitkTrackingDeviceConfigurationWidget::CreateConnections()
{
  if (m_Controls)
  {
    connect((QObject*)(m_Controls->m_TrackingDeviceChooser), SIGNAL(currentIndexChanged(int)), this, SLOT(TrackingDeviceChanged()));
  }
}

void QmitkTrackingDeviceConfigurationWidget::TrackingDeviceChanged()
{
  const std::string currentDevice = this->GetCurrentDeviceName();

  //show the correspondig widget
  m_Controls->m_TrackingSystemWidget->setCurrentIndex(m_DeviceToWidgetIndexMap[currentDevice]);

  //reset output
  ResetOutput();

  AddOutput("<br>");
  AddOutput(currentDevice);
  AddOutput(" selected");

  QmitkAbstractTrackingDeviceWidget* widget = GetWidget(currentDevice);

  if (widget == nullptr || !widget->IsDeviceInstalled())
  {
    AddOutput("<br>ERROR: not installed!");
  }

  emit TrackingDeviceSelectionChanged();
}

void QmitkTrackingDeviceConfigurationWidget::RefreshTrackingDeviceCollection()
{
  // clean-up of stacked widget, drop-down box and map
  for (auto& item : m_DeviceToWidgetIndexMap)
  {
    m_Controls->m_TrackingSystemWidget->removeWidget(m_Controls->m_TrackingSystemWidget->widget(item.second));
    MITK_INFO << "removing widget for device '" << item.first << "'";
  }

  m_Controls->m_TrackingDeviceChooser->clear();

  m_DeviceToWidgetIndexMap.clear();

  // get tracking device type service references
  us::ModuleContext* context = us::GetModuleContext();
  std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > deviceRefs =
    context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();

  if (deviceRefs.empty())
  {
    MITK_ERROR << "No tracking device type service found!";
    return;
  }

  // get tracking device configuration widget service references
  std::vector<us::ServiceReference<mitk::TrackingDeviceWidgetCollection> > widgetRefs =
    context->GetServiceReferences<mitk::TrackingDeviceWidgetCollection>();

  if (widgetRefs.empty())
  {
    MITK_ERROR << "No tracking device configuration widget service found!";
    return;
  }

  const us::ServiceReference<mitk::TrackingDeviceTypeCollection>& deviceServiceReference = deviceRefs.front();
  const us::ServiceReference<mitk::TrackingDeviceWidgetCollection>& widgetServiceReference = widgetRefs.front();

  mitk::TrackingDeviceTypeCollection* deviceTypeCollection =
    context->GetService<mitk::TrackingDeviceTypeCollection>(deviceServiceReference);

  mitk::TrackingDeviceWidgetCollection* deviceWidgetCollection =
    context->GetService<mitk::TrackingDeviceWidgetCollection>(widgetServiceReference);

  for (auto name : deviceTypeCollection->GetTrackingDeviceTypeNames())
  {
    // if the device is not included yet, add name to comboBox and widget to stackedWidget
    if (m_Controls->m_TrackingDeviceChooser->findText(QString::fromStdString(name)) == -1)
    {
      m_Controls->m_TrackingDeviceChooser->addItem(QString::fromStdString(name));
      QWidget* current = deviceWidgetCollection->GetTrackingDeviceWidgetClone(name);
      if (current == nullptr)
      {
        MITK_WARN << "No widget for tracking device type " << name << " available. Please implement and register it!";
        current = new QWidget();
      }

      m_DeviceToWidgetIndexMap[name] = m_Controls->m_TrackingSystemWidget->addWidget(current);
    }
  }

  if (!m_DeviceToWidgetIndexMap.empty())
  {
    m_Controls->m_TrackingDeviceChooser->setCurrentIndex(0);
    m_Controls->m_TrackingSystemWidget->setCurrentIndex(0);
  }

  context->UngetService(deviceServiceReference);
  context->UngetService(widgetServiceReference);
}

//######################### internal help methods #######################################
void QmitkTrackingDeviceConfigurationWidget::ResetOutput()
{
  QmitkAbstractTrackingDeviceWidget* currentWidget = this->GetWidget(this->GetCurrentDeviceName());

  if (currentWidget == nullptr)
  {
    return;
  }

  currentWidget->ResetOutput();
  currentWidget->repaint();
}

void QmitkTrackingDeviceConfigurationWidget::AddOutput(std::string s)
{
  QmitkAbstractTrackingDeviceWidget* currentWidget = this->GetWidget(this->GetCurrentDeviceName());

  if (currentWidget == nullptr)
  {
    return;
  }

  currentWidget->AddOutput(s);
  currentWidget->repaint();
}

mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConstructTrackingDevice()
{
  QmitkAbstractTrackingDeviceWidget* currentWidget = this->GetWidget(this->GetCurrentDeviceName());

  if (currentWidget == nullptr)
  {
    return nullptr;
  }

  return currentWidget->ConstructTrackingDevice();
}

mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::GetTrackingDevice()
{
  m_TrackingDevice = ConstructTrackingDevice();
  if (m_TrackingDevice.IsNull() || !m_TrackingDevice->IsDeviceInstalled()) return nullptr;
  else return this->m_TrackingDevice;
}

void QmitkTrackingDeviceConfigurationWidget::StoreUISettings()
{
  std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";

  std::string selectedDevice = this->GetCurrentDeviceName();

  //Save settings for every widget
  //Don't use m_DeviceTypeCollection here, it's already unregistered, when deconstructor is called...
  for (int index = 0; index < m_Controls->m_TrackingSystemWidget->count(); index++)
  {
    QmitkAbstractTrackingDeviceWidget* widget = dynamic_cast<QmitkAbstractTrackingDeviceWidget*>(m_Controls->m_TrackingSystemWidget->widget(index));

    if (widget != nullptr)
    {
      widget->StoreUISettings();
    }
  }

  if (this->GetPersistenceService()) // now save the settings using the persistence service
  {
    mitk::PropertyList::Pointer propList = this->GetPersistenceService()->GetPropertyList(id);
    propList->Set("SelectedDevice", selectedDevice);
  }
  else // QSettings as a fallback if the persistence service is not available
  {
    QSettings settings;
    settings.beginGroup(QString::fromStdString(id));
    settings.setValue("trackingDeviceChooser", QVariant(QString::fromStdString(selectedDevice)));
    settings.endGroup();
  }
}

void QmitkTrackingDeviceConfigurationWidget::LoadUISettings()
{
  //Load settings for every widget
  for (int index = 0; index < m_Controls->m_TrackingSystemWidget->count(); index++)
  {
    QmitkAbstractTrackingDeviceWidget* widget = dynamic_cast<QmitkAbstractTrackingDeviceWidget*>(m_Controls->m_TrackingSystemWidget->widget(index));

    if (widget != nullptr)
    {
      widget->LoadUISettings();
    }
  }

  std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
  std::string selectedDevice;
  if (this->GetPersistenceService())
  {
    mitk::PropertyList::Pointer propList = this->GetPersistenceService()->GetPropertyList(id);
    if (propList.IsNull())
    {
      MITK_ERROR << "Property list for this UI (" << id << ") is not available, could not load UI settings!"; return;
    }

    propList->Get("SelectedDevice", selectedDevice);

    if (selectedDevice.empty())
    {
      MITK_ERROR << "Loaded data from persistence service is invalid (SelectedDevice:" << selectedDevice << "): aborted to restore data!";
      return;
    }

    MITK_INFO << "Successfully restored UI settings";
  }
  else
  {
    // QSettings as a fallback if the persistence service is not available
    QSettings settings;
    settings.beginGroup(QString::fromStdString(id));

    selectedDevice = settings.value("trackingDeviceChooser", "").toString().toStdString();

    settings.endGroup();
  }

  // The selected device requires some checks because a device that is not installed should not be restored to avoid bugs.
  // Use NDI Polaris as default if there's no widget registered for selected device or there's a widget for it but no device installed.

  const auto& deviceIterator = m_DeviceToWidgetIndexMap.find(selectedDevice);

  if (deviceIterator != m_DeviceToWidgetIndexMap.end())
  {
    QmitkAbstractTrackingDeviceWidget* widget =
      dynamic_cast<QmitkAbstractTrackingDeviceWidget*>(m_Controls->m_TrackingSystemWidget->widget(deviceIterator->second));

    if (widget == nullptr || (widget != nullptr && !widget->IsDeviceInstalled()))
    {
      selectedDevice = mitk::NDIPolarisTypeInformation::GetTrackingDeviceName();
    }
  }
  else
  {
    selectedDevice = mitk::NDIPolarisTypeInformation::GetTrackingDeviceName();
  }

  const int index = m_Controls->m_TrackingDeviceChooser->findText(QString::fromStdString(selectedDevice));

  if (index >= 0)
  {
    m_Controls->m_TrackingDeviceChooser->setCurrentIndex(index);
  }
  else
  {
    MITK_ERROR << "Failed to load UI setting for tracking device configuration";
    return;
  }

  m_Controls->m_TrackingSystemWidget->setCurrentIndex(m_DeviceToWidgetIndexMap[selectedDevice]);
}

std::string QmitkTrackingDeviceConfigurationWidget::GetCurrentDeviceName(void) const
{
  return m_Controls->m_TrackingDeviceChooser->currentText().toStdString();
}

QmitkAbstractTrackingDeviceWidget* QmitkTrackingDeviceConfigurationWidget::GetWidget(const std::string& deviceName) const
{
  const auto& deviceIterator = m_DeviceToWidgetIndexMap.find(deviceName);

  if (deviceIterator != m_DeviceToWidgetIndexMap.end())
  {
    QWidget* widget = m_Controls->m_TrackingSystemWidget->widget(deviceIterator->second);

    return dynamic_cast<QmitkAbstractTrackingDeviceWidget*>(widget);
  }

  return nullptr;
}