diff --git a/Core/Code/Controllers/mitkCoreActivator.cpp b/Core/Code/Controllers/mitkCoreActivator.cpp
index 052a3aa8a7..be55e61c1e 100644
--- a/Core/Code/Controllers/mitkCoreActivator.cpp
+++ b/Core/Code/Controllers/mitkCoreActivator.cpp
@@ -1,209 +1,209 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkRenderingManager.h"
 #include "mitkPlanePositionManager.h"
 #include <mitkCoreDataNodeReader.h>
 #include <mitkStandardFileLocations.h>
-#include <mitkShaderRepository.h>
+//#include <mitkShaderRepository.h>
 #include <mitkPropertyAliases.h>
 #include <mitkPropertyDescriptions.h>
 #include <mitkPropertyExtensions.h>
 #include <mitkPropertyFilters.h>
 #include <mitkIOUtil.h>
 
 #include <usModuleInitialization.h>
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usModuleSettings.h>
 #include <usModuleEvent.h>
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
 void HandleMicroServicesMessages(us::MsgType type, const char* msg)
 {
   switch (type)
   {
   case us::DebugMsg:
     MITK_DEBUG << msg;
     break;
   case us::InfoMsg:
     MITK_INFO << msg;
     break;
   case us::WarningMsg:
     MITK_WARN << msg;
     break;
   case us::ErrorMsg:
     MITK_ERROR << msg;
     break;
   }
 }
 
 void AddMitkAutoLoadPaths(const std::string& programPath)
 {
   us::ModuleSettings::AddAutoLoadPath(programPath);
 #ifdef __APPLE__
   // Walk up three directories since that is where the .dylib files are located
   // for build trees.
   std::string additionalPath = programPath;
   bool addPath = true;
   for(int i = 0; i < 3; ++i)
   {
     std::size_t index = additionalPath.find_last_of('/');
     if (index != std::string::npos)
     {
       additionalPath = additionalPath.substr(0, index);
     }
     else
     {
       addPath = false;
       break;
     }
   }
   if (addPath)
   {
     us::ModuleSettings::AddAutoLoadPath(additionalPath);
   }
 #endif
 }
 
 /*
  * This is the module activator for the "Mitk" module. It registers core services
  * like ...
  */
 class MitkCoreActivator : public us::ModuleActivator
 {
 public:
 
   void Load(us::ModuleContext* context)
   {
     // Handle messages from CppMicroServices
     us::installMsgHandler(HandleMicroServicesMessages);
 
     // Add the current application directory to the auto-load paths.
     // This is useful for third-party executables.
     std::string programPath = mitk::IOUtil::GetProgramPath();
     if (programPath.empty())
     {
       MITK_WARN << "Could not get the program path.";
     }
     else
     {
       AddMitkAutoLoadPaths(programPath);
     }
 
     //m_RenderingManager = mitk::RenderingManager::New();
     //context->RegisterService<mitk::RenderingManager>(renderingManager.GetPointer());
     m_PlanePositionManager.reset(new mitk::PlanePositionManagerService);
     context->RegisterService<mitk::PlanePositionManagerService>(m_PlanePositionManager.get());
 
     m_CoreDataNodeReader.reset(new mitk::CoreDataNodeReader);
     context->RegisterService<mitk::IDataNodeReader>(m_CoreDataNodeReader.get());
 
     m_PropertyAliases.reset(new mitk::PropertyAliases);
     context->RegisterService<mitk::IPropertyAliases>(m_PropertyAliases.get());
 
     m_PropertyDescriptions.reset(new mitk::PropertyDescriptions);
     context->RegisterService<mitk::IPropertyDescriptions>(m_PropertyDescriptions.get());
 
     m_PropertyExtensions.reset(new mitk::PropertyExtensions);
     context->RegisterService<mitk::IPropertyExtensions>(m_PropertyExtensions.get());
 
     m_PropertyFilters.reset(new mitk::PropertyFilters);
     context->RegisterService<mitk::IPropertyFilters>(m_PropertyFilters.get());
 
     context->AddModuleListener(this, &MitkCoreActivator::HandleModuleEvent);
 
     /*
     There IS an option to exchange ALL vtkTexture instances against vtkNeverTranslucentTextureFactory.
     This code is left here as a reminder, just in case we might need to do that some time.
 
     vtkNeverTranslucentTextureFactory* textureFactory = vtkNeverTranslucentTextureFactory::New();
     vtkObjectFactory::RegisterFactory( textureFactory );
     textureFactory->Delete();
     */
   }
 
   void Unload(us::ModuleContext* )
   {
     // The mitk::ModuleContext* argument of the Unload() method
     // will always be 0 for the Mitk library. It makes no sense
     // to use it at this stage anyway, since all libraries which
     // know about the module system have already been unloaded.
   }
 
 private:
 
   void HandleModuleEvent(const us::ModuleEvent moduleEvent);
 
   std::map<long, std::vector<int> > moduleIdToShaderIds;
 
   //mitk::RenderingManager::Pointer m_RenderingManager;
   std::auto_ptr<mitk::PlanePositionManagerService> m_PlanePositionManager;
   std::auto_ptr<mitk::CoreDataNodeReader> m_CoreDataNodeReader;
   std::auto_ptr<mitk::PropertyAliases> m_PropertyAliases;
   std::auto_ptr<mitk::PropertyDescriptions> m_PropertyDescriptions;
   std::auto_ptr<mitk::PropertyExtensions> m_PropertyExtensions;
   std::auto_ptr<mitk::PropertyFilters> m_PropertyFilters;
 };
 
 void MitkCoreActivator::HandleModuleEvent(const us::ModuleEvent moduleEvent)
 {
   if (moduleEvent.GetType() == us::ModuleEvent::LOADED)
   {
     // search and load shader files
     std::vector<us::ModuleResource> shaderResoruces =
         moduleEvent.GetModule()->FindResources("Shaders", "*.xml", true);
     for (std::vector<us::ModuleResource>::iterator i = shaderResoruces.begin();
          i != shaderResoruces.end(); ++i)
     {
       if (*i)
       {
         us::ModuleResourceStream rs(*i);
 //        int id = m_ShaderRepository->LoadShader(rs, i->GetBaseName());
 //        if (id >= 0)
 //        {
 //          moduleIdToShaderIds[moduleEvent.GetModule()->GetModuleId()].push_back(id);
 //        }
       }
     }
   }
   else if (moduleEvent.GetType() == us::ModuleEvent::UNLOADED)
   {
     std::map<long, std::vector<int> >::iterator shaderIdsIter =
         moduleIdToShaderIds.find(moduleEvent.GetModule()->GetModuleId());
     if (shaderIdsIter != moduleIdToShaderIds.end())
     {
 //      for (std::vector<int>::iterator idIter = shaderIdsIter->second.begin();
 //           idIter != shaderIdsIter->second.end(); ++idIter)
 //      {
 //        m_ShaderRepository->UnloadShader(*idIter);
 //      }
 //      moduleIdToShaderIds.erase(shaderIdsIter);
     }
   }
 
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(Mitk, MitkCoreActivator)
 
 // Call CppMicroservices initialization code at the end of the file.
 // This especially ensures that VTK object factories have already
 // been registered (VTK initialization code is injected by implicitly
 // include VTK header files at the top of this file).
 US_INITIALIZE_MODULE("Mitk", "Mitk")
diff --git a/Core/Code/Rendering/mitkSurfaceVtkMapper3D.cpp b/Core/Code/Rendering/mitkSurfaceVtkMapper3D.cpp
index 5334257e9a..e36e20225c 100644
--- a/Core/Code/Rendering/mitkSurfaceVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkSurfaceVtkMapper3D.cpp
@@ -1,504 +1,504 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "mitkSurfaceVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkVtkInterpolationProperty.h"
 #include "mitkVtkScalarModeProperty.h"
 #include "mitkClippingProperty.h"
 #include "mitkSmartPointerProperty.h"
 
-#include "mitkShaderProperty.h"
+//#include "mitkShaderProperty.h"
 #include "mitkIShaderRepository.h"
 #include <mitkExtractSliceFilter.h>
 #include <mitkImageSliceSelector.h>
 #include <mitkCoreServices.h>
 
 //VTK
 #include <vtkActor.h>
 #include <vtkProperty.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkPointData.h>
 #include <vtkPlaneCollection.h>
 #include <vtkSmartPointer.h>
 
 const mitk::Surface* mitk::SurfaceVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::Surface * > ( GetDataNode()->GetData() );
 }
 
 mitk::SurfaceVtkMapper3D::SurfaceVtkMapper3D()
 {
     // m_Prop3D = vtkActor::New();
     m_GenerateNormals = false;
 }
 
 mitk::SurfaceVtkMapper3D::~SurfaceVtkMapper3D()
 {
     // m_Prop3D->Delete();
 }
 
 void mitk::SurfaceVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
     LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if(!visible)
   {
     ls->m_Actor->VisibilityOff();
     return;
   }
 
   //
   // set the input-object at time t for the mapper
   //
   mitk::Surface::Pointer input  = const_cast< mitk::Surface* >( this->GetInput() );
   vtkPolyData * polydata = input->GetVtkPolyData( this->GetTimestep() );
   if(polydata == NULL)
   {
     ls->m_Actor->VisibilityOff();
     return;
   }
 
   if ( m_GenerateNormals )
   {
     ls->m_VtkPolyDataNormals->SetInputData( polydata );
     ls->m_VtkPolyDataMapper->SetInputConnection( ls->m_VtkPolyDataNormals->GetOutputPort() );
   }
   else
   {
     ls->m_VtkPolyDataMapper->SetInputData( polydata );
   }
 
   //
   // apply properties read from the PropertyList
   //
   ApplyAllProperties(renderer, ls->m_Actor);
 
   if(visible)
     ls->m_Actor->VisibilityOn();
 }
 
 
 void mitk::SurfaceVtkMapper3D::ResetMapper( BaseRenderer* renderer )
 {
     LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
     ls->m_Actor->VisibilityOff();
 }
 
 void mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(mitk::DataNode *node, vtkProperty* property, mitk::BaseRenderer* renderer)
 {
     // Backface culling
     {
         mitk::BoolProperty::Pointer p;
         node->GetProperty(p, "Backface Culling", renderer);
         bool useCulling = false;
         if(p.IsNotNull())
             useCulling = p->GetValue();
         property->SetBackfaceCulling(useCulling);
     }
 
     // Colors
     {
         double ambient [3] = { 0.5,0.5,0.0 };
         double diffuse [3] = { 0.5,0.5,0.0 };
         double specular[3] = { 1.0,1.0,1.0 };
 
         float coeff_ambient = 0.5f;
         float coeff_diffuse = 0.5f;
         float coeff_specular= 0.5f;
         float power_specular=10.0f;
 
         // Color
         {
             mitk::ColorProperty::Pointer p;
             node->GetProperty(p, "color", renderer);
             if(p.IsNotNull())
             {
                 mitk::Color c = p->GetColor();
                 ambient[0]=c.GetRed(); ambient[1]=c.GetGreen(); ambient[2]=c.GetBlue();
                 diffuse[0]=c.GetRed(); diffuse[1]=c.GetGreen(); diffuse[2]=c.GetBlue();
                 // Setting specular color to the same, make physically no real sense, however vtk rendering slows down, if these colors are different.
                 specular[0]=c.GetRed(); specular[1]=c.GetGreen(); specular[2]=c.GetBlue();
             }
         }
 
         // Ambient
         {
             mitk::ColorProperty::Pointer p;
             node->GetProperty(p, "material.ambientColor", renderer);
             if(p.IsNotNull())
             {
                 mitk::Color c = p->GetColor();
                 ambient[0]=c.GetRed(); ambient[1]=c.GetGreen(); ambient[2]=c.GetBlue();
             }
         }
 
         // Diffuse
         {
             mitk::ColorProperty::Pointer p;
             node->GetProperty(p, "material.diffuseColor", renderer);
             if(p.IsNotNull())
             {
                 mitk::Color c = p->GetColor();
                 diffuse[0]=c.GetRed(); diffuse[1]=c.GetGreen(); diffuse[2]=c.GetBlue();
             }
         }
 
         // Specular
         {
             mitk::ColorProperty::Pointer p;
             node->GetProperty(p, "material.specularColor", renderer);
             if(p.IsNotNull())
             {
                 mitk::Color c = p->GetColor();
                 specular[0]=c.GetRed(); specular[1]=c.GetGreen(); specular[2]=c.GetBlue();
             }
         }
 
         // Ambient coeff
         {
             node->GetFloatProperty("material.ambientCoefficient", coeff_ambient, renderer);
         }
 
         // Diffuse coeff
         {
             node->GetFloatProperty("material.diffuseCoefficient", coeff_diffuse, renderer);
         }
 
         // Specular coeff
         {
             node->GetFloatProperty("material.specularCoefficient", coeff_specular, renderer);
         }
 
         // Specular power
         {
             node->GetFloatProperty("material.specularPower", power_specular, renderer);
         }
 
         property->SetAmbient( coeff_ambient );
         property->SetDiffuse( coeff_diffuse );
         property->SetSpecular( coeff_specular );
         property->SetSpecularPower( power_specular );
 
         property->SetAmbientColor( ambient );
         property->SetDiffuseColor( diffuse );
         property->SetSpecularColor( specular );
     }
 
     // Render mode
     {
         // Opacity
         {
             float opacity = 1.0f;
             if( node->GetOpacity(opacity,renderer) )
                 property->SetOpacity( opacity );
         }
 
         // Wireframe line width
         {
             float lineWidth = 1;
             node->GetFloatProperty("material.wireframeLineWidth", lineWidth, renderer);
             property->SetLineWidth( lineWidth );
         }
 
         // Representation
         {
             mitk::VtkRepresentationProperty::Pointer p;
             node->GetProperty(p, "material.representation", renderer);
             if(p.IsNotNull())
                 property->SetRepresentation( p->GetVtkRepresentation() );
         }
 
         // Interpolation
         {
             mitk::VtkInterpolationProperty::Pointer p;
             node->GetProperty(p, "material.interpolation", renderer);
             if(p.IsNotNull())
                 property->SetInterpolation( p->GetVtkInterpolation() );
         }
     }
 }
 
 
 
 void mitk::SurfaceVtkMapper3D::ApplyAllProperties( mitk::BaseRenderer* renderer, vtkActor* /*actor*/)
 {
     LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
     // Applying shading properties
     Superclass::ApplyColorAndOpacityProperties( renderer, ls->m_Actor ) ;
     // VTK Properties
     ApplyMitkPropertiesToVtkProperty( this->GetDataNode(), ls->m_Actor->GetProperty(), renderer );
     // Shaders
     CoreServicePointer<IShaderRepository> shaderRepo(CoreServices::GetShaderRepository());
     shaderRepo->ApplyProperties(this->GetDataNode(),ls->m_Actor,renderer,ls->m_ShaderTimestampUpdate);
 
     mitk::LookupTableProperty::Pointer lookupTableProp;
     this->GetDataNode()->GetProperty(lookupTableProp, "LookupTable", renderer);
     if (lookupTableProp.IsNotNull() )
     {
         ls->m_VtkPolyDataMapper->SetLookupTable(lookupTableProp->GetLookupTable()->GetVtkLookupTable());
     }
 
     mitk::LevelWindow levelWindow;
     if(this->GetDataNode()->GetLevelWindow(levelWindow, renderer, "levelWindow"))
     {
         ls->m_VtkPolyDataMapper->SetScalarRange(levelWindow.GetLowerWindowBound(),levelWindow.GetUpperWindowBound());
     }
     else
         if(this->GetDataNode()->GetLevelWindow(levelWindow, renderer))
         {
             ls->m_VtkPolyDataMapper->SetScalarRange(levelWindow.GetLowerWindowBound(),levelWindow.GetUpperWindowBound());
         }
 
     bool scalarVisibility = false;
     this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility);
     ls->m_VtkPolyDataMapper->SetScalarVisibility( (scalarVisibility ? 1 : 0) );
 
     if(scalarVisibility)
     {
         mitk::VtkScalarModeProperty* scalarMode;
         if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer))
         {
             ls->m_VtkPolyDataMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
         }
         else
             ls->m_VtkPolyDataMapper->SetScalarModeToDefault();
 
         bool colorMode = false;
         this->GetDataNode()->GetBoolProperty("color mode", colorMode);
         ls->m_VtkPolyDataMapper->SetColorMode( (colorMode ? 1 : 0) );
 
         float scalarsMin = 0;
         if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL)
             scalarsMin = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue();
 
         float scalarsMax = 1.0;
         if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL)
             scalarsMax = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue();
 
         ls->m_VtkPolyDataMapper->SetScalarRange(scalarsMin,scalarsMax);
     }
 
     mitk::SmartPointerProperty::Pointer imagetextureProp;
     imagetextureProp = dynamic_cast< mitk::SmartPointerProperty * >(
                 GetDataNode()->GetProperty("Surface.Texture", renderer));
     if(imagetextureProp.IsNotNull())
     {
         mitk::Image* miktTexture = dynamic_cast< mitk::Image* >( imagetextureProp->GetSmartPointer().GetPointer() );
         vtkSmartPointer<vtkTexture> vtkTxture = vtkSmartPointer<vtkTexture>::New();
         //Either select the first slice of a volume
         if(miktTexture->GetDimension(2) > 1)
         {
             MITK_WARN << "3D Textures are not supported by VTK and MITK. The first slice of the volume will be used instead!";
             mitk::ImageSliceSelector::Pointer sliceselector = mitk::ImageSliceSelector::New();
             sliceselector->SetSliceNr(0);
             sliceselector->SetChannelNr(0);
             sliceselector->SetTimeNr(0);
             sliceselector->SetInput(miktTexture);
             sliceselector->Update();
             vtkTxture->SetInputData(sliceselector->GetOutput()->GetVtkImageData());
         }
         else //or just use the 2D image
         {
             vtkTxture->SetInputData(miktTexture->GetVtkImageData());
         }
         vtkTxture->Update();
         //pass the texture to the actor
         ls->m_Actor->SetTexture(vtkTxture);
         if(ls->m_VtkPolyDataMapper->GetInput()->GetPointData()->GetTCoords() == NULL)
         {
             MITK_ERROR << "Surface.Texture property was set, but there are no texture coordinates. Please provide texture coordinates for the vtkPolyData via vtkPolyData->GetPointData()->SetTCoords().";
         }
     }
 
     // deprecated settings
     bool deprecatedUseCellData = false;
     this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", deprecatedUseCellData);
 
     bool deprecatedUsePointData = false;
     this->GetDataNode()->GetBoolProperty("deprecated usePointDataForColouring", deprecatedUsePointData);
 
     if (deprecatedUseCellData)
     {
         ls->m_VtkPolyDataMapper->SetColorModeToDefault();
         ls->m_VtkPolyDataMapper->SetScalarRange(0,255);
         ls->m_VtkPolyDataMapper->ScalarVisibilityOn();
         ls->m_VtkPolyDataMapper->SetScalarModeToUseCellData();
         ls->m_Actor->GetProperty()->SetSpecular (1);
         ls->m_Actor->GetProperty()->SetSpecularPower (50);
         ls->m_Actor->GetProperty()->SetInterpolationToPhong();
     }
     else if (deprecatedUsePointData)
     {
         float scalarsMin = 0;
         if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL)
             scalarsMin = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue();
 
         float scalarsMax = 0.1;
         if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL)
             scalarsMax = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue();
 
         ls->m_VtkPolyDataMapper->SetScalarRange(scalarsMin,scalarsMax);
         ls->m_VtkPolyDataMapper->SetColorModeToMapScalars();
         ls->m_VtkPolyDataMapper->ScalarVisibilityOn();
         ls->m_Actor->GetProperty()->SetSpecular (1);
         ls->m_Actor->GetProperty()->SetSpecularPower (50);
         ls->m_Actor->GetProperty()->SetInterpolationToPhong();
     }
 
     int deprecatedScalarMode = VTK_COLOR_MODE_DEFAULT;
     if(this->GetDataNode()->GetIntProperty("deprecated scalar mode", deprecatedScalarMode, renderer))
     {
         ls->m_VtkPolyDataMapper->SetScalarMode(deprecatedScalarMode);
         ls->m_VtkPolyDataMapper->ScalarVisibilityOn();
         ls->m_Actor->GetProperty()->SetSpecular (1);
         ls->m_Actor->GetProperty()->SetSpecularPower (50);
         //m_Actor->GetProperty()->SetInterpolationToPhong();
     }
 
 
     // Check whether one or more ClippingProperty objects have been defined for
     // this node. Check both renderer specific and global property lists, since
     // properties in both should be considered.
     const PropertyList::PropertyMap *rendererProperties = this->GetDataNode()->GetPropertyList( renderer )->GetMap();
     const PropertyList::PropertyMap *globalProperties = this->GetDataNode()->GetPropertyList( NULL )->GetMap();
 
     // Add clipping planes (if any)
     ls->m_ClippingPlaneCollection->RemoveAllItems();
 
     PropertyList::PropertyMap::const_iterator it;
     for ( it = rendererProperties->begin(); it != rendererProperties->end(); ++it )
     {
         this->CheckForClippingProperty( renderer,(*it).second.GetPointer() );
     }
 
     for ( it = globalProperties->begin(); it != globalProperties->end(); ++it )
     {
         this->CheckForClippingProperty( renderer,(*it).second.GetPointer() );
     }
 
     if ( ls->m_ClippingPlaneCollection->GetNumberOfItems() > 0 )
     {
         ls->m_VtkPolyDataMapper->SetClippingPlanes( ls->m_ClippingPlaneCollection );
     }
     else
     {
         ls->m_VtkPolyDataMapper->RemoveAllClippingPlanes();
     }
 
 
 }
 
 vtkProp *mitk::SurfaceVtkMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
     LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
     return ls->m_Actor;
 }
 
 void mitk::SurfaceVtkMapper3D::CheckForClippingProperty( mitk::BaseRenderer* renderer, mitk::BaseProperty *property )
 {
     LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
     //  m_Prop3D = ls->m_Actor;
 
     ClippingProperty *clippingProperty = dynamic_cast< ClippingProperty * >( property );
 
     if ( (clippingProperty != NULL)
          && (clippingProperty->GetClippingEnabled()) )
     {
         const Point3D &origin = clippingProperty->GetOrigin();
         const Vector3D &normal = clippingProperty->GetNormal();
 
         vtkPlane *clippingPlane = vtkPlane::New();
         clippingPlane->SetOrigin( origin[0], origin[1], origin[2] );
         clippingPlane->SetNormal( normal[0], normal[1], normal[2] );
 
         ls->m_ClippingPlaneCollection->AddItem( clippingPlane );
 
         clippingPlane->UnRegister( NULL );
     }
 }
 
 
 void mitk::SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
     // Shading
     {
         node->AddProperty( "material.wireframeLineWidth", mitk::FloatProperty::New(1.0f)          , renderer, overwrite );
 
         node->AddProperty( "material.ambientCoefficient" , mitk::FloatProperty::New(0.05f)          , renderer, overwrite );
         node->AddProperty( "material.diffuseCoefficient" , mitk::FloatProperty::New(0.9f)          , renderer, overwrite );
         node->AddProperty( "material.specularCoefficient", mitk::FloatProperty::New(1.0f)          , renderer, overwrite );
         node->AddProperty( "material.specularPower"      , mitk::FloatProperty::New(16.0f)          , renderer, overwrite );
 
         //node->AddProperty( "material.ambientColor"       , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
         //node->AddProperty( "material.diffuseColor"       , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
         //node->AddProperty( "material.specularColor"      , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
 
         node->AddProperty( "material.representation"      , mitk::VtkRepresentationProperty::New()  , renderer, overwrite );
         node->AddProperty( "material.interpolation"       , mitk::VtkInterpolationProperty::New()   , renderer, overwrite );
     }
 
     // Shaders
     CoreServicePointer<IShaderRepository> shaderRepo(CoreServices::GetShaderRepository());
     shaderRepo->AddDefaultProperties(node,renderer,overwrite);
 }
 
 
 void mitk::SurfaceVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
     node->AddProperty( "color", mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
     node->AddProperty( "opacity", mitk::FloatProperty::New(1.0), renderer, overwrite );
 
     mitk::SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(node,renderer,overwrite); // Shading
 
     node->AddProperty( "scalar visibility", mitk::BoolProperty::New(false), renderer, overwrite );
     node->AddProperty( "color mode", mitk::BoolProperty::New(false), renderer, overwrite );
     node->AddProperty( "scalar mode", mitk::VtkScalarModeProperty::New(), renderer, overwrite );
     mitk::Surface::Pointer surface = dynamic_cast<Surface*>(node->GetData());
     if(surface.IsNotNull())
     {
         if((surface->GetVtkPolyData() != 0) && (surface->GetVtkPolyData()->GetPointData() != NULL) && (surface->GetVtkPolyData()->GetPointData()->GetScalars() != 0))
         {
             node->AddProperty( "scalar visibility", mitk::BoolProperty::New(true), renderer, overwrite );
             node->AddProperty( "color mode", mitk::BoolProperty::New(true), renderer, overwrite );
         }
     }
 
     // Backface culling
     node->AddProperty( "Backface Culling", mitk::BoolProperty::New(false), renderer, overwrite );
 
     Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 
 void mitk::SurfaceVtkMapper3D::SetImmediateModeRenderingOn(int  /*on*/)
 {
     /*
   if (m_VtkPolyDataMapper != NULL)
     m_VtkPolyDataMapper->SetImmediateModeRendering(on);
 */
 }
diff --git a/Modules/Shaders/files.cmake b/Modules/Shaders/files.cmake
index 15f3711584..4ea681704e 100644
--- a/Modules/Shaders/files.cmake
+++ b/Modules/Shaders/files.cmake
@@ -1,23 +1,24 @@
 SET(CPP_FILES
   vtkXMLMaterial.cxx
   vtkXMLMaterialParser.cxx
   vtkXMLMaterialReader.cxx
   vtkXMLShader.cxx
   mitkShaderRepository.cpp
   mitkShaderProperty.cpp
   vtkPropertyXMLParser.cxx
+  mitkShadersActivator.cpp
 )
 
 SET(H_FILES
   vtkXMLMaterial.h
   vtkXMLMaterialParser.h
   vtkXMLMaterialReader.h
   vtkXMLShader.h
   mitkShaderRepository.h
   mitkShaderProperty.h
   vtkPropertyXMLParser.h
 )
 
 set(RESOURCE_FILES
   Shaders/mitkShaderLighting.xml
 )
diff --git a/Modules/Shaders/mitkShaderRepository.cpp b/Modules/Shaders/mitkShaderRepository.cpp
index ae7ac6eb33..894119f8e6 100644
--- a/Modules/Shaders/mitkShaderRepository.cpp
+++ b/Modules/Shaders/mitkShaderRepository.cpp
@@ -1,456 +1,456 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #define SR_INFO MITK_INFO("shader.repository")
 #define SR_WARN MITK_WARN("shader.repository")
 #define SR_ERROR MITK_ERROR("shader.repository")
 
 #include "mitkShaderRepository.h"
 #include "mitkShaderProperty.h"
 #include "mitkProperties.h"
 #include "mitkDataNode.h"
 
 #include <vtkActor.h>
 #include <vtkProperty.h>
 #include <vtkPropertyXMLParser.h>
 #include <vtkXMLMaterial.h>
 #include <vtkXMLShader.h>
 #include <vtkXMLDataElement.h>
 #include <vtkXMLMaterialParser.h>
 
 #include <itkDirectory.h>
 #include <itksys/SystemTools.hxx>
 
 int mitk::ShaderRepository::shaderId = 0;
 const bool mitk::ShaderRepository::debug = false;
 
 mitk::ShaderRepository::ShaderRepository()
 {
   LoadShaders();
 }
 
 mitk::ShaderRepository::~ShaderRepository()
 {
 }
 
 void mitk::ShaderRepository::LoadShaders()
 {
   itk::Directory::Pointer dir = itk::Directory::New();
 
   std::string dirPath = "./vtk_shader";
 
   if( dir->Load( dirPath.c_str() ) )
   {
     int n = dir->GetNumberOfFiles();
     for(int r=0;r<n;r++)
     {
       const char *filename = dir->GetFile( r );
 
       std::string extension = itksys::SystemTools::GetFilenameExtension(filename);
 
       if(extension.compare(".xml")==0)
       {
         Shader::Pointer element=Shader::New();
 
         element->SetName(itksys::SystemTools::GetFilenameWithoutExtension(filename));
         std::string filePath = dirPath + std::string("/") + element->GetName() + std::string(".xml");
 
         SR_INFO(debug) << "found shader '" << element->GetName() << "'";
 
         std::ifstream fileStream(filePath.c_str());
         element->LoadProperties(fileStream);
 
         shaders.push_back(element);
       }
     }
   }
 }
 
 mitk::ShaderRepository::Shader::Pointer mitk::ShaderRepository::GetShaderImpl(const std::string &name) const
 {
   std::list<Shader::Pointer>::const_iterator i = shaders.begin();
 
   while( i != shaders.end() )
   {
     if( (*i)->GetName() == name)
       return (*i);
 
     i++;
   }
 
   return Shader::Pointer();
 }
 
 int mitk::ShaderRepository::LoadShader(std::istream& stream, const std::string& filename)
 {
   Shader::Pointer element=Shader::New();
   element->SetName(filename);
   element->SetId(shaderId++);
   element->LoadProperties(stream);
   shaders.push_back(element);
   SR_INFO(debug) << "found shader '" << element->GetName() << "'";
   return element->GetId();
 }
 
 bool mitk::ShaderRepository::UnloadShader(int id)
 {
   for (std::list<Shader::Pointer>::iterator i = shaders.begin();
        i != shaders.end(); ++i)
   {
     if ((*i)->GetId() == id)
     {
       shaders.erase(i);
       return true;
     }
   }
   return false;
 }
 
 mitk::ShaderRepository::Shader::Shader()
 {
 }
 
 mitk::ShaderRepository::Shader::~Shader()
 {
 }
 
-void mitk::ShaderRepository::Shader::LoadProperties(vtkProperty* p)
+void mitk::ShaderRepository::Shader::LoadProperties(vtkPropertyXMLParser* p)
 {
-//  vtkXMLMaterial *m=p->GetMaterial();
-//  if (m == NULL) return;
+  vtkXMLMaterial *m=p->GetMaterial();
+  if (m == NULL) return;
 
   // Vertexshader uniforms
-//  {
-//    vtkXMLShader *s=m->GetVertexShader();
-//    if (s)
-//    {
-//      vtkXMLDataElement *x=s->GetRootElement();
-//      int n=x->GetNumberOfNestedElements();
-//      for(int r=0;r<n;r++)
-//      {
-//        vtkXMLDataElement *y=x->GetNestedElement(r);
-//        if(!strcmp(y->GetName(),"ApplicationUniform"))
-//        {
-//          Uniform::Pointer element=Uniform::New();
-//          element->LoadFromXML(y);
-//          uniforms.push_back(element);
-//        }
-//      }
-//    }
-//  }
+  {
+    vtkXMLShader *s=m->GetVertexShader();
+    if (s)
+    {
+      vtkXMLDataElement *x=s->GetRootElement();
+      int n=x->GetNumberOfNestedElements();
+      for(int r=0;r<n;r++)
+      {
+        vtkXMLDataElement *y=x->GetNestedElement(r);
+        if(!strcmp(y->GetName(),"ApplicationUniform"))
+        {
+          Uniform::Pointer element=Uniform::New();
+          element->LoadFromXML(y);
+          uniforms.push_back(element);
+        }
+      }
+    }
+  }
 
   // Fragmentshader uniforms
-//  {
-//    vtkXMLShader *s=m->GetFragmentShader();
-//    if (s)
-//    {
-//      vtkXMLDataElement *x=s->GetRootElement();
-//      int n=x->GetNumberOfNestedElements();
-//      for(int r=0;r<n;r++)
-//      {
-//        vtkXMLDataElement *y=x->GetNestedElement(r);
-//        if(!strcmp(y->GetName(),"ApplicationUniform"))
-//        {
-//          Uniform::Pointer element=Uniform::New();
-//          element->LoadFromXML(y);
-//          uniforms.push_back(element);
-//        }
-//      }
-//    }
-//  }
+  {
+    vtkXMLShader *s=m->GetFragmentShader();
+    if (s)
+    {
+      vtkXMLDataElement *x=s->GetRootElement();
+      int n=x->GetNumberOfNestedElements();
+      for(int r=0;r<n;r++)
+      {
+        vtkXMLDataElement *y=x->GetNestedElement(r);
+        if(!strcmp(y->GetName(),"ApplicationUniform"))
+        {
+          Uniform::Pointer element=Uniform::New();
+          element->LoadFromXML(y);
+          uniforms.push_back(element);
+        }
+      }
+    }
+  }
 }
 
 void mitk::ShaderRepository::Shader::LoadProperties(std::istream& stream)
 {
   std::string content;
   content.reserve(2048);
   char buffer[2048];
   while (stream.read(buffer, sizeof(buffer)))
   {
     content.append(buffer, sizeof(buffer));
   }
   content.append(buffer, static_cast<std::size_t>(stream.gcount()));
 
   if (content.empty()) return;
 
   this->SetMaterialXml(content);
 
-  vtkProperty *p = vtkProperty::New();
-//  p->LoadMaterialFromString(content.c_str());
+  vtkPropertyXMLParser *p = vtkPropertyXMLParser::New();
+  p->LoadMaterialFromString(content.c_str());
   LoadProperties(p);
   p->Delete();
 }
 
 mitk::ShaderRepository::Shader::Uniform::Uniform()
 {
 }
 
 mitk::ShaderRepository::Shader::Uniform::~Uniform()
 {
 }
 
 void mitk::ShaderRepository::Shader::Uniform::LoadFromXML(vtkXMLDataElement *y)
 {
   //MITK_INFO << "found uniform '" << y->GetAttribute("name") << "' type=" << y->GetAttribute("type");// << " default=" << y->GetAttribute("value");
 
   name = y->GetAttribute("name");
 
   const char *sType=y->GetAttribute("type");
 
   if(!strcmp(sType,"float"))
     type=glsl_float;
   else if(!strcmp(sType,"vec2"))
     type=glsl_vec2;
   else if(!strcmp(sType,"vec3"))
     type=glsl_vec3;
   else if(!strcmp(sType,"vec4"))
     type=glsl_vec4;
   else if(!strcmp(sType,"int"))
     type=glsl_int;
   else if(!strcmp(sType,"ivec2"))
     type=glsl_ivec2;
   else if(!strcmp(sType,"ivec3"))
     type=glsl_ivec3;
   else if(!strcmp(sType,"ivec4"))
     type=glsl_ivec4;
   else
   {
     type=glsl_none;
     SR_WARN << "unknown type for uniform '" << name << "'" ;
   }
 
 
   defaultFloat[0]=defaultFloat[1]=defaultFloat[2]=defaultFloat[3]=0;
 
   /*
   const char *sDefault=y->GetAttribute("value");
 
   switch(type)
   {
     case glsl_float:
       sscanf(sDefault,"%f",&defaultFloat[0]);
       break;
 
     case glsl_vec2:
       sscanf(sDefault,"%f %f",&defaultFloat[0],&defaultFloat[1]);
       break;
 
     case glsl_vec3:
       sscanf(sDefault,"%f %f %f",&defaultFloat[0],&defaultFloat[1],&defaultFloat[2]);
       break;
 
     case glsl_vec4:
       sscanf(sDefault,"%f %f %f %f",&defaultFloat[0],&defaultFloat[1],&defaultFloat[2],&defaultFloat[3]);
       break;
   }
   */
 }
 
 void mitk::ShaderRepository::AddDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) const
 {
   node->AddProperty( "shader", mitk::ShaderProperty::New(), renderer, overwrite );
 
   std::list<Shader::Pointer>::const_iterator i = shaders.begin();
 
   while( i != shaders.end() )
   {
     std::list<Shader::Uniform::Pointer> *l = (*i)->GetUniforms();
 
     std::string shaderName = (*i)->GetName();
 
     std::list<Shader::Uniform::Pointer>::const_iterator j = l->begin();
 
     while( j != l->end() )
     {
       std::string propertyName = "shader." + shaderName + "." + (*j)->name;
 
       switch( (*j)->type )
       {
         case Shader::Uniform::glsl_float:
           node->AddProperty( propertyName.c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[0] ), renderer, overwrite );
           break;
 
         case Shader::Uniform::glsl_vec2:
           node->AddProperty( (propertyName+".x").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[0] ), renderer, overwrite );
           node->AddProperty( (propertyName+".y").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[1] ), renderer, overwrite );
           break;
 
         case Shader::Uniform::glsl_vec3:
           node->AddProperty( (propertyName+".x").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[0] ), renderer, overwrite );
           node->AddProperty( (propertyName+".y").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[1] ), renderer, overwrite );
           node->AddProperty( (propertyName+".z").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[2] ), renderer, overwrite );
           break;
 
        case Shader::Uniform::glsl_vec4:
           node->AddProperty( (propertyName+".x").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[0] ), renderer, overwrite );
           node->AddProperty( (propertyName+".y").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[1] ), renderer, overwrite );
           node->AddProperty( (propertyName+".z").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[2] ), renderer, overwrite );
           node->AddProperty( (propertyName+".w").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[3] ), renderer, overwrite );
           break;
 
        default:
           break;
 
       }
 
       j++;
 
     }
 
     i++;
   }
 
 
 }
 
 void mitk::ShaderRepository::ApplyProperties(mitk::DataNode* node, vtkActor *actor, mitk::BaseRenderer* renderer,itk::TimeStamp &MTime) const
 {
   bool setMTime = false;
 
   vtkProperty* property = actor->GetProperty();
 
   unsigned long ts = MTime.GetMTime();
 
   mitk::ShaderProperty *sep= dynamic_cast<mitk::ShaderProperty*>(node->GetProperty("shader",renderer));
 
   if(!sep)
   {
     property->ShadingOff();
     return;
   }
 
   std::string shader=sep->GetValueAsString();
 
   // Need update pipeline mode
   if(sep->GetMTime() > ts)
   {
     if(shader.compare("fixed")==0)
     {
       //MITK_INFO << "disabling shader";
       property->ShadingOff();
     }
     else
     {
       Shader::Pointer s=GetShaderImpl(shader);
       if(s.IsNotNull())
       {
         //MITK_INFO << "enabling shader";
         property->ShadingOn();
 //        property->LoadMaterialFromString(s->GetMaterialXml().c_str());
       }
     }
     setMTime = true;
   }
 
    if(shader.compare("fixed")!=0)
   {
     Shader::Pointer s=GetShaderImpl(shader);
 
     if(s.IsNull())
       return;
 
     std::list<Shader::Uniform::Pointer>::const_iterator j = s->uniforms.begin();
 
     while( j != s->uniforms.end() )
     {
       std::string propertyName = "shader." + s->GetName() + "." + (*j)->name;
 
     //  MITK_INFO << "querying property: " << propertyName;
 
     //  mitk::BaseProperty *p = node->GetProperty( propertyName.c_str(), renderer );
 
     //  if( p && p->GetMTime() > MTime.GetMTime() )
       {
         float fval[4];
 
        // MITK_INFO << "copying property " << propertyName << " ->->- " << (*j)->name << " type=" << (*j)->type ;
 
 
         switch( (*j)->type )
         {
           case Shader::Uniform::glsl_float:
             node->GetFloatProperty( propertyName.c_str(), fval[0], renderer );
             property->AddShaderVariable( (*j)->name.c_str(), 1 , fval );
             break;
 
           case Shader::Uniform::glsl_vec2:
             node->GetFloatProperty( (propertyName+".x").c_str(), fval[0], renderer );
             node->GetFloatProperty( (propertyName+".y").c_str(), fval[1], renderer );
             property->AddShaderVariable( (*j)->name.c_str(), 2 , fval );
             break;
 
           case Shader::Uniform::glsl_vec3:
             node->GetFloatProperty( (propertyName+".x").c_str(), fval[0], renderer );
             node->GetFloatProperty( (propertyName+".y").c_str(), fval[1], renderer );
             node->GetFloatProperty( (propertyName+".z").c_str(), fval[2], renderer );
 
             property->AddShaderVariable( (*j)->name.c_str(), 3 , fval );
             break;
 
          case Shader::Uniform::glsl_vec4:
             node->GetFloatProperty( (propertyName+".x").c_str(), fval[0], renderer );
             node->GetFloatProperty( (propertyName+".y").c_str(), fval[1], renderer );
             node->GetFloatProperty( (propertyName+".z").c_str(), fval[2], renderer );
             node->GetFloatProperty( (propertyName+".w").c_str(), fval[3], renderer );
             property->AddShaderVariable( (*j)->name.c_str(), 4 , fval );
             break;
 
          default:
           break;
 
         }
 
         //setMTime=true;
       }
 
       j++;
     }
   }
 
   if(setMTime)
     MTime.Modified();
 }
 
 std::list<mitk::IShaderRepository::Shader::Pointer> mitk::ShaderRepository::GetShaders() const
 {
   std::list<mitk::IShaderRepository::Shader::Pointer> result;
   for (std::list<Shader::Pointer>::const_iterator i = shaders.begin();
        i != shaders.end(); ++i)
   {
     result.push_back(i->GetPointer());
   }
   return result;
 }
 
 mitk::IShaderRepository::Shader::Pointer mitk::ShaderRepository::GetShader(const std::string& name) const
 {
   for (std::list<Shader::Pointer>::const_iterator i = shaders.begin();
        i != shaders.end(); ++i)
   {
     if ((*i)->GetName() == name) return i->GetPointer();
   }
   return IShaderRepository::Shader::Pointer();
 }
 
 mitk::IShaderRepository::Shader::Pointer mitk::ShaderRepository::GetShader(int id) const
 {
   for (std::list<Shader::Pointer>::const_iterator i = shaders.begin();
        i != shaders.end(); ++i)
   {
     if ((*i)->GetId() == id) return i->GetPointer();
   }
   return IShaderRepository::Shader::Pointer();
 }
diff --git a/Modules/Shaders/mitkShaderRepository.h b/Modules/Shaders/mitkShaderRepository.h
index 692e0f0c09..7655a2768c 100644
--- a/Modules/Shaders/mitkShaderRepository.h
+++ b/Modules/Shaders/mitkShaderRepository.h
@@ -1,163 +1,165 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef _MITKSHADERREPOSITORY_H_
 #define _MITKSHADERREPOSITORY_H_
 
 #include "mitkIShaderRepository.h"
 
+
 class vtkXMLDataElement;
 class vtkXMLMaterial;
 class vtkProperty;
+class vtkPropertyXMLParser;
 
 namespace mitk {
 
 /**
  * \brief Management class for vtkShader XML descriptions.
  *
  * Looks for all XML shader files in a given directory and adds default properties
  * for each shader object (shader uniforms) to the specified mitk::DataNode.
  *
  * Additionally, it provides a utility function for applying properties for shaders
  * in mappers.
  */
 class ShaderRepository : public IShaderRepository
 {
 
 protected:
 
   class Shader : public IShaderRepository::Shader
   {
     public:
 
     mitkClassMacro( Shader, itk::Object )
     itkFactorylessNewMacro( Self )
 
     class Uniform : public itk::Object
     {
       public:
 
       mitkClassMacro( Uniform, itk::Object )
       itkFactorylessNewMacro( Self )
 
       enum Type
       {
         glsl_none,
         glsl_float,
         glsl_vec2,
         glsl_vec3,
         glsl_vec4,
         glsl_int,
         glsl_ivec2,
         glsl_ivec3,
         glsl_ivec4
       };
 
       /**
        * Constructor
        */
       Uniform();
 
       /**
        * Destructor
        */
       ~Uniform();
 
       Type type;
       std::string name;
 
       int defaultInt[4];
       float defaultFloat[4];
 
       void LoadFromXML(vtkXMLDataElement *e);
     };
 
     std::list<Uniform::Pointer> uniforms;
 
     /**
      * Constructor
      */
     Shader();
 
     /**
      * Destructor
      */
     ~Shader();
 
     Uniform *GetUniform(char * /*id*/) { return 0; }
 
     std::list<Uniform::Pointer> *GetUniforms()
     {
       return &uniforms;
     }
 
   private:
 
     friend class ShaderRepository;
 
-    void LoadProperties(vtkProperty* prop);
+    void LoadProperties(vtkPropertyXMLParser* prop);
     void LoadProperties(std::istream& stream);
 
   };
 
   void LoadShaders();
 
   Shader::Pointer GetShaderImpl(const std::string& name) const;
 
 private:
 
   std::list<Shader::Pointer> shaders;
 
   static int shaderId;
   static const bool debug;
 
   public:
 
   /**
    * Constructor
    */
   ShaderRepository();
 
   /**
    * Destructor
    */
   ~ShaderRepository();
 
   std::list<IShaderRepository::Shader::Pointer> GetShaders() const;
 
   IShaderRepository::Shader::Pointer GetShader(const std::string& name) const;
 
   IShaderRepository::Shader::Pointer GetShader(int id) const;
 
   /** \brief Adds all parsed shader uniforms to property list of the given DataNode;
    * used by mappers.
    */
   void AddDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) const;
 
   /** \brief Applies shader and shader specific variables of the specified DataNode
    * to the VTK object by updating the shader variables of its vtkProperty.
    */
   void ApplyProperties(mitk::DataNode* node, vtkActor *actor, mitk::BaseRenderer* renderer,itk::TimeStamp &MTime) const;
 
   int LoadShader(std::istream& stream, const std::string& name);
 
   bool UnloadShader(int id);
 
 
 };
 
 } //end of namespace mitk
 #endif
diff --git a/Modules/Shaders/mitkShadersActivator.cpp b/Modules/Shaders/mitkShadersActivator.cpp
new file mode 100644
index 0000000000..c70072774a
--- /dev/null
+++ b/Modules/Shaders/mitkShadersActivator.cpp
@@ -0,0 +1,101 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include <mitkShaderRepository.h>
+#include <usModuleActivator.h>
+#include <usModuleContext.h>
+#include <usModuleEvent.h>
+#include <usModule.h>
+#include <usModuleResource.h>
+#include <usModuleResourceStream.h>
+#include <memory>
+
+namespace mitk
+{
+  class ShadersActivator : public us::ModuleActivator
+  {
+  public:
+    ShadersActivator()
+    {
+    }
+
+    ~ShadersActivator()
+    {
+    }
+
+    void Load(us::ModuleContext* context)
+    {
+      m_ShaderRepository.reset(new ShaderRepository);
+      context->RegisterService<IShaderRepository>(m_ShaderRepository.get());
+      context->AddModuleListener(this, &ShadersActivator::HandleModuleEvent);
+    }
+
+    void Unload(us::ModuleContext*)
+    {
+      m_ShaderRepository.reset(NULL);
+    }
+
+  private:
+    ShadersActivator(const ShadersActivator&);
+    ShadersActivator& operator=(const ShadersActivator&);
+
+    void HandleModuleEvent(const us::ModuleEvent moduleEvent);
+    std::map<long, std::vector<int> > moduleIdToShaderIds;
+
+    std::auto_ptr<ShaderRepository> m_ShaderRepository;
+  };
+
+  void ShadersActivator::HandleModuleEvent(const us::ModuleEvent moduleEvent)
+  {
+    if (moduleEvent.GetType() == us::ModuleEvent::LOADED)
+    {
+      // search and load shader files
+      std::vector<us::ModuleResource> shaderResoruces =
+          moduleEvent.GetModule()->FindResources("Shaders", "*.xml", true);
+      for (std::vector<us::ModuleResource>::iterator i = shaderResoruces.begin();
+           i != shaderResoruces.end(); ++i)
+      {
+        if (*i)
+        {
+          us::ModuleResourceStream rs(*i);
+          int id = m_ShaderRepository->LoadShader(rs, i->GetBaseName());
+          if (id >= 0)
+          {
+            moduleIdToShaderIds[moduleEvent.GetModule()->GetModuleId()].push_back(id);
+          }
+        }
+      }
+    }
+    else if (moduleEvent.GetType() == us::ModuleEvent::UNLOADED)
+    {
+      std::map<long, std::vector<int> >::iterator shaderIdsIter =
+          moduleIdToShaderIds.find(moduleEvent.GetModule()->GetModuleId());
+      if (shaderIdsIter != moduleIdToShaderIds.end())
+      {
+        for (std::vector<int>::iterator idIter = shaderIdsIter->second.begin();
+             idIter != shaderIdsIter->second.end(); ++idIter)
+        {
+          m_ShaderRepository->UnloadShader(*idIter);
+        }
+        moduleIdToShaderIds.erase(shaderIdsIter);
+      }
+    }
+
+
+  }
+}
+
+US_EXPORT_MODULE_ACTIVATOR(Shaders, mitk::ShadersActivator);