diff --git a/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.cpp b/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.cpp
index 3d58e4de79..f3337fdca9 100644
--- a/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.cpp
+++ b/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.cpp
@@ -1,718 +1,718 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "berryApplicationContainer.h"
 
 #include <berryIConfigurationElement.h>
 #include <berryIContributor.h>
 #include <berryIExtensionRegistry.h>
 #include <berryIExtension.h>
 #include <berryIExtensionPoint.h>
 #include <berryIProductProvider.h>
 #include <berryIProduct.h>
 
 #include "berryApplicationHandle.h"
 #include "berryApplicationDescriptor.h"
 #include "berryCoreException.h"
 #include "berryErrorApplication.h"
 #include "berryMainApplicationLauncher.h"
 #include "berryProductExtensionBranding.h"
 #include "berryProviderExtensionBranding.h"
 
 #include <berryLog.h>
 
 #include "berryCTKPluginActivator.h"
 
 #include <service/application/ctkApplicationException.h>
 #include <service/application/ctkApplicationLauncher.h>
 
 namespace berry {
 
 static const QString PI_OSGI = "org.blueberry.osgi";
 
 const QString ApplicationContainer::PI_RUNTIME = "org.blueberry.core.runtime";
 const QString ApplicationContainer::PT_APPLICATIONS = "applications";
 const QString ApplicationContainer::PT_APP_VISIBLE = "visible";
 const QString ApplicationContainer::PT_APP_THREAD = "thread";
 const QString ApplicationContainer::PT_APP_THREAD_ANY = "any";
 const QString ApplicationContainer::PT_APP_CARDINALITY = "cardinality";
 const QString ApplicationContainer::PT_APP_CARDINALITY_SINGLETON_GLOBAL = "singleton-global";
 const QString ApplicationContainer::PT_APP_CARDINALITY_SINGLETON_SCOPED = "singleton-scoped";
 const QString ApplicationContainer::PT_APP_CARDINALITY_UNLIMITED = "*";
 const QString ApplicationContainer::PT_APP_ICON = "icon";
 const QString ApplicationContainer::PT_PRODUCTS = "products";
 const QString ApplicationContainer::EXT_ERROR_APP = "org.blueberry.core.runtime.app.error";
 
 const QString ApplicationContainer::PROP_PRODUCT = "blueberry.product";
 const QString ApplicationContainer::PROP_BLUEBERRY_APPLICATION = "blueberry.application";
 const QString ApplicationContainer::PROP_BLUEBERRY_APPLICATION_LAUNCH_DEFAULT = "blueberry.application.launchDefault";
 
 const int ApplicationContainer::NOT_LOCKED = 0;
 const int ApplicationContainer::LOCKED_SINGLETON_GLOBAL_RUNNING = 1;
 const int ApplicationContainer::LOCKED_SINGLETON_GLOBAL_APPS_RUNNING = 2;
 const int ApplicationContainer::LOCKED_SINGLETON_SCOPED_RUNNING = 3;
 const int ApplicationContainer::LOCKED_SINGLETON_LIMITED_RUNNING = 4;
 const int ApplicationContainer::LOCKED_MAIN_THREAD_RUNNING = 5;
 
 
 ApplicationContainer::ApplicationContainer(ctkPluginContext* context, IExtensionRegistry* extensionRegistry)
   : context(context)
   , extensionRegistry(extensionRegistry)
   , launcherTracker(new ctkServiceTracker<ctkApplicationLauncher*>(context, this))
   , branding(nullptr)
   , missingProductReported(false)
   , defaultMainThreadAppHandle(nullptr)
   , missingApp(false)
 {
 }
 
 ApplicationContainer::~ApplicationContainer()
 {
 }
 
 void ApplicationContainer::Start()
 {
   launcherTracker->open();
   extensionRegistry->AddListener(this, PI_OSGI + '.' + PT_APPLICATIONS);
   // need to listen for system bundle stopping
   context->connectPluginListener(this, SLOT(PluginChanged(ctkPluginEvent)), Qt::DirectConnection);
   // register all the descriptors
   RegisterAppDescriptors();
   QVariant startDefaultProp = context->getProperty(ApplicationContainer::PROP_BLUEBERRY_APPLICATION_LAUNCH_DEFAULT);
   if (startDefaultProp.isNull() || startDefaultProp.toBool())
   {
     // Start the default application
     try
     {
       StartDefaultApp(true);
     }
     catch (const ctkApplicationException& e)
     {
       BERRY_ERROR << "An error occurred while starting the application:" << e.message();
     }
   }
 }
 
 void ApplicationContainer::Stop()
 {
   // stop all applications
   StopAllApps();
   context->disconnectPluginListener(this);
   extensionRegistry->RemoveListener(this);
   // flush the apps
   apps.clear();
   branding.reset();
   missingProductReported = false;
   launcherTracker->close();
 }
 
 IBranding* ApplicationContainer::GetBranding() const
 {
   if (branding)
   {
     return branding.data();
   }
 
   // try pluginContext properties
   if (context == nullptr) return nullptr;
   QString productId = context->getProperty(PROP_PRODUCT).toString();
   if (productId.isEmpty()) return nullptr;
 
   QList<IConfigurationElement::Pointer> entries = extensionRegistry->GetConfigurationElementsFor(PI_RUNTIME, PT_PRODUCTS, productId);
   if (!entries.isEmpty())
   {
     // There should only be one product with the given id so just take the first element
     branding.reset(new ProductExtensionBranding(productId, entries[0]));
     return branding.data();
   }
   QList<IConfigurationElement::Pointer> elements = extensionRegistry->GetConfigurationElementsFor(PI_RUNTIME, PT_PRODUCTS);
   for (const auto &element : qAsConst(elements))
   {
     if (element->GetName().compare("provider", Qt::CaseInsensitive) == 0)
     {
       try
       {
         IProductProvider* provider = element->CreateExecutableExtension<IProductProvider>("run");
         QList<IProduct::Pointer> products = provider->GetProducts();
         for (const auto &product : qAsConst(products))
         {
           if (productId.compare(product->GetId(), Qt::CaseInsensitive) == 0)
           {
             branding.reset(new ProviderExtensionBranding(product));
             return branding.data();
           }
         }
       }
       catch (const CoreException&)
       {
         BERRY_WARN << "Problem creating the provider registered by " << element->GetParent()->ToString() << ".";
       }
     }
   }
 
   if (!missingProductReported)
   {
     BERRY_WARN << "Product " << productId << " could not be found.";
     missingProductReported = true;
   }
   return nullptr;
 }
 
 ctkPluginContext* ApplicationContainer::GetContext() const
 {
   return context;
 }
 
 ApplicationDescriptor* ApplicationContainer::GetAppDescriptor(const QString& applicationId)
 {
   ApplicationDescriptor* result = nullptr;
   {
-    QMutexLocker l(&lock);
+    QMutexLocker l(&appDescLock);
     auto iter = apps.find(applicationId);
     result = iter == apps.end() ? nullptr : iter.value();
   }
 
   if (result == nullptr)
   {
     RegisterAppDescriptor(applicationId); // try again just in case we are waiting for an event
     {
-      QMutexLocker l(&lock);
+      QMutexLocker l(&appDescLock);
       auto iter = apps.find(applicationId);
       result = iter == apps.end() ? nullptr : iter.value();
     }
   }
   return result;
 }
 
 ApplicationDescriptor* ApplicationContainer::CreateAppDescriptor(const SmartPointer<IExtension>& appExtension)
 {
   if (org_blueberry_core_runtime_Activator::DEBUG)
   {
     BERRY_INFO << "Creating application descriptor: " << appExtension->GetUniqueIdentifier();
   }
   QString iconPath;
   {
-    QMutexLocker l(&lock);
+    QMutexLocker l(&appDescLock);
     auto iter = apps.find(appExtension->GetUniqueIdentifier());
     ApplicationDescriptor* appDescriptor = iter == apps.end() ? nullptr : iter.value();
     if (appDescriptor != nullptr)
     {
       return appDescriptor;
     }
 
     // the appDescriptor does not exist for the app ID; create it
     QList<IConfigurationElement::Pointer> configs = appExtension->GetConfigurationElements();
     ApplicationDescriptor::Flags flags = ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL | ApplicationDescriptor::FLAG_VISIBLE |
                                          ApplicationDescriptor::FLAG_TYPE_MAIN_THREAD;
     int cardinality = 0;
     if (!configs.isEmpty())
     {
       QString sVisible = configs[0]->GetAttribute(PT_APP_VISIBLE);
       if (!sVisible.isEmpty() && sVisible.compare("true", Qt::CaseInsensitive) != 0)
       {
         flags &= ~(ApplicationDescriptor::FLAG_VISIBLE);
       }
       QString sThread = configs[0]->GetAttribute(PT_APP_THREAD);
       if (PT_APP_THREAD_ANY == sThread)
       {
         flags |= ApplicationDescriptor::FLAG_TYPE_ANY_THREAD;
         flags &= ~(ApplicationDescriptor::FLAG_TYPE_MAIN_THREAD);
       }
       QString sCardinality = configs[0]->GetAttribute(PT_APP_CARDINALITY);
       if (!sCardinality.isEmpty())
       {
         flags &= ~(ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL); // clear the global bit
         if (PT_APP_CARDINALITY_SINGLETON_SCOPED == sCardinality)
         {
           flags |= ApplicationDescriptor::FLAG_CARD_SINGLETON_SCOPED;
         }
         else if (PT_APP_CARDINALITY_UNLIMITED == sCardinality)
         {
           flags |= ApplicationDescriptor::FLAG_CARD_UNLIMITED;
         }
         else if (PT_APP_CARDINALITY_SINGLETON_GLOBAL == sCardinality)
         {
           flags |= ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL;
         }
         else
         {
           bool okay = false;
           cardinality = sCardinality.toInt(&okay);
           if (okay)
           {
             flags |= ApplicationDescriptor::FLAG_CARD_LIMITED;
           }
           else
           {
             // TODO should we log this?
             // just fall back to the default
             flags |= ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL;
           }
         }
       }
       QString defaultApp = GetDefaultAppId();
       QString appId = appExtension->GetUniqueIdentifier();
       if (defaultApp == appId)
       {
         flags |= ApplicationDescriptor::FLAG_DEFAULT_APP;
       }
       iconPath = configs[0]->GetAttribute(PT_APP_ICON);
     }
     appDescriptor = new ApplicationDescriptor(org_blueberry_core_runtime_Activator::GetPlugin(appExtension->GetContributor()),
                                               appExtension->GetUniqueIdentifier(), appExtension->GetLabel(), iconPath, flags, cardinality, this);
     // register the appDescriptor as a service
     ctkServiceRegistration sr = context->registerService<ctkApplicationDescriptor>(appDescriptor, appDescriptor->GetServiceProperties());
     appDescriptor->SetServiceRegistration(sr);
     // save the app descriptor in the cache
     apps.insert(appExtension->GetUniqueIdentifier(), appDescriptor);
     return appDescriptor;
   }
 }
 
 ApplicationDescriptor*ApplicationContainer::RemoveAppDescriptor(const QString& applicationId)
 {
   if (org_blueberry_core_runtime_Activator::DEBUG)
   {
     BERRY_INFO << "Removing application descriptor: " << applicationId;
   }
 
   {
-    QMutexLocker l(&lock);
+    QMutexLocker l(&appDescLock);
     ApplicationDescriptor* appDescriptor = apps.take(applicationId);
     if (appDescriptor == nullptr)
     {
       return nullptr;
     }
     appDescriptor->Unregister();
     return appDescriptor;
   }
 }
 
 void ApplicationContainer::StartDefaultApp(bool delayError)
 {
   // find the default application
   QString applicationId = GetDefaultAppId();
   ApplicationDescriptor* defaultDesc = nullptr;
   QHash<QString, QVariant> args;
   args.insert(ApplicationDescriptor::APP_DEFAULT, true);
   if (applicationId.isEmpty() && !delayError)
   {
     // the application id is not set; use a descriptor that will throw an exception
     args.insert(ErrorApplication::ERROR_EXCEPTION, QString("No application id has been found."));
     defaultDesc = GetAppDescriptor(EXT_ERROR_APP);
   }
   else
   {
     defaultDesc = GetAppDescriptor(applicationId);
     if (defaultDesc == nullptr && !delayError)
     {
       // the application id is not available in the registry; use a descriptor that will throw an exception
       args.insert(ErrorApplication::ERROR_EXCEPTION, QString("Application \"%1\" could not be found in the registry. The applications available are: %2.")
                   .arg(applicationId)
                   .arg(GetAvailableAppsMsg()));
       defaultDesc = GetAppDescriptor(EXT_ERROR_APP);
     }
   }
   if (delayError && defaultDesc == nullptr)
   {
     // could not find the application; but we want to delay the error.
     // another bundle may get installed that provides the application
     // before we actually try to launch it.
     missingApp = true;
     return;
   }
   if (defaultDesc != nullptr)
   {
     defaultDesc->launch(args);
   }
   else
   {
     throw ctkApplicationException(ctkApplicationException::APPLICATION_INTERNAL_ERROR, "No application id has been found.");
   }
 }
 
 void ApplicationContainer::RegisterAppDescriptors()
 {
   QList<IExtension::Pointer> availableApps = GetAvailableAppExtensions();
   for (int i = 0; i < availableApps.size(); i++)
   {
     CreateAppDescriptor(availableApps[i]);
   }
 }
 
 void ApplicationContainer::RegisterAppDescriptor(const QString& applicationId)
 {
   IExtension::Pointer appExtension = GetAppExtension(applicationId);
   if (appExtension.IsNotNull())
   {
     CreateAppDescriptor(appExtension);
   }
 }
 
 QList<SmartPointer<IExtension> > ApplicationContainer::GetAvailableAppExtensions() const
 {
   IExtensionPoint::Pointer point = extensionRegistry->GetExtensionPoint(PI_OSGI + '.' + PT_APPLICATIONS);
   if (point.IsNull())
   {
     return QList<IExtension::Pointer>();
   }
   return point->GetExtensions();
 }
 
 QString ApplicationContainer::GetAvailableAppsMsg() const
 {
   QList<IExtension::Pointer> availableApps = GetAvailableAppExtensions();
   QString availableAppsMsg = "<NONE>";
   if (!availableApps.isEmpty())
   {
     availableAppsMsg = availableApps.front()->GetUniqueIdentifier();
     for (const auto &availableApp : qAsConst(availableApps))
     {
       availableAppsMsg = availableAppsMsg + ", " + availableApp->GetUniqueIdentifier();
     }
   }
   return availableAppsMsg;
 }
 
 SmartPointer<IExtension> ApplicationContainer::GetAppExtension(const QString& applicationId) const
 {
   return extensionRegistry->GetExtension(PI_OSGI, PT_APPLICATIONS, applicationId);
 }
 
 void ApplicationContainer::Launch(ApplicationHandle* appHandle)
 {
   bool isDefault = appHandle->IsDefault();
   if (appHandle->getApplicationDescriptor()->GetThreadType() == ApplicationDescriptor::FLAG_TYPE_MAIN_THREAD)
   {
     // use the ApplicationLauncher provided by the framework to ensure it is launched on the main thread
     //DefaultApplicationListener curDefaultApplicationListener = null;
     MainApplicationLauncher* curMissingAppLauncher = nullptr;
     ctkApplicationLauncher* appLauncher = nullptr;
     {
       QMutexLocker l(this);
       appLauncher = launcherTracker->getService();
       if (appLauncher == nullptr)
       {
         if (isDefault)
         {
           // we need to wait to allow the ApplicationLauncher to get registered;
           // save the handle to be launched as soon as the ApplicationLauncher is available
           defaultMainThreadAppHandle = appHandle;
           return;
         }
         throw ctkApplicationException(ctkApplicationException::APPLICATION_INTERNAL_ERROR,
                                       QString("The main thread is not available to launch the application: %1").arg(appHandle->getInstanceId()));
       }
       //curDefaultApplicationListener = defaultAppListener;
       curMissingAppLauncher = missingAppLauncher.data();
     }
     //if (curDefaultApplicationListener != nullptr)
     //{
     //  curDefaultApplicationListener->launch(appHandle);
     //}
     //else
     if (curMissingAppLauncher != nullptr)
     {
       curMissingAppLauncher->Launch(appHandle);
     }
     else
     {
       appLauncher->launch(appHandle, appHandle->GetArguments()[IApplicationContext::APPLICATION_ARGS]);
     }
   }
   else
   {
     if (isDefault)
     {
       //DefaultApplicationListener curDefaultApplicationListener = null;
       MainApplicationLauncher* curMissingAppLauncher = nullptr;
       ctkApplicationLauncher* appLauncher = nullptr;
       {
         QMutexLocker l(this);
         appLauncher = launcherTracker->getService();
         //if (defaultAppListener == nullptr)
         //{
         //  defaultAppListener = new DefaultApplicationListener(appHandle);
         //}
         //curDefaultApplicationListener = defaultAppListener;
         if (appLauncher == nullptr)
         {
           // we need to wait to allow the ApplicationLauncher to get registered;
           // save the default app listener to be launched as soon as the ApplicationLauncher is available
           //defaultMainThreadAppHandle = curDefaultApplicationListener;
           return;
         }
         curMissingAppLauncher = missingAppLauncher.data();
       }
       if (curMissingAppLauncher != nullptr)
       {
         //curMissingAppLauncher->Launch(curDefaultApplicationListener);
       }
       else
       {
         //appLauncher->Launch(curDefaultApplicationListener, QVariant());
       }
     }
     else
     {
       //AnyThreadAppLauncher.launchEclipseApplication(appHandle);
     }
   }
 }
 
 void ApplicationContainer::PluginChanged(const ctkPluginEvent& event)
 {
   // if this is not the system bundle stopping then ignore the event
   if ((ctkPluginEvent::STOPPING & event.getType()) == 0 || event.getPlugin()->getPluginId() != 0)
   {
     return;
   }
   // The system bundle is stopping; better stop all applications and containers now
   StopAllApps();
 }
 
 void ApplicationContainer::StopAllApps()
 {
   // get a stapshot of running applications
   QList<ctkServiceReference> runningRefs = context->getServiceReferences<ctkApplicationHandle>("(!(application.state=STOPPING))");
   for (const auto &runningRef : qAsConst(runningRefs))
   {
     ctkApplicationHandle* handle = context->getService<ctkApplicationHandle>(runningRef);
     try
     {
       if (handle != nullptr)
       {
         handle->destroy();
       }
     }
     catch (const std::exception&)
     {
       BERRY_WARN << QString("An error occurred while stopping the application: %1").arg(handle->getInstanceId());
     }
     if (handle != nullptr)
     {
       context->ungetService(runningRef);
     }
   }
 }
 
 QString ApplicationContainer::GetDefaultAppId() const
 {
   if (!defaultAppId.isNull())
   {
     return defaultAppId;
   }
 
   // try plugin context properties
   defaultAppId = context->getProperty(ApplicationContainer::PROP_BLUEBERRY_APPLICATION).toString();
   if (!defaultAppId.isEmpty())
   {
     return defaultAppId;
   }
 
   //Derive the application from the product information
   defaultAppId = GetBranding() == nullptr ? QString("") : GetBranding()->GetApplication();
   return defaultAppId;
 }
 
 void ApplicationContainer::Lock(ApplicationHandle* /*appHandle*/)
 {
   /*
   ApplicationDescriptor eclipseApp = (ApplicationDescriptor) appHandle.getApplicationDescriptor();
   {
-    QMutexLocker l(&lock);
+    QMutexLocker l(&appDescLock);
     switch (isLocked(eclipseApp))
     {
     case NOT_LOCKED :
       break;
     case LOCKED_SINGLETON_GLOBAL_RUNNING :
       throw new ApplicationException(ApplicationException.APPLICATION_NOT_LAUNCHABLE, NLS.bind(Messages.singleton_running, activeGlobalSingleton.getInstanceId()));
     case LOCKED_SINGLETON_GLOBAL_APPS_RUNNING :
       throw new ApplicationException(ApplicationException.APPLICATION_NOT_LAUNCHABLE, Messages.apps_running);
     case LOCKED_SINGLETON_SCOPED_RUNNING :
       throw new ApplicationException(ApplicationException.APPLICATION_NOT_LAUNCHABLE, NLS.bind(Messages.singleton_running, activeScopedSingleton.getInstanceId()));
     case LOCKED_SINGLETON_LIMITED_RUNNING :
       throw new ApplicationException(ApplicationException.APPLICATION_NOT_LAUNCHABLE, NLS.bind(Messages.max_running, eclipseApp.getApplicationId()));
     case LOCKED_MAIN_THREAD_RUNNING :
       throw new ApplicationException(ApplicationException.APPLICATION_NOT_LAUNCHABLE, NLS.bind(Messages.main_running, activeMain.getInstanceId()));
     default :
       break;
     }
 
     // ok we can now successfully lock the container
     switch (eclipseApp.getCardinalityType())
     {
     case ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL :
       activeGlobalSingleton = appHandle;
       break;
     case ApplicationDescriptor::FLAG_CARD_SINGLETON_SCOPED :
       activeScopedSingleton = appHandle;
       break;
     case ApplicationDescriptor::FLAG_CARD_LIMITED :
       if (activeLimited == null)
         activeLimited = new HashMap(3);
       ArrayList limited = (ArrayList) activeLimited.get(eclipseApp.getApplicationId());
       if (limited == null)
       {
         limited = new ArrayList(eclipseApp.getCardinality());
         activeLimited.put(eclipseApp.getApplicationId(), limited);
       }
       limited.add(appHandle);
       break;
     case ApplicationDescriptor::FLAG_CARD_UNLIMITED :
       break;
     default :
       break;
     }
     if (eclipseApp.getThreadType() == ApplicationDescriptor::FLAG_TYPE_MAIN_THREAD)
     {
       activeMain = appHandle;
     }
     activeHandles.add(appHandle);
     refreshAppDescriptors();
   }
   */
 }
 
 void ApplicationContainer::Unlock(ApplicationHandle* /*appHandle*/)
 {
   /*
-  QMutexLocker l(&lock);
+  QMutexLocker l(&appDescLock);
   if (activeGlobalSingleton == appHandle)
     activeGlobalSingleton = null;
   else if (activeScopedSingleton == appHandle)
     activeScopedSingleton = null;
   else if (((ApplicationDescriptor) appHandle.getApplicationDescriptor()).getCardinalityType() == ApplicationDescriptor::FLAG_CARD_LIMITED) {
     if (activeLimited != null) {
       ArrayList limited = (ArrayList) activeLimited.get(((ApplicationDescriptor) appHandle.getApplicationDescriptor()).getApplicationId());
       if (limited != null)
         limited.remove(appHandle);
     }
   }
   if (activeMain == appHandle)
     activeMain = null;
   if (activeHandles.remove(appHandle))
     refreshAppDescriptors(); // only refresh descriptors if we really unlocked something
 */
 }
 
 int ApplicationContainer::IsLocked(const ApplicationDescriptor* /*eclipseApp*/) const
 {
   /*
   {
-    QMutexLocker l(&lock);
+    QMutexLocker l(&appDescLock);
     if (activeGlobalSingleton != null)
       return LOCKED_SINGLETON_GLOBAL_RUNNING;
     switch (eclipseApp.getCardinalityType()) {
     case ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL :
       if (activeHandles.size() > 0)
         return LOCKED_SINGLETON_GLOBAL_APPS_RUNNING;
       break;
     case ApplicationDescriptor::FLAG_CARD_SINGLETON_SCOPED :
       if (activeScopedSingleton != null)
         return LOCKED_SINGLETON_SCOPED_RUNNING;
       break;
     case ApplicationDescriptor::FLAG_CARD_LIMITED :
       if (activeLimited != null) {
         ArrayList limited = (ArrayList) activeLimited.get(eclipseApp.getApplicationId());
         if (limited != null && limited.size() >= eclipseApp.getCardinality())
           return LOCKED_SINGLETON_LIMITED_RUNNING;
       }
       break;
     case ApplicationDescriptor::FLAG_CARD_UNLIMITED :
       break;
     default :
       break;
     }
     if (eclipseApp.getThreadType() == ApplicationDescriptor::FLAG_TYPE_MAIN_THREAD && activeMain != null)
       return LOCKED_MAIN_THREAD_RUNNING;
     return NOT_LOCKED;
   }
   */
   return NOT_LOCKED;
 }
 
 ctkApplicationLauncher* ApplicationContainer::addingService(const ctkServiceReference& reference)
 {
   ctkApplicationLauncher* appLauncher = nullptr;
   ctkApplicationRunnable* appRunnable = nullptr;
   {
     QMutexLocker l(this);
     appLauncher = context->getService<ctkApplicationLauncher>(reference);
     // see if there is a default main threaded application waiting to run
     appRunnable = defaultMainThreadAppHandle;
     // null out so we do not attempt to start this handle again
     defaultMainThreadAppHandle = nullptr;
     if (appRunnable == nullptr && missingApp)
     {
       missingAppLauncher.reset(new MainApplicationLauncher(this));
       appRunnable = missingAppLauncher.data();
       missingApp = false;
     }
   }
   if (appRunnable != nullptr)
   {
     // found a main threaded app; start it now that the app launcher is available
     ApplicationHandle* handle = dynamic_cast<ApplicationHandle*>(appRunnable);
     appLauncher->launch(appRunnable, handle ? handle->GetArguments()[IApplicationContext::APPLICATION_ARGS] : QVariant());
   }
   return appLauncher;
 }
 
 void ApplicationContainer::modifiedService(const ctkServiceReference& /*reference*/, ctkApplicationLauncher* /*service*/)
 {
   // Do nothing
 }
 
 void ApplicationContainer::removedService(const ctkServiceReference& /*reference*/, ctkApplicationLauncher* /*service*/)
 {
   // Do nothing
 }
 
 void ApplicationContainer::Added(const QList<SmartPointer<IExtension> >& extensions)
 {
   for (const IExtension::Pointer &extension : extensions)
   {
     CreateAppDescriptor(extension);
   }
 }
 
 void ApplicationContainer::Added(const QList<SmartPointer<IExtensionPoint> >& /*extensionPoints*/)
 {
   // nothing
 }
 
 void ApplicationContainer::Removed(const QList<SmartPointer<IExtension> >& extensions)
 {
   for (const IExtension::Pointer &extension : extensions)
   {
     RemoveAppDescriptor(extension->GetUniqueIdentifier());
   }
 }
 
 void ApplicationContainer::Removed(const QList<SmartPointer<IExtensionPoint> >& /*extensionPoints*/)
 {
   // nothing
 }
 
 void ApplicationContainer::RefreshAppDescriptors()
 {
-  QMutexLocker l(&lock);
+  QMutexLocker l(&appDescLock);
   for (ApplicationDescriptor* app : apps.values())
   {
     app->RefreshProperties();
   }
 }
 
 
 
 }
diff --git a/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.h b/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.h
index 778bce9295..6cda616af8 100644
--- a/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.h
+++ b/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.h
@@ -1,180 +1,180 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef BERRYAPPLICATIONCONTAINER_H
 #define BERRYAPPLICATIONCONTAINER_H
 
 #include <berryIRegistryEventListener.h>
 
 #include <ctkServiceTracker.h>
 #include <ctkServiceTrackerCustomizer.h>
 
 #include <QObject>
 #include <QMutex>
 
 struct ctkApplicationLauncher;
 struct ctkApplicationRunnable;
 
 namespace berry {
 
 struct IBranding;
 struct IExtensionRegistry;
 
 class ApplicationDescriptor;
 class ApplicationHandle;
 class MainApplicationLauncher;
 
 /*
  * This container will discover installed BlueBerry applications and register the
  * appropriate ctkApplicationDescriptor service with the service registry.
  */
 class ApplicationContainer : public QObject, public QMutex, private IRegistryEventListener,
     private ctkServiceTrackerCustomizer<ctkApplicationLauncher*>
 {
   Q_OBJECT
 
 private:
 
   static const QString PI_RUNTIME; // = "org.blueberry.core.runtime";
   static const QString PT_APPLICATIONS; // = "applications";
   static const QString PT_APP_VISIBLE; // = "visible";
   static const QString PT_APP_THREAD; // = "thread";
   static const QString PT_APP_THREAD_ANY; // = "any";
   static const QString PT_APP_CARDINALITY; // = "cardinality";
   static const QString PT_APP_CARDINALITY_SINGLETON_GLOBAL; // = "singleton-global";
   static const QString PT_APP_CARDINALITY_SINGLETON_SCOPED; // = "singleton-scoped";
   static const QString PT_APP_CARDINALITY_UNLIMITED; // = "*";
   static const QString PT_APP_ICON; // = "icon";
   static const QString PT_PRODUCTS; // = "products";
   static const QString EXT_ERROR_APP; // = "org.blueberry.core.runtime.app.error";
 
   static const QString PROP_PRODUCT; // = "blueberry.product";
   static const QString PROP_BLUEBERRY_APPLICATION; // = "blueberry.application";
   static const QString PROP_BLUEBERRY_APPLICATION_LAUNCH_DEFAULT; // = "blueberry.application.launchDefault";
 
   static const int NOT_LOCKED; // = 0;
   static const int LOCKED_SINGLETON_GLOBAL_RUNNING; // = 1;
   static const int LOCKED_SINGLETON_GLOBAL_APPS_RUNNING; // = 2;
   static const int LOCKED_SINGLETON_SCOPED_RUNNING; // = 3;
   static const int LOCKED_SINGLETON_LIMITED_RUNNING; // = 4;
   static const int LOCKED_MAIN_THREAD_RUNNING; // = 5;
 
   ctkPluginContext* context;
 
-  QMutex lock;
+  QMutex appDescLock;
 
   // A map of ApplicationDescriptors keyed by application ID
   /* @GuardedBy(lock) */
   QHash<QString, ApplicationDescriptor*> apps;
 
   IExtensionRegistry* extensionRegistry;
   QScopedPointer<ctkServiceTracker<ctkApplicationLauncher*>> launcherTracker;
   mutable QScopedPointer<IBranding> branding;
   mutable bool missingProductReported;
 
   /* @GuardedBy(lock) */
   QList<ApplicationHandle*> activeHandles; // the currently active application handles
   /* @GuardedBy(lock) */
   ApplicationHandle* activeMain; // the handle currently running on the main thread
   /* @GuardedBy(lock) */
   ApplicationHandle* activeGlobalSingleton; // the current global singleton handle
   /* @GuardedBy(lock) */
   ApplicationHandle* activeScopedSingleton; // the current scoped singleton handle
   /* @GuardedBy(lock) */
   QHash<QString, QList<ApplicationHandle*> > activeLimited; // Map of handles that have cardinality limits
 
   mutable QString defaultAppId;
   //DefaultApplicationListener defaultAppListener;
   ctkApplicationRunnable* defaultMainThreadAppHandle; // holds the default app handle to be run on the main thread
   volatile bool missingApp;
   QScopedPointer<MainApplicationLauncher> missingAppLauncher;
 
 public:
 
   ApplicationContainer(ctkPluginContext* context, IExtensionRegistry* extensionRegistry);
   ~ApplicationContainer() override;
 
   void Start();
   void Stop();
 
   IBranding* GetBranding() const;
 
   ctkPluginContext* GetContext() const;
 
   void Launch(ApplicationHandle* appHandle);
 
   void Lock(ApplicationHandle* appHandle);
   void Unlock(ApplicationHandle* appHandle);
   int IsLocked(const ApplicationDescriptor* eclipseApp) const;
 
   void StartDefaultApp(bool delayError);
 
 private:
 
   Q_DISABLE_COPY(ApplicationContainer)
 
   friend class ApplicationHandle;
 
   /*
    * Only used to find the default application
    */
   ApplicationDescriptor* GetAppDescriptor(const QString& applicationId);
 
   ApplicationDescriptor* CreateAppDescriptor(const SmartPointer<IExtension>& appExtension);
 
   ApplicationDescriptor* RemoveAppDescriptor(const QString& applicationId);
 
   /*
    * Registers an ApplicationDescriptor service for each eclipse application
    * available in the extension registry.
    */
   void RegisterAppDescriptors();
 
   void RegisterAppDescriptor(const QString& applicationId);
 
   /*
    * Returns a list of all the available application IDs which are available
    * in the extension registry.
    */
   QList<SmartPointer<IExtension> > GetAvailableAppExtensions() const;
 
   QString GetAvailableAppsMsg() const;
 
   /*
    * Returns the application extension for the specified application ID.
    * A RuntimeException is thrown if the extension does not exist for the
    * given application ID.
    */
   SmartPointer<IExtension> GetAppExtension(const QString& applicationId) const;
 
   Q_SLOT void PluginChanged(const ctkPluginEvent& event);
 
   void StopAllApps();
 
   QString GetDefaultAppId() const;
 
   ctkApplicationLauncher* addingService(const ctkServiceReference& reference) override;
   void modifiedService(const ctkServiceReference& reference, ctkApplicationLauncher* service) override;
   void removedService(const ctkServiceReference& reference, ctkApplicationLauncher* service) override;
 
   void Added(const QList<SmartPointer<IExtension> >& extensions) override;
   void Added(const QList<SmartPointer<IExtensionPoint> >& extensionPoints) override;
   void Removed(const QList<SmartPointer<IExtension> >& extensions) override;
   void Removed(const QList<SmartPointer<IExtensionPoint> >& extensionPoints) override;
 
   void RefreshAppDescriptors();
 
 };
 
 }
 
 #endif // BERRYAPPLICATIONCONTAINER_H