Index: mbi-sb/Testing/mitkVtkPropRendererTest_sb.cpp
===================================================================
--- mbi-sb/Testing/mitkVtkPropRendererTest_sb.cpp	(revision 14764)
+++ mbi-sb/Testing/mitkVtkPropRendererTest_sb.cpp	(working copy)
@@ -64,41 +64,41 @@
   ipPicGetTags(argv[1], picheader);
 
   //Read pic-Image from file
-//  std::cout << "Reading image: ";
+  std::cout << "Reading image: ";
 	mitk::PicFileReader::Pointer reader = mitk::PicFileReader::New();
   reader->SetFileName(argv[1]);
   reader->Update();
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
   mitk::Image::Pointer image = reader->GetOutput();
 
-//  std::cout << "Creating node: ";
+  std::cout << "Creating node: ";
   mitk::DataTreeNode::Pointer node = mitk::DataTreeNode::New();
   node->SetData(image);
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  std::cout << "Creating tree: ";
-  mitk::DataTree* tree;
-  (tree=mitk::DataTree::New())->Register(); //@FIXME: da DataTreeIteratorClone keinen Smartpointer auf DataTree h�lt, wird tree sonst gel�scht.
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout << "Creating tree: ";
+  mitk::DataTree::Pointer tree;
+  tree=mitk::DataTree::New();
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  std::cout << "Creating iterator on tree: ";
+  std::cout << "Creating iterator on tree: ";
   mitk::DataTreePreOrderIterator it(tree);
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  std::cout << "Adding node via iterator: ";
+  std::cout << "Adding node via iterator: ";
   it.Add(node);
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  std::cout << "Adding level-window property: ";
+  std::cout << "Adding level-window property: ";
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( image );
   levWinProp->SetLevelWindow( levelwindow );
   node->GetPropertyList()->SetProperty( "levelwindow", levWinProp );
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  std::cout << "Creating a vtk sphere: ";
+  std::cout << "Creating a vtk sphere: ";
   vtkSphereSource *sphere = vtkSphereSource::New();
   sphere->SetRadius(1.0);
   sphere->SetThetaResolution(18);
@@ -106,53 +106,56 @@
 
   vtkPolyDataMapper *map = vtkPolyDataMapper::New();
   map->SetInput(sphere->GetOutput());
+  sphere->Delete();
 
   vtkActor *aSphere = vtkActor::New();
   aSphere->SetMapper(map);
+  map->Delete();
   aSphere->GetProperty()->SetColor(0,0,1); // sphere color blue
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  std::cout << "Creating a renderer for the sphere: ";
+  std::cout << "Creating a renderer for the sphere: ";
   vtkRenderer *sphereRenderer = vtkRenderer::New();
   sphereRenderer->AddActor(aSphere);
+  aSphere->Delete();
   //sphereRenderer->SetBackground(1,1,1); // Background color white
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  std::cout << "Creating vtkRenderWindow and VtkPropRenderer: ";
+  std::cout << "Creating vtkRenderWindow and VtkPropRenderer: ";
   vtkRenderWindow *renderWindow = vtkRenderWindow::New();
-  mitk::VtkPropRenderer *propRenderer = new mitk::VtkPropRenderer( "the renderer", renderWindow );
+  mitk::VtkPropRenderer::Pointer propRenderer = mitk::VtkPropRenderer::New( "the renderer", renderWindow );
   //propRenderer->SetMapperID(2);
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
   //renderWindow->AddRenderer(sphereRenderer);
   //renderWindow->SetErase(0);
 
-//  std::cout << "BaseRenderer::SetData(iterator): ";
+  std::cout << "BaseRenderer::SetData(iterator): ";
   propRenderer->SetData(&it);
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  std::cout << "Creating vtkMitkRenderProp and connecting it to the VtkPropRenderer: ";
+  std::cout << "Creating vtkMitkRenderProp and connecting it to the VtkPropRenderer: ";
   vtkMitkRenderProp* renderProp = vtkMitkRenderProp::New();
   renderProp->SetPropRenderer(propRenderer);
   propRenderer->GetVtkRenderer()->AddViewProp(renderProp);
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  std::cout << "Inserting the sphere into the foreground of the VtkLayerController: ";
+  std::cout << "Inserting the sphere into the foreground of the VtkLayerController: ";
   mitk::VtkLayerController::GetInstance(renderWindow)->InsertForegroundRenderer(sphereRenderer,true);
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
   // mouse interaction for debugging
   //vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
   //iren->SetRenderWindow(renderWindow);
 
-//  std::cout << "Setting and getting size of renderWindow: ";
+  std::cout << "Setting and getting size of renderWindow: ";
   renderWindow->SetSize(400, 400);
   int *size = renderWindow->GetSize();
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  std::cout << "Do the rendering: ";
+  std::cout << "Do the rendering: ";
   renderWindow->Render();
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
   //iren->Start();
 
@@ -164,20 +167,20 @@
   propRenderer->PickWorldPoint(p, p_mm);
   std::cout << "returned world position: " << p_mm << "\n";
 
-//  std::cout << "Creating vtkUnsignedCharArray: ";
+  std::cout << "Creating vtkUnsignedCharArray: ";
   vtkUnsignedCharArray *vtkImage = vtkUnsignedCharArray::New();
-//  std::cout<<"[PASSED]"<<std::endl;
+  std::cout<<"[PASSED]"<<std::endl;
 
-//  cout << "Reading image from renderWindow" << std::endl;
+  cout << "Reading image from renderWindow" << std::endl;
   renderWindow->GetRGBACharPixelData(0, 0, size[0]-1, size[1]-1, 0, vtkImage);
-//  cout << "Read " << size[0]*size[1] << " data points\n";
+  cout << "Read " << size[0]*size[1] << " data points\n";
 
   cout << "Computing sum of all RGBA values..\n";
   long int sum_now = 0;
   for(int i=0;i<size[0]*size[1];i++) 
     sum_now += vtkImage->GetValue(i);
   std::cout << "Sum of all RGBA values: " << sum_now << "\n";
-//  std::cout << "Sum should be: " << sum_orig_Pic3D_pic_gz << "\n";
+  std::cout << "Sum should be: " << sum_orig_Pic3D_pic_gz << "\n";
 
   //std::string Pic3d_pic_gz_str("Pic3D.pic.gz");
   //std::cout << "pic3d " << Pic3d_pic_gz_str << "\n";
@@ -195,6 +198,11 @@
   //    return EXIT_FAILURE;
   //  }
   //  std::cout<<"[PASSED]"<<std::endl;
+  //}
+  //else
+  //{
+  //  std::cout<<"Unknown image, comparison test skipped"<<std::endl;
+  //}
 
     std::stringstream filename;
     filename << "darttempimage.png";
@@ -236,8 +244,14 @@
   std::cout << filename.str();
   std::cout << "</DartMeasurementFile>" << std::endl;
 
+  propRenderer->GetVtkRenderer()->RemoveViewProp(renderProp);
+  renderProp->Delete();
+  propRenderer = NULL;
+  sphereRenderer->Delete();
 
   renderWindow->Delete();
+
+  vtkImage->Delete();
   tree = NULL; // As the tree has been registered explicitely, destroy it again.
 
   std::cout<<"[TEST DONE]"<<std::endl;
Index: mitk/Core/Algorithms/mitkManualSegmentationToSurfaceFilter.cpp
===================================================================
--- mitk/Core/Algorithms/mitkManualSegmentationToSurfaceFilter.cpp	(revision 14764)
+++ mitk/Core/Algorithms/mitkManualSegmentationToSurfaceFilter.cpp	(working copy)
@@ -17,6 +17,7 @@
 
 #include <mitkManualSegmentationToSurfaceFilter.h>
 
+#include <vtkSmartPointer.h>
 
 mitk::ManualSegmentationToSurfaceFilter::ManualSegmentationToSurfaceFilter() 
 {
@@ -49,11 +50,8 @@
   for( int t=tstart; t<tmax; t++ )
   {
 
-    vtkImageData *vtkimage = image->GetVtkImageData(t);
+    vtkSmartPointer<vtkImageData> vtkimage = image->GetVtkImageData(t);
 
-    //Inkrement Referenzcounter Counter (hier: RC)
-    vtkimage->Register(NULL);
-
     // Median -->smooth 3D 
     if(m_MedianFilter3D)
     {
@@ -63,9 +61,7 @@
       median->ReleaseDataFlagOn();
       median->UpdateInformation();
       median->Update();
-      vtkimage->Delete(); //->Input
       vtkimage = median->GetOutput(); //->Out
-      vtkimage->Register(NULL);
       median->Delete();
     }
 
@@ -81,9 +77,7 @@
       imageresample->SetAxisOutputSpacing(2, m_MedianKernelSizeZ);
       imageresample->UpdateInformation();
       imageresample->Update();
-      vtkimage->Delete(); //->Input
       vtkimage=imageresample->GetOutput();//->Output
-      vtkimage->Register(NULL);
       imageresample->Delete();
     }
 
@@ -101,15 +95,14 @@
 
       vtkImageGaussianSmooth *gaussian = vtkImageGaussianSmooth::New();
       gaussian->SetInput(vtkimagethreshold->GetOutput()); 
+      vtkimagethreshold->Delete();
       gaussian->SetDimensionality(3);
       gaussian->SetRadiusFactor(0.49);
       gaussian->SetStandardDeviation( m_GaussianStandardDeviation );
       gaussian->ReleaseDataFlagOn();
       gaussian->UpdateInformation();
       gaussian->Update();
-      vtkimage->Delete();//->Input
       vtkimage = gaussian->GetOutput(); //->Out
-      gaussian->Register(NULL);
       gaussian->Delete();
     }
 
Index: mitk/Core/Controllers/mitkSlicesRotator.cpp
===================================================================
--- mitk/Core/Controllers/mitkSlicesRotator.cpp	(revision 14764)
+++ mitk/Core/Controllers/mitkSlicesRotator.cpp	(working copy)
@@ -48,12 +48,7 @@
 
 SlicesRotator::Pointer SlicesRotator::New()
 {
-  // from itkNewMacro()
-  Pointer smartPtr;
-  SlicesRotator* rawPtr = new SlicesRotator("slices-rotator");
-  smartPtr = rawPtr;
-  rawPtr->UnRegister();
-  return smartPtr;
+  return SlicesRotator::New("slices-rotator");
 }
 
 SlicesRotator::SlicesRotator(const char* machine)
Index: mitk/Core/Controllers/mitkSlicesRotator.h
===================================================================
--- mitk/Core/Controllers/mitkSlicesRotator.h	(revision 14764)
+++ mitk/Core/Controllers/mitkSlicesRotator.h	(working copy)
@@ -66,11 +66,13 @@
 
   mitkClassMacro(SlicesRotator, SlicesCoordinator);
   
-  /// @TODO FIX StateMachine smart pointer handling (or learn about the reason)
   static Pointer New();
-  /// @TODO public ONLY because of StateMachine's meddling with m_ReferenceCount
-  SlicesRotator(const char* machine);
 
+  /**
+  * @brief New Macro with one parameter for creating this object with static New(..) method
+  **/
+  mitkNewMacro1Param(Self, const char*);
+
   virtual void SetGeometry(const itk::EventObject& EventObject);
 
   virtual void RotateToPoint( SliceNavigationController *rotationPlaneSNC,
@@ -79,6 +81,7 @@
 
 protected:
 
+  SlicesRotator(const char* machine);
   // clear list of controllers
   virtual ~SlicesRotator();
 
Index: mitk/Core/Controllers/mitkSlicesSwiveller.cpp
===================================================================
--- mitk/Core/Controllers/mitkSlicesSwiveller.cpp	(revision 14764)
+++ mitk/Core/Controllers/mitkSlicesSwiveller.cpp	(working copy)
@@ -47,12 +47,7 @@
 
 SlicesSwiveller::Pointer SlicesSwiveller::New()
 {
-  // from itkNewMacro()
-  Pointer smartPtr;
-  SlicesSwiveller* rawPtr = new SlicesSwiveller("slices-rotator");
-  smartPtr = rawPtr;
-  rawPtr->UnRegister();
-  return smartPtr;
+  return SlicesSwiveller::New("slices-rotator");
 }
 
 SlicesSwiveller::SlicesSwiveller(const char* machine)
Index: mitk/Core/Controllers/mitkSlicesSwiveller.h
===================================================================
--- mitk/Core/Controllers/mitkSlicesSwiveller.h	(revision 14764)
+++ mitk/Core/Controllers/mitkSlicesSwiveller.h	(working copy)
@@ -67,14 +67,16 @@
 
   mitkClassMacro(SlicesSwiveller, SlicesCoordinator);
   
-  /// @TODO FIX StateMachine smart pointer handling (or learn about the reason)
   static Pointer New();
-  /// @TODO public ONLY because of StateMachine's meddling with m_ReferenceCount
-  SlicesSwiveller(const char* machine);
+  /**
+  * @brief New Macro with one parameter for creating this object with static New(..) method
+  **/
+  mitkNewMacro1Param(Self, const char*);
 
   virtual void SetGeometry(const itk::EventObject& EventObject);
 
 protected:
+  SlicesSwiveller(const char* machine);
 
   // clear list of controllers
   virtual ~SlicesSwiveller();
Index: mitk/Core/Controllers/mitkUndoController.cpp
===================================================================
--- mitk/Core/Controllers/mitkUndoController.cpp	(revision 14764)
+++ mitk/Core/Controllers/mitkUndoController.cpp	(working copy)
@@ -62,6 +62,17 @@
   }
 }
 
+mitk::UndoController::~UndoController()
+{
+  UndoModelMapIter undoModelIter = m_UndoModelList.begin();
+  while(undoModelIter != m_UndoModelList.end())
+  {
+    delete (*undoModelIter).second;
+    ++undoModelIter;
+  }
+  m_UndoModelList.clear();
+}
+
 //##ModelId=3E5F543402C5
 bool mitk::UndoController::SetOperationEvent(UndoStackItem* operationEvent)
 {
Index: mitk/Core/Controllers/mitkUndoController.h
===================================================================
--- mitk/Core/Controllers/mitkUndoController.h	(revision 14764)
+++ mitk/Core/Controllers/mitkUndoController.h	(working copy)
@@ -48,6 +48,7 @@
   //## Constructor; Adds the new UndoType or if undoType exists ,
   //## switches it to undoType; for UndoTypes see definitionmitkInteractionConst.h
   UndoController(UndoType undoType = DEFAULTUNDOMODEL);
+  virtual ~UndoController();
 
   //##ModelId=3E5F543402C5
   bool SetOperationEvent(UndoStackItem* operationEvent);
Index: mitk/Core/DataStructures/itkVtkAbstractTransform.txx
===================================================================
--- mitk/Core/DataStructures/itkVtkAbstractTransform.txx	(revision 14764)
+++ mitk/Core/DataStructures/itkVtkAbstractTransform.txx	(working copy)
@@ -16,6 +16,8 @@
 template <class TScalarType>
 itk::VtkAbstractTransform<TScalarType>::~VtkAbstractTransform()
 {
+  if(m_VtkAbstractTransform!=NULL)
+    m_VtkAbstractTransform->UnRegister(NULL);
 }
 
 template <class TScalarType>
@@ -39,15 +41,11 @@
   if(m_VtkAbstractTransform!=NULL)
     m_VtkAbstractTransform->UnRegister(NULL);
 
-  if(m_InverseVtkAbstractTransform!=NULL)
-    m_InverseVtkAbstractTransform->UnRegister(NULL);
-
   m_VtkAbstractTransform=aVtkAbstractTransform;
   if(m_VtkAbstractTransform!=NULL)
   {
     m_VtkAbstractTransform->Register(NULL);
-    m_InverseVtkAbstractTransform=m_VtkAbstractTransform->GetInverse();
-    m_InverseVtkAbstractTransform->Register(NULL);
+    m_InverseVtkAbstractTransform=m_VtkAbstractTransform->GetInverse(); // memory managed by m_VtkAbstractTransform
   }
 
   m_LastVtkAbstractTransformTimeStamp = m_VtkAbstractTransform->GetMTime();
Index: mitk/Core/DataStructures/mitkDataStorage/mitkDataStorage.cpp
===================================================================
--- mitk/Core/DataStructures/mitkDataStorage/mitkDataStorage.cpp	(revision 14764)
+++ mitk/Core/DataStructures/mitkDataStorage/mitkDataStorage.cpp	(working copy)
@@ -37,6 +37,18 @@
 
 mitk::DataStorage::~DataStorage()
 {
+  if(m_DataTree.IsNotNull())
+  {
+    m_DataTree->RemoveObserver(m_DeleteInTreeObserverTag);
+  }
+
+  // workaround for bug #343: do another UnRegister in case we re-create a DataStorage 
+  // which happens when a PlugIn is re-initialized within Chili
+  if(s_Instance.IsNotNull())
+  {
+    s_Instance->m_DataTree->UnRegister();
+  }
+
   m_DataTree = NULL; 
 }
 
Index: mitk/Core/DataStructures/mitkDataTreeNode.cpp
===================================================================
--- mitk/Core/DataStructures/mitkDataTreeNode.cpp	(revision 14764)
+++ mitk/Core/DataStructures/mitkDataTreeNode.cpp	(working copy)
@@ -104,7 +104,7 @@
 {
   Interactor* interactor = this->GetInteractor();
 
-  if ( interactor )
+  if ( ( interactor ) && ( mitk::GlobalInteraction::HasInstance() ) )
   {
     mitk::GlobalInteraction::GetInstance()->RemoveInteractor( interactor );  
   }
Index: mitk/Core/DataStructures/mitkLevelWindowPreset.cpp
===================================================================
--- mitk/Core/DataStructures/mitkLevelWindowPreset.cpp	(revision 14764)
+++ mitk/Core/DataStructures/mitkLevelWindowPreset.cpp	(working copy)
@@ -17,11 +17,14 @@
 
 #include "mitkLevelWindowPreset.h"
 #include "mitkStandardFileLocations.h"
+#include <vtkObjectFactory.h>
 
 namespace mitk {
 
-  const std::string LevelWindowPreset::PRESET = "preset";
+const std::string LevelWindowPreset::PRESET = "preset";
 
+vtkStandardNewMacro(LevelWindowPreset);
+
 LevelWindowPreset::LevelWindowPreset()
 {
 }
@@ -142,4 +145,5 @@
   m_Window = newWindow;
   save();
 }
+
 }
Index: mitk/Core/DataStructures/mitkLevelWindowPreset.h
===================================================================
--- mitk/Core/DataStructures/mitkLevelWindowPreset.h	(revision 14764)
+++ mitk/Core/DataStructures/mitkLevelWindowPreset.h	(working copy)
@@ -25,38 +25,39 @@
 
 namespace mitk {
 
-  class MITK_CORE_EXPORT LevelWindowPreset : public vtkXMLParser
-  {
-  public:
-    LevelWindowPreset();
-    ~LevelWindowPreset();
+class MITK_CORE_EXPORT LevelWindowPreset : public vtkXMLParser
+{
+public:
+  static LevelWindowPreset *New();
+  vtkTypeMacro(LevelWindowPreset,vtkXMLParser);
 
-    bool LoadPreset();
-    bool LoadPreset(std::string fileName);
-    double getLevel(std::string name);
-    double getWindow(std::string window);
-    std::map<std::string, double>& getLevelPresets();
-    std::map<std::string, double>& getWindowPresets();
-    void newPresets(std::map<std::string, double> newLevel, std::map<std::string, double> newWindow);
-  
+  bool LoadPreset();
+  bool LoadPreset(std::string fileName);
+  double getLevel(std::string name);
+  double getWindow(std::string window);
+  std::map<std::string, double>& getLevelPresets();
+  std::map<std::string, double>& getWindowPresets();
+  void newPresets(std::map<std::string, double> newLevel, std::map<std::string, double> newWindow);
+protected:
+  LevelWindowPreset();
+  ~LevelWindowPreset();
 
-    private:
+private:
+  //##Documentation
+  //## @brief method used in XLM-Reading; gets called when a start-tag is read
+  void StartElement (const char *elementName, const char **atts);
 
-      //##Documentation
-      //## @brief method used in XLM-Reading; gets called when a start-tag is read
-      void StartElement (const char *elementName, const char **atts);
-    
-      void saveXML(mitk::XMLWriter& xmlWriter);
-      void save();
+  void saveXML(mitk::XMLWriter& xmlWriter);
+  void save();
 
-      //##Documentation
-      //## @brief reads an XML-String-Attribute
-      std::string ReadXMLStringAttribut( std::string name, const char** atts);
+  //##Documentation
+  //## @brief reads an XML-String-Attribute
+  std::string ReadXMLStringAttribut( std::string name, const char** atts);
 
-      static const std::string PRESET;
-      std::map<std::string, double> m_Level;
-      std::map<std::string, double> m_Window;
-      std::string m_XmlFileName;
-  };
+  static const std::string PRESET;
+  std::map<std::string, double> m_Level;
+  std::map<std::string, double> m_Window;
+  std::string m_XmlFileName;
+};
 }
 #endif
Index: mitk/Core/DataStructures/mitkThinPlateSplineCurvedGeometry.cpp
===================================================================
--- mitk/Core/DataStructures/mitkThinPlateSplineCurvedGeometry.cpp	(revision 14764)
+++ mitk/Core/DataStructures/mitkThinPlateSplineCurvedGeometry.cpp	(working copy)
@@ -31,6 +31,14 @@
 
 mitk::ThinPlateSplineCurvedGeometry::~ThinPlateSplineCurvedGeometry()
 {
+  // don't need to delete m_ThinPlateSplineTransform, because it is
+  // the same as m_InterpolatingAbstractTransform, which will be deleted
+  // by the superclass.
+
+  if(m_VtkTargetLandmarks!=NULL)
+    m_VtkTargetLandmarks->Delete();
+  if(m_VtkProjectedLandmarks!=NULL)
+    m_VtkProjectedLandmarks->Delete();
 }
 
 bool mitk::ThinPlateSplineCurvedGeometry::IsValid() const
Index: mitk/Core/DataStructures/mitkTransferFunctionProperty.h
===================================================================
--- mitk/Core/DataStructures/mitkTransferFunctionProperty.h	(revision 14764)
+++ mitk/Core/DataStructures/mitkTransferFunctionProperty.h	(working copy)
@@ -83,6 +83,10 @@
           : BaseProperty()
         {};
 
+        virtual ~TransferFunctionProperty()
+        {
+        };
+
         TransferFunctionProperty( mitk::TransferFunction::Pointer value )
           : BaseProperty(), m_Value( value )
         {};
Index: mitk/Core/Interactions/mitkEventMapper.cpp
===================================================================
--- mitk/Core/Interactions/mitkEventMapper.cpp	(revision 14764)
+++ mitk/Core/Interactions/mitkEventMapper.cpp	(working copy)
@@ -44,6 +44,12 @@
 #include <itksys/SystemTools.hxx>
 #include "mitkCoreObjectFactory.h"
 
+#include <vtkObjectFactory.h>
+namespace mitk
+{
+vtkStandardNewMacro(EventMapper);
+}
+
 #ifdef MBI_INTERNAL_CONFERENCE
   #include <mitkGeometry3D.h>
   #include <mitkDisplayPositionEvent.h>
@@ -554,7 +560,7 @@
   if ( fileName.empty() )
     return false;
 
-  mitk::EventMapper* eventMapper = new EventMapper();
+  mitk::EventMapper* eventMapper = EventMapper::New();
   eventMapper->SetFileName( fileName.c_str() );
 
   if ( ! eventMapper->Parse() )
Index: mitk/Core/Interactions/mitkEventMapper.h
===================================================================
--- mitk/Core/Interactions/mitkEventMapper.h	(revision 14764)
+++ mitk/Core/Interactions/mitkEventMapper.h	(working copy)
@@ -60,10 +60,8 @@
   class MITK_CORE_EXPORT EventMapper : public vtkXMLParser
   {
   public:
-    //##ModelId=3F02F896006D
-    EventMapper();
-    //##ModelId=3F02F896008C
-    ~EventMapper();
+    static EventMapper *New();
+    vtkTypeMacro(EventMapper,vtkXMLParser);
 
     //##ModelId=3F0177080269
     typedef std::vector<mitk::EventDescription> EventDescriptionVec;
@@ -124,6 +122,9 @@
     friend class mitk::GlobalInteraction;
 
   protected:
+    EventMapper();
+    ~EventMapper();
+
     //##Documentation
     //##@brief method only for GlobalInteraction to change the Event (from DiplayPositionEvent to PositionEvent)
     static void SetStateEvent(Event* event);
Index: mitk/Core/Interactions/mitkGlobalInteraction.cpp
===================================================================
--- mitk/Core/Interactions/mitkGlobalInteraction.cpp	(revision 14764)
+++ mitk/Core/Interactions/mitkGlobalInteraction.cpp	(working copy)
@@ -349,6 +349,11 @@
   return s_GlobalInteraction.GetPointer();
 }
 
+bool mitk::GlobalInteraction::HasInstance()
+{
+  return s_GlobalInteraction.IsNotNull();
+}
+
 bool mitk::GlobalInteraction::AddToSelectedInteractors(mitk::Interactor* interactor)
 {
   InteractorListIter position = std::find(m_SelectedList.begin(), m_SelectedList.end(),interactor);
Index: mitk/Core/Interactions/mitkGlobalInteraction.h
===================================================================
--- mitk/Core/Interactions/mitkGlobalInteraction.h	(revision 14764)
+++ mitk/Core/Interactions/mitkGlobalInteraction.h	(working copy)
@@ -135,8 +135,15 @@
 
     static bool StandardInteractionSetup(const char * XMLbehaviorFile = NULL, const char * globalInteractionName = NULL);
 
+    //##Documentation
+    //## @brief Returns the global (singleton) instance of
+    //## GlobalInteraction. Create it, if it does not exist.
     static GlobalInteraction* GetInstance();
 
+    //##Documentation
+    //## @brief Returns whether an instance exists
+    static bool HasInstance();
+
     //so that the interactors can call AddToSelectedInteractors() and RemoveFromSelectedInteractors()
     friend class Interactor;
 
Index: mitk/Core/Interactions/mitkStateMachineFactory.cpp
===================================================================
--- mitk/Core/Interactions/mitkStateMachineFactory.cpp	(revision 14764)
+++ mitk/Core/Interactions/mitkStateMachineFactory.cpp	(working copy)
@@ -55,6 +55,12 @@
 const std::string mitk::StateMachineFactory::STRING_PARAMETER = "stringParameter";
 const std::string mitk::StateMachineFactory::VALUE = "VALUE";
 
+#include <vtkObjectFactory.h>
+namespace mitk
+{
+vtkStandardNewMacro(StateMachineFactory);
+}
+
 mitk::StateMachineFactory::StateMachineFactory()
 : m_AktStateMachineName("")
 {}
@@ -97,7 +103,7 @@
   s_LastLoadedBehavior = fileName;
 
   //call a new instance of this class and let it build up static containers
-  mitk::StateMachineFactory* stateMachineFactory = new StateMachineFactory();
+  mitk::StateMachineFactory* stateMachineFactory = StateMachineFactory::New();
   stateMachineFactory->SetFileName( fileName.c_str() );
 
   InteractionDebug::SetXMLFileName( "StateMachine.xml" );
Index: mitk/Core/Interactions/mitkStateMachineFactory.h
===================================================================
--- mitk/Core/Interactions/mitkStateMachineFactory.h	(revision 14764)
+++ mitk/Core/Interactions/mitkStateMachineFactory.h	(working copy)
@@ -43,6 +43,9 @@
   class MITK_CORE_EXPORT StateMachineFactory : public vtkXMLParser
   {
   public:
+    static StateMachineFactory *New();
+    vtkTypeMacro(StateMachineFactory,vtkXMLParser);
+
     /**
     * @brief Typedef for all states that are defined as start-states
     **/
@@ -66,16 +69,6 @@
     typedef std::map<std::string, StateMachineMapType* > AllStateMachineMapType;
 
     /**
-    * @brief Default Constructor
-    **/
-    StateMachineFactory();
-
-    /**
-    * @brief Default Destructor
-    **/
-    ~StateMachineFactory();
-
-    /**
     * @brief Returns the StartState of the StateMachine with the name type;
     *
     * Returns NULL if no entry with name type is found.
@@ -119,6 +112,17 @@
     **/
     friend class StateMachine;
 
+  protected:
+    /**
+    * @brief Default Constructor
+    **/
+    StateMachineFactory();
+
+    /**
+    * @brief Default Destructor
+    **/
+    ~StateMachineFactory();
+
   private:
     /**
     * @brief Derived from XMLReader
Index: mitk/Core/IO/mitkPointSetReader.cpp
===================================================================
--- mitk/Core/IO/mitkPointSetReader.cpp	(revision 14764)
+++ mitk/Core/IO/mitkPointSetReader.cpp	(working copy)
@@ -53,7 +53,7 @@
     }
     in.close();
 
-    mitk::vtkPointSetXMLParser* parser = new mitk::vtkPointSetXMLParser();
+    mitk::vtkPointSetXMLParser* parser = mitk::vtkPointSetXMLParser::New();
    parser->SetFileName( m_FileName.c_str() );
     if ( parser->Parse() == 0 ) //Parse returns zero as error indicator
     {
Index: mitk/Core/IO/vtkPointSetXMLParser.cpp
===================================================================
--- mitk/Core/IO/vtkPointSetXMLParser.cpp	(revision 14764)
+++ mitk/Core/IO/vtkPointSetXMLParser.cpp	(working copy)
@@ -1,12 +1,24 @@
 #include "vtkPointSetXMLParser.h"
+#include "vtkObjectFactory.h"
 #include "mitkPointSetWriter.h"
 #include "mitkOperation.h"
 #include "mitkInteractionConst.h"
 #include "mitkPointOperation.h"
 
+namespace mitk
+{
+vtkStandardNewMacro(vtkPointSetXMLParser);
+}
 
+mitk::vtkPointSetXMLParser::vtkPointSetXMLParser()
+{
+}
 
+mitk::vtkPointSetXMLParser::~vtkPointSetXMLParser()
+{
+}
 
+
 void mitk::vtkPointSetXMLParser::StartElement ( const char *name, const char ** /*atts */)
 {
     std::string currentElement = name;
Index: mitk/Core/IO/vtkPointSetXMLParser.h
===================================================================
--- mitk/Core/IO/vtkPointSetXMLParser.h	(revision 14764)
+++ mitk/Core/IO/vtkPointSetXMLParser.h	(working copy)
@@ -22,6 +22,10 @@
 class MITK_CORE_EXPORT vtkPointSetXMLParser : public vtkXMLParser
 {
 public:
+    vtkTypeMacro(vtkPointSetXMLParser,vtkXMLParser);
+
+    static vtkPointSetXMLParser* New();
+
     typedef mitk::PointSet PointSetType;
 
     typedef std::stack< std::string > ParseStack;
@@ -69,6 +73,8 @@
     virtual PointSetList GetParsedPointSets();
     
 protected:
+    vtkPointSetXMLParser();
+    virtual ~vtkPointSetXMLParser();
     
     /**
      * A stack containing the parsed start-tags. 
Index: mitk/Core/Rendering/mitkBaseRenderer.cpp
===================================================================
--- mitk/Core/Rendering/mitkBaseRenderer.cpp	(revision 14764)
+++ mitk/Core/Rendering/mitkBaseRenderer.cpp	(working copy)
@@ -180,14 +180,9 @@
   m_CameraRotationController->AcquireCamera();
 
   m_CameraController = VtkInteractorCameraController::New(); //B/
-  
 
-  m_ReferenceCountLock.Lock();
-  m_ReferenceCount = 0;
-  m_ReferenceCountLock.Unlock();
+  m_VtkRenderer = vtkRenderer::New();
 
-  m_VtkRenderer = vtkRenderer::New();
-  
   if (mitk::VtkLayerController::GetInstance(m_RenderWindow) == NULL)
   {  
     mitk::VtkLayerController::AddInstance(m_RenderWindow,m_VtkRenderer);
@@ -201,6 +196,12 @@
 //##ModelId=3E3D2F12008C
 mitk::BaseRenderer::~BaseRenderer()
 {
+  if(m_VtkRenderer!=NULL)
+  {
+    m_VtkRenderer->Delete();
+    m_VtkRenderer = NULL;
+  }
+
   if(m_CameraController.IsNotNull())
     m_CameraController->SetRenderer(NULL);
   
Index: mitk/Core/Rendering/mitkBaseVtkMapper3D.cpp
===================================================================
--- mitk/Core/Rendering/mitkBaseVtkMapper3D.cpp	(revision 14764)
+++ mitk/Core/Rendering/mitkBaseVtkMapper3D.cpp	(working copy)
@@ -199,5 +199,12 @@
 #endif
 }
 
+void BaseVtkMapper3D::ReleaseGraphicsResources(vtkWindow *renWin)
+{
+  if(m_Prop3D)
+    m_Prop3D->ReleaseGraphicsResources(renWin);
+}
+
+
 } // namespace
 
Index: mitk/Core/Rendering/mitkBaseVtkMapper3D.h
===================================================================
--- mitk/Core/Rendering/mitkBaseVtkMapper3D.h	(revision 14764)
+++ mitk/Core/Rendering/mitkBaseVtkMapper3D.h	(working copy)
@@ -62,6 +62,12 @@
   //## @brief Apply color and opacity read from the PropertyList
   virtual void ApplyProperties(vtkActor* actor, mitk::BaseRenderer* renderer);
 
+  /** 
+  * \brief Release vtk-based graphics resources. Must be overwritten in
+  * subclasses if vtkProps additional to m_Prop3D are used.
+  */
+  virtual void ReleaseGraphicsResources(vtkWindow *renWin);
+
 protected:
   BaseVtkMapper3D();
 
Index: mitk/Core/Rendering/mitkColoredRectangleRendering.cpp
===================================================================
--- mitk/Core/Rendering/mitkColoredRectangleRendering.cpp	(revision 14764)
+++ mitk/Core/Rendering/mitkColoredRectangleRendering.cpp	(working copy)
@@ -92,7 +92,9 @@
   rect->SetColor(col1, col2, col3);
 
   m_RectangleRenderer->AddViewProp(rect);
-    
+
+  rect->Delete();
+
   if(!mitk::VtkLayerController::GetInstance(m_RenderWindow)->IsRendererInserted( m_RectangleRenderer ))
   {
     #if ( VTK_MAJOR_VERSION >= 5 )
Index: mitk/Core/Rendering/mitkGeometry2DDataVtkMapper3D.cpp
===================================================================
--- mitk/Core/Rendering/mitkGeometry2DDataVtkMapper3D.cpp	(revision 14764)
+++ mitk/Core/Rendering/mitkGeometry2DDataVtkMapper3D.cpp	(working copy)
@@ -93,9 +93,12 @@
   m_BackgroundActor->GetProperty()->SetColor( 0.0, 0.0, 0.0 );
   m_BackgroundActor->GetProperty()->SetOpacity( 1.0 );
   m_BackgroundActor->SetMapper( m_BackgroundMapper );
-  m_BackgroundActor->SetBackfaceProperty( m_BackgroundActor->MakeProperty() );
-  m_BackgroundActor->GetBackfaceProperty()->SetColor( 0.0, 0.0, 0.0 );
 
+  vtkProperty * backfaceProperty = m_BackgroundActor->MakeProperty();
+  backfaceProperty->SetColor( 0.0, 0.0, 0.0 );
+  m_BackgroundActor->SetBackfaceProperty( backfaceProperty );
+  backfaceProperty->Delete();
+
   m_FrontHedgeHog = vtkHedgeHog::New();
   m_BackHedgeHog  = vtkHedgeHog::New();
 
Index: mitk/Core/Rendering/mitkGradientBackground.cpp
===================================================================
--- mitk/Core/Rendering/mitkGradientBackground.cpp	(revision 14764)
+++ mitk/Core/Rendering/mitkGradientBackground.cpp	(working copy)
@@ -68,6 +68,10 @@
   m_Plane->SetPolys( cellArray );
   m_Plane->GetPointData()->SetScalars( data );
 
+  points->Delete();
+  cellArray->Delete();
+  data->Delete();
+
   m_Lut->SetNumberOfColors( 2 );
   m_Lut->Build();
   m_Lut->SetTableValue( m_Lut->GetIndex(0), 1, 1, 1 );
Index: mitk/Core/Rendering/mitkLogoRendering.cpp
===================================================================
--- mitk/Core/Rendering/mitkLogoRendering.cpp	(revision 14764)
+++ mitk/Core/Rendering/mitkLogoRendering.cpp	(working copy)
@@ -188,7 +188,7 @@
             *dest++ = a;
           }        
 
-      m_VtkImageImport->SetImportVoidPointer(m_ImageData);
+      m_VtkImageImport->SetImportVoidPointer(m_ImageData, 0 /*delete on destruct*/);
       m_VtkImageImport->Modified();
       m_VtkImageImport->Update();
       
Index: mitk/Core/Rendering/mitkMapper.h
===================================================================
--- mitk/Core/Rendering/mitkMapper.h	(revision 14764)
+++ mitk/Core/Rendering/mitkMapper.h	(working copy)
@@ -25,6 +25,8 @@
 #include "itkWeakPointer.h"
 #include "mitkXMLIO.h"
 
+class vtkWindow;
+
 namespace mitk {
 
   class BaseRenderer;
@@ -102,13 +104,20 @@
     virtual void MitkRenderOpaqueGeometry(mitk::BaseRenderer* renderer) = 0;
     virtual void MitkRenderTranslucentGeometry(mitk::BaseRenderer* renderer) = 0;
 
-
-
+    /** 
+    * \brief Returns whether this is an vtk-based mapper
+    */
     bool IsVtkBased() const
     {
       return m_VtkBased;
     }
 
+    /** 
+    * \brief Release vtk-based graphics resources. Must be overwritten in
+    * subclasses if vtkProps are used.
+    */
+    virtual void ReleaseGraphicsResources(vtkWindow *renWin) { };
+
     //##Documentation
     virtual const std::string& GetXMLNodeName() const;
 
Index: mitk/Core/Rendering/mitkPointSetVtkMapper3D.cpp
===================================================================
--- mitk/Core/Rendering/mitkPointSetVtkMapper3D.cpp	(revision 14764)
+++ mitk/Core/Rendering/mitkPointSetVtkMapper3D.cpp	(working copy)
@@ -80,12 +80,20 @@
 {
   m_PointsAssembly->Delete();
 
-  //m_SelectedActor->Delete(); //leads to an exeption
+  m_SelectedActor->Delete(); //leads to an exeption
   m_UnselectedActor->Delete();
   m_ContourActor->Delete();
 }
 
+void mitk::PointSetVtkMapper3D::ReleaseGraphicsResources(vtkWindow *renWin)
+{
+  m_PointsAssembly->ReleaseGraphicsResources(renWin);
 
+  m_SelectedActor->ReleaseGraphicsResources(renWin);
+  m_UnselectedActor->ReleaseGraphicsResources(renWin);
+  m_ContourActor->ReleaseGraphicsResources(renWin);
+}
+
 void mitk::PointSetVtkMapper3D::GenerateData()
 {
   m_PointsAssembly->VisibilityOn();
@@ -340,7 +348,6 @@
   {
     m_VtkSelectedPolyDataMapper = vtkPolyDataMapper::New();
     m_VtkSelectedPolyDataMapper->SetInput(m_vtkSelectedPointList->GetOutput());
-    m_vtkSelectedPointList->Delete();
 
     //create a new instance of the actor
     m_SelectedActor->Delete();
@@ -350,12 +357,12 @@
     m_VtkSelectedPolyDataMapper->Delete();
     m_PointsAssembly->AddPart(m_SelectedActor);
   }
+  m_vtkSelectedPointList->Delete();
 
   if (m_NumberOfUnselectedAdded > 0)
   {
     m_VtkUnselectedPolyDataMapper = vtkPolyDataMapper::New();
     m_VtkUnselectedPolyDataMapper->SetInput(m_vtkUnselectedPointList->GetOutput());
-    m_vtkUnselectedPointList->Delete();
 
     //create a new instance of the actor
     m_UnselectedActor->Delete();
@@ -365,6 +372,7 @@
     m_VtkUnselectedPolyDataMapper->Delete();
     m_PointsAssembly->AddPart(m_UnselectedActor);
   }
+  m_vtkUnselectedPointList->Delete();
 
     //apply props
   Superclass::ApplyProperties( m_ContourActor, NULL );
Index: mitk/Core/Rendering/mitkPointSetVtkMapper3D.h
===================================================================
--- mitk/Core/Rendering/mitkPointSetVtkMapper3D.h	(revision 14764)
+++ mitk/Core/Rendering/mitkPointSetVtkMapper3D.h	(working copy)
@@ -80,6 +80,8 @@
 
   static void SetDefaultProperties(mitk::DataTreeNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
+  void ReleaseGraphicsResources(vtkWindow *renWin);
+
 protected:
   PointSetVtkMapper3D();
 
Index: mitk/Core/Rendering/mitkVolumeDataVtkMapper3D.cpp
===================================================================
--- mitk/Core/Rendering/mitkVolumeDataVtkMapper3D.cpp	(revision 14764)
+++ mitk/Core/Rendering/mitkVolumeDataVtkMapper3D.cpp	(working copy)
@@ -164,6 +164,10 @@
   m_VolumeLOD->Delete();
   m_ClippingPlane->Delete();
   m_PlaneWidget->Delete();
+  m_Prop3DAssembly->Delete();
+  m_BoundingBox->Delete();
+  m_BoundingBoxMapper->Delete();
+  m_BoundingBoxActor->Delete();
   m_ImageMaskFilter->Delete();
 
   if (m_Mask)
Index: mitk/Core/Rendering/mitkVtkPropRenderer.cpp
===================================================================
--- mitk/Core/Rendering/mitkVtkPropRenderer.cpp	(revision 14764)
+++ mitk/Core/Rendering/mitkVtkPropRenderer.cpp	(working copy)
@@ -98,6 +98,8 @@
     m_CameraController = NULL;
 
     m_VtkRenderer->Delete();
+
+    m_VtkRenderer = NULL;
   }
   else
     m_CameraController = NULL;
@@ -588,6 +590,26 @@
     return NULL;
   }
 }
+
+void mitk::VtkPropRenderer::ReleaseGraphicsResources(vtkWindow *renWin)
+{
+  if(m_DataTreeIterator.IsNull())
+    return;
+
+  mitk::DataTreeIteratorClone it = m_DataTreeIterator;
+
+  for(;it->IsAtEnd()==false;++it)
+  {
+    mitk::DataTreeNode::Pointer node = it->Get();
+    if(node.IsNull())
+      continue;
+    mitk::Mapper::Pointer mapper = node->GetMapper(m_MapperID);
+    if(mapper.IsNotNull())
+    {
+      mapper->ReleaseGraphicsResources(renWin);
+    }
+  }
+}
   
 vtkWorldPointPicker* mitk::VtkPropRenderer::GetWorldPointPicker()
 {
Index: mitk/Core/Rendering/mitkVtkPropRenderer.h
===================================================================
--- mitk/Core/Rendering/mitkVtkPropRenderer.h	(revision 14764)
+++ mitk/Core/Rendering/mitkVtkPropRenderer.h	(working copy)
@@ -56,7 +56,7 @@
 public:
   
   mitkClassMacro(VtkPropRenderer,BaseRenderer);
-  VtkPropRenderer( const char* name = "VtkPropRenderer", vtkRenderWindow * renWin = NULL);
+  mitkNewMacro2Param(VtkPropRenderer, const char*, vtkRenderWindow *);
   
   // Render - called by vtkMitkRenderProp, returns the number of props rendered
   enum RenderType{Opaque,Translucent,Overlay};
@@ -112,8 +112,14 @@
   vtkWorldPointPicker* GetWorldPointPicker();
   vtkPointPicker* GetPointPicker();
   
+  /** 
+  * \brief Release vtk-based graphics resources. Called by
+  * vtkMitkRenderProp::ReleaseGraphicsResources.
+  */
+  virtual void ReleaseGraphicsResources(vtkWindow *renWin);
+
 protected:
-  
+  VtkPropRenderer( const char* name = "VtkPropRenderer", vtkRenderWindow * renWin = NULL);
   virtual ~VtkPropRenderer();
   virtual void Update();
 
Index: mitk/Core/Rendering/vtkMitkRectangleProp.h
===================================================================
--- mitk/Core/Rendering/vtkMitkRectangleProp.h	(revision 14764)
+++ mitk/Core/Rendering/vtkMitkRectangleProp.h	(working copy)
@@ -27,8 +27,8 @@
 class MITK_CORE_EXPORT vtkMitkRectangleProp : public vtkProp
 {
   public:
-    
     static vtkMitkRectangleProp* New();
+    vtkTypeMacro(vtkMitkRectangleProp,vtkProp);
 
     int RenderOpaqueGeometry(vtkViewport* viewport);
     int RenderTranslucentGeometry(vtkViewport* viewport);
Index: mitk/Core/Rendering/vtkMitkRenderProp.cpp
===================================================================
--- mitk/Core/Rendering/vtkMitkRenderProp.cpp	(revision 14764)
+++ mitk/Core/Rendering/vtkMitkRenderProp.cpp	(working copy)
@@ -52,8 +52,9 @@
   return m_VtkPropRenderer->Render(mitk::VtkPropRenderer::Overlay);
 }
 
-void vtkMitkRenderProp::ReleaseGraphicsResources(vtkWindow* /*window*/)
-{ //B/ what shall we do here....
+void vtkMitkRenderProp::ReleaseGraphicsResources(vtkWindow* window)
+{
+  m_VtkPropRenderer->ReleaseGraphicsResources(window);
 }
 
 void vtkMitkRenderProp::InitPathTraversal()
Index: mitk/Core/Rendering/vtkMitkRenderProp.h
===================================================================
--- mitk/Core/Rendering/vtkMitkRenderProp.h	(revision 14764)
+++ mitk/Core/Rendering/vtkMitkRenderProp.h	(working copy)
@@ -38,8 +38,8 @@
 class MITK_CORE_EXPORT vtkMitkRenderProp : public vtkProp
 {
   public:
-    
     static vtkMitkRenderProp *New();
+    vtkTypeMacro(vtkMitkRenderProp,vtkProp);
 
     void SetPropRenderer(mitk::VtkPropRenderer::Pointer propRenderer);
 
Index: mitk/Q4mitk/QmitkRenderWindow.cpp
===================================================================
--- mitk/Q4mitk/QmitkRenderWindow.cpp	(revision 14764)
+++ mitk/Q4mitk/QmitkRenderWindow.cpp	(working copy)
@@ -39,7 +39,7 @@
 {
   if(m_Renderer.IsNull())
   {
-    m_Renderer = new mitk::VtkPropRenderer( qPrintable(name), GetRenderWindow());
+    m_Renderer = mitk::VtkPropRenderer::New( qPrintable(name), GetRenderWindow());
   }
 
   m_Renderer->InitRenderer(this->GetRenderWindow());
Index: mitk/QApplications/Tutorial/Step6.cpp
===================================================================
--- mitk/QApplications/Tutorial/Step6.cpp	(revision 14764)
+++ mitk/QApplications/Tutorial/Step6.cpp	(working copy)
@@ -106,9 +106,6 @@
   // Part I: Basic initialization
   //*************************************************************************
 
-  // Create a tree
-  m_Tree=mitk::DataTree::New();
-
   // Create an iterator on the tree
   mitk::DataTreePreOrderIterator it(m_Tree);
 
Index: mitk/Qmitk/QmitkLevelWindowWidgetContextMenu.cpp
===================================================================
--- mitk/Qmitk/QmitkLevelWindowWidgetContextMenu.cpp	(revision 14764)
+++ mitk/Qmitk/QmitkLevelWindowWidgetContextMenu.cpp	(working copy)
@@ -24,7 +24,7 @@
 QmitkLevelWindowWidgetContextMenu::QmitkLevelWindowWidgetContextMenu(QWidget * parent, const char * name, WFlags f )
 : QWidget( parent, name, f )
 {
-  m_LevelWindowPreset = new mitk::LevelWindowPreset();
+  m_LevelWindowPreset = mitk::LevelWindowPreset::New();
   m_LevelWindowPreset->LoadPreset();
 }
 
Index: mitk/Qmitk/QmitkRenderWindow.cpp
===================================================================
--- mitk/Qmitk/QmitkRenderWindow.cpp	(revision 14764)
+++ mitk/Qmitk/QmitkRenderWindow.cpp	(working copy)
@@ -34,7 +34,7 @@
   if(m_Renderer.IsNull())
   {
     std::string rendererName(name);
-    m_Renderer = new mitk::VtkPropRenderer( rendererName.c_str(), GetRenderWindow());
+    m_Renderer = mitk::VtkPropRenderer::New( rendererName.c_str(), GetRenderWindow());
   }
 
   m_Renderer->InitRenderer(this->GetRenderWindow());
Index: mitk/Qmitk/QmitkSelectableGLWidget.ui.h
===================================================================
--- mitk/Qmitk/QmitkSelectableGLWidget.ui.h	(revision 14764)
+++ mitk/Qmitk/QmitkSelectableGLWidget.ui.h	(working copy)
@@ -35,7 +35,7 @@
   rendererName += name();
 
   // create Renderer
-  m_Renderer= new mitk::VtkPropRenderer( rendererName ); 
+  m_Renderer= mitk::VtkPropRenderer::New( rendererName, NULL ); 
 
   // create widget
   QString composedName("QSGLWt::");
Index: mitk/Qmitk/QmitkStdMultiWidget.ui
===================================================================
--- mitk/Qmitk/QmitkStdMultiWidget.ui	(revision 14764)
+++ mitk/Qmitk/QmitkStdMultiWidget.ui	(working copy)
@@ -191,8 +191,8 @@
     <variable>mitk::PositionTracker::Pointer m_PositionTracker;</variable>
     <variable>mitk::DataTreeNode::Pointer m_PositionTrackerNode;</variable>
     <variable>mitk::DataTreeBase::Pointer m_Tree;</variable>
-    <variable>mitk::SlicesRotator *m_SlicesRotator;</variable>
-    <variable>mitk::SlicesSwiveller *m_SlicesSwiveller;</variable>
+    <variable>mitk::SlicesRotator::Pointer m_SlicesRotator;</variable>
+    <variable>mitk::SlicesSwiveller::Pointer m_SlicesSwiveller;</variable>
     <variable>mitk::GradientBackground::Pointer m_GradientBackground1;</variable>
     <variable>mitk::GradientBackground::Pointer m_GradientBackground2;</variable>
     <variable>mitk::LogoRendering::Pointer m_LogoRendering1;</variable>
Index: mitk/Qmitk/QmitkStdMultiWidget.ui.h
===================================================================
--- mitk/Qmitk/QmitkStdMultiWidget.ui.h	(revision 14764)
+++ mitk/Qmitk/QmitkStdMultiWidget.ui.h	(working copy)
@@ -98,7 +98,7 @@
   // m_SlicesRotator = mitk::SlicesRotator::New();
   // @TODO next line causes sure memory leak
   // rotator will be created nonetheless (will be switched on and off)
-  m_SlicesRotator = new mitk::SlicesRotator("slices-rotator");
+  m_SlicesRotator = mitk::SlicesRotator::New("slices-rotator");
   m_SlicesRotator->AddSliceController( 
     mitkWidget1->GetSliceNavigationController() );
   m_SlicesRotator->AddSliceController( 
@@ -107,7 +107,7 @@
     mitkWidget3->GetSliceNavigationController() );
 
   // create a slice swiveller (using the same state-machine as SlicesRotator)
-  m_SlicesSwiveller = new mitk::SlicesSwiveller("slices-rotator");
+  m_SlicesSwiveller = mitk::SlicesSwiveller::New("slices-rotator");
   m_SlicesSwiveller->AddSliceController( 
     mitkWidget1->GetSliceNavigationController() );
   m_SlicesSwiveller->AddSliceController( 
Index: mitk/Testing/mitkContourMapper2DTest.cpp
===================================================================
--- mitk/Testing/mitkContourMapper2DTest.cpp	(revision 14764)
+++ mitk/Testing/mitkContourMapper2DTest.cpp	(working copy)
@@ -44,8 +44,8 @@
   }
   else {
   std::cout<<"[PASSED]"<<std::endl;
-  } 
-  
+  }
+
   contourMapper->SetDataTreeNode( node );
   contourMapper->Update(NULL);
   mitk::Contour* testContour = (mitk::Contour*)contourMapper->GetInput();
@@ -53,27 +53,26 @@
   
   mitk::DataTree::Pointer dataTree = mitk::DataTree::New();
   mitk::DataTreePreOrderIterator it(dataTree);
-  
+
   it.Add( node );
-  
+
   mitk::BoundingBox::Pointer bounds = mitk::DataTree::ComputeBoundingBox(&it);
-  
+
   std::cout << "bounds: " << bounds << std::endl;
 
   bounds = mitk::DataTree::ComputeVisibleBoundingBox(&it);
   std::cout << "visible bounds: " << bounds << std::endl;
- 
+
   vtkRenderWindow* renWin = vtkRenderWindow::New();
-  mitk::VtkPropRenderer * renderer = new mitk::VtkPropRenderer("ContourRenderer",renWin);
-    
+  mitk::VtkPropRenderer::Pointer renderer = mitk::VtkPropRenderer::New("ContourRenderer",renWin);
+
   std::cout<<"Testing mitk::BaseRenderer::SetData()"<<std::endl;
-  
+
   renderer->SetData(&it);
 
   std::cout<<"[TEST DONE]"<<std::endl;
 
   renWin->Delete();
-  renderer->Delete();
 
   return EXIT_SUCCESS;
 }
Index: mitk/Testing/mitkEventTest.cpp
===================================================================
--- mitk/Testing/mitkEventTest.cpp	(revision 14764)
+++ mitk/Testing/mitkEventTest.cpp	(working copy)
@@ -23,11 +23,11 @@
 int mitkEventTest(int /*argc*/, char* /*argv*/[])
 {
   vtkRenderWindow* renWin = vtkRenderWindow::New();
-  mitk::VtkPropRenderer * renderer = new mitk::VtkPropRenderer("ContourRenderer",renWin);
-  
+  mitk::VtkPropRenderer::Pointer renderer = mitk::VtkPropRenderer::New("ContourRenderer",renWin);
+
   //Create Event
   mitk::Event * event = new mitk::Event(renderer, 0, 1, 2, 3);
-  
+
   //check Get...
   std::cout << "check the get methods of the Event";
   if (event->GetSender() != renderer ||
@@ -44,7 +44,6 @@
   std::cout<<"[PASSED]"<<std::endl;
 
   renWin->Delete();
-  renderer->Delete();
 
   std::cout<<"[TEST DONE]"<<std::endl;
   return EXIT_SUCCESS;
Index: mitk/Testing/mitkImageMapper2DTest.cpp
===================================================================
--- mitk/Testing/mitkImageMapper2DTest.cpp	(revision 14764)
+++ mitk/Testing/mitkImageMapper2DTest.cpp	(working copy)
@@ -23,9 +23,14 @@
 #include <mitkLevelWindow.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkVtkPropRenderer.h>
+#include <mitkVolumeDataVtkMapper3D.h>
+#include <mitkTransferFunctionProperty.h>
+#include <mitkTransferFunction.h>
 
 #include <mitkNativeRenderWindowInteractor.h>
 
+#include "mitkReferenceCountWatcher.h"
+
 #include <fstream>
 int mitkImageMapper2DTest(int /*argc*/, char* /*argv*/[])
 {
@@ -50,10 +55,28 @@
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Creating tree: ";
-  mitk::DataTree* tree;
-  (tree=mitk::DataTree::New())->Register(); //@FIXME: da DataTreeIteratorClone keinen Smartpointer auf DataTree h�lt, wird tree sonst gel�scht.
+  mitk::DataTree::Pointer tree;
+  tree=mitk::DataTree::New();
   std::cout<<"[PASSED]"<<std::endl;
 
+  std::cout << "Testing reference count of tree: ";
+  mitk::ReferenceCountWatcher::Pointer treeWatcher = new mitk::ReferenceCountWatcher(tree, "tree");
+  if(treeWatcher->GetReferenceCount()!=1)
+  {
+    std::cout<<treeWatcher->GetReferenceCount()<<"!=1 [FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing reference count of node: ";
+  mitk::ReferenceCountWatcher::Pointer nodeWatcher = new mitk::ReferenceCountWatcher(node, "node");
+  if(nodeWatcher->GetReferenceCount()!=1)
+  {
+    std::cout<<nodeWatcher->GetReferenceCount()<<"!=1 [FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
   std::cout << "Creating iterator on tree: ";
   mitk::DataTreePreOrderIterator it(tree);
   std::cout<<"[PASSED]"<<std::endl;
@@ -72,24 +95,113 @@
 
   std::cout << "Creating VtkPropRenderer: ";
   vtkRenderWindow *renderWindow = vtkRenderWindow::New();
-  mitk::VtkPropRenderer *propRenderer = new mitk::VtkPropRenderer( "the renderer", renderWindow );
+  mitk::VtkPropRenderer::Pointer propRenderer = mitk::VtkPropRenderer::New( "the renderer", renderWindow );
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "BaseRenderer::SetData(iterator): ";
   propRenderer->SetData(&it);
   std::cout<<"[PASSED]"<<std::endl;
 
+  std::cout << "Testing reference count of node: ";
+  if(nodeWatcher->GetReferenceCount()!=2)
+  {
+    std::cout<<nodeWatcher->GetReferenceCount()<<"!=2 [FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
   std::cout << "Testing if an mitk::ImageMapper2D was created: ";
-  if(dynamic_cast<mitk::ImageMapper2D*>(node->GetMapper(1))==NULL)
+  if(dynamic_cast<mitk::ImageMapper2D*>(node->GetMapper(mitk::BaseRenderer::Standard2D))==NULL)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
+  std::cout << "Testing if an mitk::VolumeDataVtkMapper3D was created: ";
+  if(dynamic_cast<mitk::VolumeDataVtkMapper3D*>(node->GetMapper(mitk::BaseRenderer::Standard3D))==NULL)
+  {
+    std::cout<<"[FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing if an mitk::TransferFunctionProperty was created: ";
+  mitk::TransferFunctionProperty::Pointer transferFctProperty;
+  if(node->GetProperty<mitk::TransferFunctionProperty>(transferFctProperty, "TransferFunction") == false)
+  {
+    std::cout<<"[FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing if an mitk::TransferFunctionProperty contains an mitk::TransferFunction: ";
+  mitk::TransferFunction::Pointer transferFct = transferFctProperty->GetValue();
+  if(transferFct.IsNull())
+  {
+    std::cout<<"[FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing reference count of mitk::TransferFunctionProperty: ";
+  mitk::ReferenceCountWatcher::Pointer transferFctPropertyWatcher = new mitk::ReferenceCountWatcher(transferFctProperty, "transferFctProperty");
+  transferFctProperty = NULL;
+  if(transferFctPropertyWatcher->GetReferenceCount()!=1)
+  {
+    std::cout<<transferFctPropertyWatcher->GetReferenceCount()<<"!=1 [FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing reference count of mitk::TransferFunctionProperty: ";
+  mitk::ReferenceCountWatcher::Pointer transferFctWatcher = new mitk::ReferenceCountWatcher(transferFct, "transferFct");
+  transferFct = NULL;
+  if(transferFctWatcher->GetReferenceCount()!=1)
+  {
+    std::cout<<transferFctWatcher->GetReferenceCount()<<"!=1 [FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Deleting renderwindow, node and tree: ";
   renderWindow->Delete();
-  tree = NULL; // As the tree has been registered explicitely, destroy it again.
+  node = NULL;
+  tree = NULL;
+  std::cout<<"[PASSED]"<<std::endl;
 
+  std::cout << "Testing reference count of tree: ";
+  if(treeWatcher->GetReferenceCount()!=0)
+  {
+    std::cout<<treeWatcher->GetReferenceCount()<<"!=0 [FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing reference count of node: ";
+  if(nodeWatcher->GetReferenceCount()!=0)
+  {
+    std::cout<<nodeWatcher->GetReferenceCount()<<"!=0 [FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing reference count of mitk::TransferFunctionProperty: ";
+  if(transferFctPropertyWatcher->GetReferenceCount()!=0)
+  {
+    std::cout<<transferFctPropertyWatcher->GetReferenceCount()<<"!=0 [FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing reference count of mitk::TransferFunctionProperty: ";
+  if(transferFctWatcher->GetReferenceCount()!=0)
+  {
+    std::cout<<transferFctWatcher->GetReferenceCount()<<"!=0 [FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
   std::cout<<"[TEST DONE]"<<std::endl;
   return EXIT_SUCCESS;
 }
Index: mitk/Testing/mitkManualSegmentationToSurfaceFilterTest.cpp
===================================================================
--- mitk/Testing/mitkManualSegmentationToSurfaceFilterTest.cpp	(revision 14764)
+++ mitk/Testing/mitkManualSegmentationToSurfaceFilterTest.cpp	(working copy)
@@ -52,7 +52,7 @@
   mitk::DataTreeNodeFactory::Pointer factory = mitk::DataTreeNodeFactory::New();
   try
   {
-    std::cout << "Loading file: ";
+    std::cout << "Loading file: "<<std::flush;
     factory->SetFileName( fileIn.c_str() );
     factory->Update();
 
Index: mitk/Testing/mitkStateMachineFactoryTest.cpp
===================================================================
--- mitk/Testing/mitkStateMachineFactoryTest.cpp	(revision 14764)
+++ mitk/Testing/mitkStateMachineFactoryTest.cpp	(working copy)
@@ -23,7 +23,7 @@
 int mitkStateMachineFactoryTest(int /*argc*/, char* /*argv*/[])
 {
   //create statemachinefactory
-  mitk::StateMachineFactory* statemachineFactory = new mitk::StateMachineFactory();
+  mitk::StateMachineFactory* statemachineFactory = mitk::StateMachineFactory::New();
   
   //load standard behavior 
   std::cout << "Testing LoadStandardBehavior(): ";
Index: mitk/Testing/mitkVtkPropRendererTest.cpp
===================================================================
--- mitk/Testing/mitkVtkPropRendererTest.cpp	(revision 14764)
+++ mitk/Testing/mitkVtkPropRendererTest.cpp	(working copy)
@@ -75,8 +75,8 @@
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Creating tree: ";
-  mitk::DataTree* tree;
-  (tree=mitk::DataTree::New())->Register(); //@FIXME: da DataTreeIteratorClone keinen Smartpointer auf DataTree h�lt, wird tree sonst gel�scht.
+  mitk::DataTree::Pointer tree;
+  tree=mitk::DataTree::New();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Creating iterator on tree: ";
@@ -103,21 +103,24 @@
 
   vtkPolyDataMapper *map = vtkPolyDataMapper::New();
   map->SetInput(sphere->GetOutput());
+  sphere->Delete();
 
   vtkActor *aSphere = vtkActor::New();
   aSphere->SetMapper(map);
+  map->Delete();
   aSphere->GetProperty()->SetColor(0,0,1); // sphere color blue
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Creating a renderer for the sphere: ";
   vtkRenderer *sphereRenderer = vtkRenderer::New();
   sphereRenderer->AddActor(aSphere);
+  aSphere->Delete();
   //sphereRenderer->SetBackground(1,1,1); // Background color white
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Creating vtkRenderWindow and VtkPropRenderer: ";
   vtkRenderWindow *renderWindow = vtkRenderWindow::New();
-  mitk::VtkPropRenderer *propRenderer = new mitk::VtkPropRenderer( "the renderer", renderWindow );
+  mitk::VtkPropRenderer::Pointer propRenderer = mitk::VtkPropRenderer::New( "the renderer", renderWindow );
   //propRenderer->SetMapperID(2);
   std::cout<<"[PASSED]"<<std::endl;
 
@@ -198,7 +201,15 @@
   //  std::cout<<"Unknown image, comparison test skipped"<<std::endl;
   //}
 
+
+  propRenderer->GetVtkRenderer()->RemoveViewProp(renderProp);
+  renderProp->Delete();
+  propRenderer = NULL;
+  sphereRenderer->Delete();
+
   renderWindow->Delete();
+
+  vtkImage->Delete();
   tree = NULL; // As the tree has been registered explicitely, destroy it again.
 
   std::cout<<"[TEST DONE]"<<std::endl;