diff --git a/Modules/QmitkExt/QmitkBoundingObjectWidget.cpp b/Modules/QmitkExt/QmitkBoundingObjectWidget.cpp
index 747cbea0ac..5ad8668afd 100644
--- a/Modules/QmitkExt/QmitkBoundingObjectWidget.cpp
+++ b/Modules/QmitkExt/QmitkBoundingObjectWidget.cpp
@@ -1,453 +1,469 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-31 16:40:27 +0200 (Mi, 31 Mrz 2010) $
 Version:   $Revision: 1.12 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkBoundingObjectWidget.h"
 
 #include <mitkCone.h>
 #include <mitkCylinder.h>
 #include <mitkCuboid.h>
 #include <mitkEllipsoid.h>
 #include <mitkAffineInteractor.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkLine.h>
 
 #include <QPushButton>
 #include <QCheckBox>
 #include <QBoxLayout>
 #include <QStringList>
 #include <QInputDialog>
 
 #include "btnCube.xpm"
 #include "btnCylinder.xpm"
 #include "btnEllipsoid.xpm"
 #include "btnPyramid.xpm"
 
 
 QmitkBoundingObjectWidget::QmitkBoundingObjectWidget (QWidget* parent, Qt::WindowFlags f ):QWidget( parent, f ),
 m_DataStorage(NULL),
 m_lastSelectedItem(NULL),
 m_lastAffineObserver(NULL),
-m_ItemNodeMap()
+m_ItemNodeMap(),
+m_BoundingObjectCounter(1)
 {
 
   QBoxLayout* mainLayout = new QVBoxLayout(this);
 
   QHBoxLayout* buttonLayout = new QHBoxLayout();
 
   QStringList boList;
   boList << tr("add") << tr("cube") << tr("cone") << tr("ellipse") << tr("cylinder");
   m_addComboBox = new QComboBox();
   m_addComboBox->addItems(boList);
   m_addComboBox->setItemIcon(1, QIcon(btnCube_xpm));
   m_addComboBox->setItemIcon(2, QIcon(btnPyramid_xpm));
   m_addComboBox->setItemIcon(3, QIcon(btnEllipsoid_xpm));
   m_addComboBox->setItemIcon(4, QIcon(btnCylinder_xpm));
 
   buttonLayout->addWidget(m_addComboBox);
 
   m_DelButton = new QPushButton("del");
   buttonLayout->addWidget(m_DelButton);
 
 
   m_SaveButton = new QPushButton("save");
   buttonLayout->addWidget(m_SaveButton);
   m_SaveButton->setEnabled(false);
 
   m_LoadButton = new QPushButton("load");
   buttonLayout->addWidget(m_LoadButton);
   m_LoadButton->setEnabled(false);
 
   m_TreeWidget = new QTreeWidget(this);
   m_TreeWidget->setColumnCount(3);
   QStringList sList;
   sList << tr("name") << tr("inverted") << tr("visible"); 
   m_TreeWidget->setHeaderLabels(sList); 
   m_TreeWidget->setColumnWidth(0, 250);
   m_TreeWidget->setColumnWidth(1, 50);
   m_TreeWidget->setColumnWidth(2, 50);
   m_TreeWidget->setAutoScroll(true);
   m_TreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
 
   mainLayout->addWidget(m_TreeWidget);
   mainLayout->addLayout(buttonLayout);
 
   connect( m_addComboBox , SIGNAL(currentIndexChanged(int)), this, SLOT(CreateBoundingObject(int)) );
   connect( m_TreeWidget, SIGNAL(itemSelectionChanged()), this, SLOT(SelectionChanged()) );
   /*connect( m_SaveButton, SIGNAL(clicked()), this, SLOT(OnSaveButtonClicked()) );
   connect( m_LoadButton, SIGNAL(clicked()), this, SLOT(OnLoadButtonClicked()) );*/
   connect( m_DelButton, SIGNAL(clicked()), this, SLOT(OnDelButtonClicked()) );
 
   connect(m_TreeWidget, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)), this, SLOT(OnItemDoubleClicked(QTreeWidgetItem*, int)) );
   connect(m_TreeWidget, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(OnItemDataChanged(QTreeWidgetItem*, int)) );
 
 }
 
 QmitkBoundingObjectWidget::~QmitkBoundingObjectWidget()
 {
 
 }
 
 void QmitkBoundingObjectWidget::setEnabled(bool flag)
 {
   ItemNodeMapType::iterator it = m_ItemNodeMap.begin();
   while( it != m_ItemNodeMap.end())
   {
     mitk::DataNode* node = it->second;
     QTreeWidgetItem* item = it->first;
 
     if (flag)
       node->SetVisibility(item->checkState(2));
     else
       node->SetVisibility(flag);
     ++it;
   }
 
   QWidget::setEnabled(flag);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkBoundingObjectWidget::SelectionChanged()
 {
 
   QList<QTreeWidgetItem*> selectedItems = m_TreeWidget->selectedItems();
   if (selectedItems.size() < 1)
     return;
 
   QTreeWidgetItem* selectedItem = selectedItems.first();
 
   if (selectedItem == m_lastSelectedItem)
     return;
 
   if (m_lastSelectedItem != NULL)
   {
     m_TreeWidget->closePersistentEditor(m_lastSelectedItem, 0);
 
     ItemNodeMapType::iterator it = m_ItemNodeMap.find(m_lastSelectedItem);
 
     if (it != m_ItemNodeMap.end())
     {
       mitk::DataNode* last_node = it->second;
 
       //remove observer
       last_node->RemoveObserver(m_lastAffineObserver);
 
       //get and remove interactor
       mitk::AffineInteractor::Pointer last_interactor = dynamic_cast<mitk::AffineInteractor*> (last_node->GetInteractor());
       if (last_interactor)
         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(last_interactor);
     }
   }
 
   ItemNodeMapType::iterator it = m_ItemNodeMap.find(selectedItem);
   if (it == m_ItemNodeMap.end())
     return;
 
   mitk::DataNode* new_node = it->second;
 
   mitk::AffineInteractor::Pointer new_interactor = mitk::AffineInteractor::New("AffineInteractions ctrl-drag", new_node);
   new_node->SetInteractor(new_interactor);
 
   mitk::GlobalInteraction::GetInstance()->AddInteractor(new_interactor);
 
   //create observer for node
   itk::ReceptorMemberCommand<QmitkBoundingObjectWidget>::Pointer command = itk::ReceptorMemberCommand<QmitkBoundingObjectWidget>::New();
   command->SetCallbackFunction(this, &QmitkBoundingObjectWidget::OnBoundingObjectModified);
   m_lastAffineObserver = new_node->AddObserver(mitk::AffineInteractionEvent(), command);
 
   m_lastSelectedItem = selectedItem;
 }
 
 void QmitkBoundingObjectWidget::AddItem(mitk::DataNode* node)
 {
   mitk::BoundingObject* boundingObject;
 
   boundingObject = dynamic_cast<mitk::BoundingObject*> (node->GetData());
 
   std::string name;
   node->GetStringProperty("name", name);
 
   if (boundingObject)
   {
     QTreeWidgetItem* item = new QTreeWidgetItem();
     item->setData(0, Qt::EditRole,  QString::fromLocal8Bit(name.c_str()));
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
 
     //checkbox for positive flag
     item->setData(1, Qt::CheckStateRole, tr(""));
     item->setCheckState(1, Qt::Unchecked);
 
     //checkbox for visibleflag
     item->setData(2, Qt::CheckStateRole, tr(""));
     item->setCheckState(2, Qt::Checked);
 
     m_TreeWidget->addTopLevelItem(item);
 
     m_ItemNodeMap.insert(std::make_pair(item, node));
 
     m_TreeWidget->selectAll();
     QList<QTreeWidgetItem*> items = m_TreeWidget->selectedItems();
     for( int i = 0; i<items.size(); i++)
     {
       m_TreeWidget->setItemSelected(items.at(i), false);
     }
 
     m_TreeWidget->setItemSelected(item, true);
 
 
   }
   else 
     MITK_ERROR << name << " is not a bounding object or does not exist in data storage" << endl;
 }
 
 void QmitkBoundingObjectWidget::OnItemDoubleClicked(QTreeWidgetItem* item, int col)
 {
   if (col == 0)
   {
     m_TreeWidget->openPersistentEditor(item, col);
   }
 }
 
 void QmitkBoundingObjectWidget::OnItemDataChanged(QTreeWidgetItem *item, int col)
 {
   if (m_ItemNodeMap.size() < 1)
     return;
 
   ItemNodeMapType::iterator it = m_ItemNodeMap.find(item);
   if (it == m_ItemNodeMap.end())
     return;
 
   mitk::DataNode* node = it->second;
 
   //name
   if (col == 0)
   {
     m_TreeWidget->closePersistentEditor(item, col);
     node->SetName(item->text(0).toLocal8Bit().data());
   }
   //positive
   else if (col == 1)
   {
     mitk::BoundingObject* boundingObject = dynamic_cast<mitk::BoundingObject*> (node->GetData());
     if (boundingObject)
       boundingObject->SetPositive(!(item->checkState(1)));
     emit BoundingObjectsChanged();
   }
   //visible
   else if (col == 2)
   {
     node->SetVisibility(item->checkState(2));
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
 
 }
 
 void QmitkBoundingObjectWidget::RemoveItem()
 {
   //selection mode is set to single selection, so there should not be more than one selected item
   QList <QTreeWidgetItem*> selectedItems = m_TreeWidget->selectedItems();
   QTreeWidgetItem* item = selectedItems.first();
   QString str = item->text(0);
 
   ItemNodeMapType::iterator it = m_ItemNodeMap.find(item);
 
   if (it == m_ItemNodeMap.end())
     return;
 
   mitk::DataNode* node = it->second;
   mitk::BoundingObject* boundingObject;
 
   if (node)
   {
     boundingObject = dynamic_cast<mitk::BoundingObject*> (node->GetData());
     if (boundingObject)
     {
       //delete item;
       m_TreeWidget->takeTopLevelItem(m_TreeWidget->indexOfTopLevelItem(item));
       m_ItemNodeMap.erase(m_ItemNodeMap.find(item));
       m_DataStorage->Remove(node);
     }
   }
 }
 
+void QmitkBoundingObjectWidget::RemoveAllItems()
+{
+  ItemNodeMapType::iterator it = m_ItemNodeMap.begin();
+
+  while( it != m_ItemNodeMap.end() )
+  {
+    m_TreeWidget->takeTopLevelItem( m_TreeWidget->indexOfTopLevelItem(it->first) );
+    m_ItemNodeMap.erase(m_ItemNodeMap.find(it->first));
+
+    ++it;
+  }
+
+  m_BoundingObjectCounter = 1;
+}
+
+
 mitk::BoundingObject::Pointer QmitkBoundingObjectWidget::GetSelectedBoundingObject()
 {
   mitk::BoundingObject* boundingObject;
   mitk::DataNode* node = this->GetSelectedBoundingObjectNode();
 
   if (node)
   {
     boundingObject = dynamic_cast<mitk::BoundingObject*> (node->GetData());
     if (boundingObject)
       return boundingObject;
   }
   return NULL;
 }
 
 void QmitkBoundingObjectWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   m_DataStorage = dataStorage;
 }
 
 mitk::DataStorage* QmitkBoundingObjectWidget::GetDataStorage()
 {
   return m_DataStorage;
 }
 
 //void QmitkBoundingObjectWidget::OnSaveButtonClicked()
 //{
 //
 //}
 //
 //void QmitkBoundingObjectWidget::OnLoadButtonClicked()
 //{
 //
 //}
 
 void QmitkBoundingObjectWidget::OnDelButtonClicked()
 {
   RemoveItem();
 }
 
 void QmitkBoundingObjectWidget::CreateBoundingObject(int type)
 {
 
   //get cross position
   mitk::Point3D pos;
   mitk::RenderingManager::RenderWindowVector windows =  mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
 
   //hopefully we have the renderwindows in the "normal" order
   const mitk::PlaneGeometry *plane1 =
     mitk::BaseRenderer::GetInstance(windows.at(0))->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane2 =
     mitk::BaseRenderer::GetInstance(windows.at(1))->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane3 =
     mitk::BaseRenderer::GetInstance(windows.at(2))->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ( (plane1 != NULL) && (plane2 != NULL)
     && (plane1->IntersectionLine( plane2, line )) )
   {
     if ( !((plane3 != NULL)
       && (plane3->IntersectionPoint( line, pos ))) )
     {
       return;
     }
   }
 
   if (type != 0)
   {
     mitk::BoundingObject::Pointer boundingObject;
-    static int i = 1;
     QString name;
-    name.setNum(i);
+    name.setNum(m_BoundingObjectCounter);
 
     switch (type-1)
     {
     case CUBOID:
       boundingObject = mitk::Cuboid::New();
       name.prepend("Cube_");
       break;
     case CONE:
       boundingObject = mitk::Cone::New();
       name.prepend("Cone_");
       break;
     case ELLIPSOID:
       boundingObject = mitk::Ellipsoid::New();
       name.prepend("Ellipse_");
       break;
     case CYLINDER:
       boundingObject = mitk::Cylinder::New();
       name.prepend("Cylinder_");
       break;
     default:
       return;
       break;
     }
-    i++;
+    m_BoundingObjectCounter++;
     m_addComboBox->setCurrentIndex(0);
 
     // set initial size
     mitk::Vector3D size; 
     size.Fill(10);
     boundingObject->GetGeometry()->SetSpacing( size );
 
     boundingObject->GetGeometry()->Translate(pos.GetVectorFromOrigin());
     boundingObject->GetTimeSlicedGeometry()->UpdateInformation();
 
     //create node
     mitk::DataNode::Pointer node  = mitk::DataNode::New();
     node->SetData( boundingObject);
     node->SetProperty("name", mitk::StringProperty::New( name.toLocal8Bit().data()));
     node->SetProperty("color", mitk::ColorProperty::New(0.0, 0.0, 1.0));
     node->SetProperty("opacity", mitk::FloatProperty::New(0.7));
     node->SetProperty("bounding object", mitk::BoolProperty::New(true));
     node->SetProperty("helper object", mitk::BoolProperty::New(true));
 
     m_DataStorage->Add(node);
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     emit BoundingObjectsChanged();
 
     AddItem(node);
   }
 }
 
 mitk::DataNode::Pointer QmitkBoundingObjectWidget::GetAllBoundingObjects()
 {
   mitk::DataNode::Pointer boundingObjectGroupNode = mitk::DataNode::New();
   mitk::BoundingObjectGroup::Pointer boundingObjectGroup = mitk::BoundingObjectGroup::New();
   boundingObjectGroup->SetCSGMode(mitk::BoundingObjectGroup::Union);
 
   mitk::NodePredicateProperty::Pointer prop = mitk::NodePredicateProperty::New("bounding object", mitk::BoolProperty::New(true));
   mitk::DataStorage::SetOfObjects::ConstPointer allBO = m_DataStorage->GetSubset(prop);
 
   for (mitk::DataStorage::SetOfObjects::const_iterator it = allBO->begin(); it != allBO->end(); ++it)
   {
     mitk::DataNode::Pointer node = *it;
     mitk::BoundingObject::Pointer boundingObject = dynamic_cast<mitk::BoundingObject*> (node->GetData());
     if (boundingObject)
       boundingObjectGroup->AddBoundingObject(boundingObject);
   }
 
   boundingObjectGroupNode->SetData(boundingObjectGroup);
 
   if (boundingObjectGroup->GetCount() >0)
     return boundingObjectGroupNode;
 
   return NULL;
 }
 
 mitk::DataNode::Pointer QmitkBoundingObjectWidget::GetSelectedBoundingObjectNode()
 {
   QList <QTreeWidgetItem*> selectedItems = m_TreeWidget->selectedItems();
   if (selectedItems.size() <1)
     return NULL;
 
   QTreeWidgetItem* item = selectedItems.first();
   mitk::DataNode* node = m_ItemNodeMap.find(item)->second;
 
   return node;
 }
 
 void QmitkBoundingObjectWidget::OnBoundingObjectModified(const itk::EventObject& e)
 {
   emit BoundingObjectsChanged();
 }
\ No newline at end of file
diff --git a/Modules/QmitkExt/QmitkBoundingObjectWidget.h b/Modules/QmitkExt/QmitkBoundingObjectWidget.h
index eaa2644a35..04b268421e 100644
--- a/Modules/QmitkExt/QmitkBoundingObjectWidget.h
+++ b/Modules/QmitkExt/QmitkBoundingObjectWidget.h
@@ -1,90 +1,94 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef _QMITKBOUNDINGOBJECTWIDGET_H_INCLUDED
 #define _QMITKBOUNDINGOBJECTWIDGET_H_INCLUDED
 
 //includes
 #include <qwidget.h>
 #include "QmitkExtExports.h"
 #include <QComboBox>
 #include <mitkDataNode.h>
 #include <mitkDataStorage.h>
 #include <mitkBoundingObject.h>
 #include <mitkBoundingObjectGroup.h>
 #include <QTreeWidget>
 #include <QPushButton>
 
 class QmitkExt_EXPORT QmitkBoundingObjectWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   QmitkBoundingObjectWidget (QWidget* parent = 0, Qt::WindowFlags f = 0 );
   ~QmitkBoundingObjectWidget ();
 
   void SetDataStorage(mitk::DataStorage* dataStorage);
   mitk::DataStorage* GetDataStorage();
   mitk::BoundingObject::Pointer GetSelectedBoundingObject();
   mitk::DataNode::Pointer GetSelectedBoundingObjectNode();
 
   mitk::DataNode::Pointer GetAllBoundingObjects();
 
   void setEnabled(bool flag);
 
   void OnBoundingObjectModified( const itk::EventObject& e);
 
+  void RemoveAllItems();
+
 signals:
   //signal when bo has changed
   void BoundingObjectsChanged();
 
-  protected slots:
+protected slots:
     void CreateBoundingObject(int type);
     void OnDelButtonClicked();
  /*   void OnLoadButtonClicked();
     void OnSaveButtonClicked();*/
     void SelectionChanged();
     void OnItemDoubleClicked(QTreeWidgetItem* item, int col);
     void OnItemDataChanged(QTreeWidgetItem* item, int col);
     
 protected:
 
   void AddItem(mitk::DataNode* node);
   void RemoveItem();
 
   mitk::DataStorage* m_DataStorage;
   QTreeWidget* m_TreeWidget;
   QComboBox* m_addComboBox;
   QPushButton* m_DelButton;
   QPushButton* m_SaveButton;
   QPushButton* m_LoadButton;
   QTreeWidgetItem* m_lastSelectedItem;
   unsigned long m_lastAffineObserver;
 
   typedef std::map< QTreeWidgetItem*, mitk::DataNode* > ItemNodeMapType;
   ItemNodeMapType m_ItemNodeMap;
 
+  unsigned int m_BoundingObjectCounter;
+
   enum BoundingObjectType{
     CUBOID,
     CONE,
     ELLIPSOID,
     CYLINDER,
   };
 
 };
 #endif 
diff --git a/Modules/QmitkExt/QmitkToolRoiDataSelectionBox.cpp b/Modules/QmitkExt/QmitkToolRoiDataSelectionBox.cpp
index 60dd4736ab..8b45380189 100644
--- a/Modules/QmitkExt/QmitkToolRoiDataSelectionBox.cpp
+++ b/Modules/QmitkExt/QmitkToolRoiDataSelectionBox.cpp
@@ -1,177 +1,198 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-09-12 15:46:48 +0200 (Fr, 12 Sep 2008) $
 Version:   $Revision: 15236 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #include "QmitkToolRoiDataSelectionBox.h"
 #include <mitkProperties.h>
 #include <QBoxLayout>
 #include <QLabel>
 
 QmitkToolRoiDataSelectionBox::QmitkToolRoiDataSelectionBox(QWidget* parent, mitk::DataStorage* storage)
 :QWidget(parent),
 m_SelfCall(false),
 m_lastSelection(mitk::DataNode::New()),
 m_lastSelectedName(tr("none"))
 {
 
   QBoxLayout* mainLayout = new QVBoxLayout(this);
   m_segmentationComboBox = new QComboBox(this);
   QLabel* label = new QLabel("region of interest:", this);
   m_boundingObjectWidget = new QmitkBoundingObjectWidget();
 
   mainLayout->addWidget(label);
   mainLayout->addWidget(m_segmentationComboBox);
   mainLayout->addWidget(m_boundingObjectWidget);
 
   //connect signals
   connect(m_segmentationComboBox, SIGNAL(activated(const QString&)), this, SLOT(OnRoiDataSelectionChanged(const QString&)) );
   connect(m_boundingObjectWidget, SIGNAL(BoundingObjectsChanged()), this, SLOT(OnRoiDataSelectionChanged()));
 
   //create ToolManager
   m_ToolManager = mitk::ToolManager::New(storage);
 
   //setup message delegates
   m_ToolManager->RoiDataChanged += mitk::MessageDelegate<QmitkToolRoiDataSelectionBox> (this, &QmitkToolRoiDataSelectionBox::OnToolManagerRoiDataModified);
 
+  mainLayout->deleteLater();
+  label->deleteLater();
 }
 
 QmitkToolRoiDataSelectionBox::~QmitkToolRoiDataSelectionBox()
 {
+  delete m_segmentationComboBox;
+  delete m_boundingObjectWidget;
+
+  m_ToolManager->GetDataStorage()->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkToolRoiDataSelectionBox , const mitk::DataNode*>( this, &QmitkToolRoiDataSelectionBox::DataStorageChanged ) );  
 }
 
 void QmitkToolRoiDataSelectionBox::SetDataStorage(mitk::DataStorage &storage)
 {
   m_ToolManager->SetDataStorage(storage);
   m_boundingObjectWidget->SetDataStorage(&storage);
   UpdateComboBoxData();
+
+  storage.RemoveNodeEvent.AddListener( mitk::MessageDelegate1<QmitkToolRoiDataSelectionBox , const mitk::DataNode*>( this, &QmitkToolRoiDataSelectionBox::DataStorageChanged ) );
+
 }
 
 mitk::DataStorage* QmitkToolRoiDataSelectionBox::GetDataStorage()
 {
   return m_ToolManager->GetDataStorage();
 }
 
 void QmitkToolRoiDataSelectionBox::SetToolManager(mitk::ToolManager& manager)
 {
   //remove old messagedelegates
   m_ToolManager->RoiDataChanged -= mitk::MessageDelegate<QmitkToolRoiDataSelectionBox> (this, &QmitkToolRoiDataSelectionBox::OnToolManagerRoiDataModified);
   //set new toolmanager
   m_ToolManager = &manager;
   //add new message delegates
   m_ToolManager->RoiDataChanged += mitk::MessageDelegate<QmitkToolRoiDataSelectionBox> (this, &QmitkToolRoiDataSelectionBox::OnToolManagerRoiDataModified);
 }
 
 mitk::ToolManager* QmitkToolRoiDataSelectionBox::GetToolManager()
 {
   return m_ToolManager;
 }
 
 void QmitkToolRoiDataSelectionBox::OnToolManagerRoiDataModified()
 {
   if (m_SelfCall)
     return;
   UpdateComboBoxData();
 }
 
+void QmitkToolRoiDataSelectionBox::DataStorageChanged(const mitk::DataNode* node )
+{
+  if (m_SelfCall) 
+    return;
+
+  if ( this->GetDataStorage()->GetAll()->size() == 1 )
+  {
+    m_boundingObjectWidget->RemoveAllItems();
+  }
+}
+
+
 void QmitkToolRoiDataSelectionBox::OnRoiDataSelectionChanged()
 {
   this->OnRoiDataSelectionChanged(tr("bounding objects"));
 }
 
 void QmitkToolRoiDataSelectionBox::OnRoiDataSelectionChanged(const QString& name)
 {
   if (name.compare(tr("")) == 0)
     return;
 
   m_lastSelectedName = name;
   m_boundingObjectWidget->setEnabled(false);
   mitk::DataNode::Pointer selection = NULL;
 
   if ( name.compare(tr("none"))==0)
     m_segmentationComboBox->setCurrentIndex(0);
   else if (name.compare(tr("bounding objects"))==0)
   {
     m_boundingObjectWidget->setEnabled(true);
     selection = m_boundingObjectWidget->GetAllBoundingObjects();
   }
   else
   {
     selection = m_ToolManager->GetDataStorage()->GetNamedNode(name.toLocal8Bit().data());
 
     if (m_lastSelection.IsNotNull())
       m_lastSelection->SetProperty("outline binary", mitk::BoolProperty::New(false));
   }
 
   if (selection == m_lastSelection)
     return;
 
   m_lastSelection = selection;
 
   if (m_lastSelection.IsNotNull())
   {
     m_lastSelection->SetProperty("outline binary", mitk::BoolProperty::New(true));
     m_lastSelection->SetProperty("outline width", mitk::FloatProperty::New(2.0));
   }
 
   m_SelfCall = true;
   m_ToolManager->SetRoiData(selection);
   m_SelfCall = false;
 }
 
 void QmitkToolRoiDataSelectionBox::UpdateComboBoxData()
 {
   m_segmentationComboBox->clear();
   m_segmentationComboBox->addItem(tr("none"));
   m_segmentationComboBox->insertSeparator(1);
 
 
   //predicates for combobox
   mitk::NodePredicateProperty::Pointer isBinary= mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateDataType::Pointer isImage= mitk::NodePredicateDataType::New("Image");
   mitk::NodePredicateProperty::Pointer isHelperObject= mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true));
   mitk::NodePredicateNot::Pointer isNotHelperObject = mitk::NodePredicateNot::New(isHelperObject);
   mitk::NodePredicateAnd::Pointer segmentationPredicate = mitk::NodePredicateAnd::New(isImage, isBinary, isNotHelperObject);
 
   mitk::DataStorage::SetOfObjects::ConstPointer allSegmentations = m_ToolManager->GetDataStorage()->GetSubset(segmentationPredicate);
   QStringList names;
 
   for (mitk::DataStorage::SetOfObjects::const_iterator it = allSegmentations->begin(); it != allSegmentations->end(); ++it)
   {
     mitk::DataNode::Pointer node = *it;
 
     QString name = QString::fromLocal8Bit(node->GetName().c_str());
     names.append(name);
   }
   if (names.length() > 0)
   {
     m_segmentationComboBox->addItems(names);
     m_segmentationComboBox->insertSeparator(names.length()+2);
   }
 
   m_segmentationComboBox->addItem(tr("bounding objects"));
 
   int id = m_segmentationComboBox->findText(m_lastSelectedName);
   if (id < 0)
     this->OnRoiDataSelectionChanged(tr("none"));
   else
     m_segmentationComboBox->setCurrentIndex(id);
 }
 
 void QmitkToolRoiDataSelectionBox::setEnabled(bool flag)
 {
   if (!flag)
     this->OnRoiDataSelectionChanged(tr("none"));
   m_segmentationComboBox->setEnabled(flag);
 }
\ No newline at end of file
diff --git a/Modules/QmitkExt/QmitkToolRoiDataSelectionBox.h b/Modules/QmitkExt/QmitkToolRoiDataSelectionBox.h
index d0bbd7750d..a637875c21 100644
--- a/Modules/QmitkExt/QmitkToolRoiDataSelectionBox.h
+++ b/Modules/QmitkExt/QmitkToolRoiDataSelectionBox.h
@@ -1,76 +1,81 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-09-12 15:46:48 +0200 (Fr, 12 Sep 2008) $
 Version:   $Revision: 15236 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #ifndef QMITK_TOOLROIDATASELECTIONBOX_H
 #define QMITK_TOOLROIDATASELECTIONBOX_H
 
 #include "QmitkExtExports.h"
 #include "mitkToolManager.h"
 #include "QmitkBoundingObjectWidget.h"
 #include <QComboBox>
 
 /**
 \brief Widget for defining a ROI inside the Interactive Segmentation Framwork
 
 \ingroup ToolManagerEtAl
 \ingroup Widgets
 
 Allows to define a Region of interest (ROI) either by existing segmentations or by bounding objects.
 Selection is possible via a combobox, listing all available segmentations. 
 Item "bounding objects" activates the \ref QmitkBoundingObjectWidget.
 
 */
 class QmitkExt_EXPORT QmitkToolRoiDataSelectionBox : public QWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkToolRoiDataSelectionBox(QWidget* parent = 0, mitk::DataStorage* storage = 0);
   virtual ~QmitkToolRoiDataSelectionBox();
 
   mitk::DataStorage* GetDataStorage();
   void SetDataStorage(mitk::DataStorage& storage);
 
   mitk::ToolManager* GetToolManager();
   void SetToolManager(mitk::ToolManager& manager);
 
   void OnToolManagerRoiDataModified();
 
+  void DataStorageChanged(const mitk::DataNode* node );
+
   mitk::ToolManager::DataVectorType GetSelection();
 
   void UpdateComboBoxData();
 
   void setEnabled(bool);
 
 signals:
+  
   void RoiDataSelected(const mitk::DataNode* node);
-  protected slots:
+
+protected slots:
+
     void OnRoiDataSelectionChanged(const QString& name);
     void OnRoiDataSelectionChanged();
 
 protected:
 
   QmitkBoundingObjectWidget* m_boundingObjectWidget;
   QComboBox* m_segmentationComboBox;
 
   mitk::ToolManager::Pointer m_ToolManager;
   bool m_SelfCall;
 
   mitk::DataNode::Pointer m_lastSelection;
   QString m_lastSelectedName;
 };
 #endif
\ No newline at end of file