diff --git a/CoreUI/Qmitk/QmitkLineEditLevelWindowWidget.cpp b/CoreUI/Qmitk/QmitkLineEditLevelWindowWidget.cpp
index 2f5e3f6629..426f8acc15 100644
--- a/CoreUI/Qmitk/QmitkLineEditLevelWindowWidget.cpp
+++ b/CoreUI/Qmitk/QmitkLineEditLevelWindowWidget.cpp
@@ -1,193 +1,202 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
-Date:      $Date$
-Version:   $Revision$
+Date:      $Date: 2011-01-18 13:22:38 +0100 (Di, 18 Jan 2011) $
+Version:   $Revision: 28959 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkLineEditLevelWindowWidget.h"
 #include "QmitkLevelWindowWidgetContextMenu.h"
 
 #include <mitkRenderingManager.h>
 
 #include <itkCommand.h>
 #include <QValidator>
 #include <QLayout>
 #include <QLineEdit>
+#include <limits>
 
+using namespace std;
 
 /**
 * Constructor
 */
 QmitkLineEditLevelWindowWidget::QmitkLineEditLevelWindowWidget(QWidget* parent, Qt::WindowFlags f)
  : QWidget(parent, f)
 {
   m_Manager = mitk::LevelWindowManager::New();
   
   itk::ReceptorMemberCommand<QmitkLineEditLevelWindowWidget>::Pointer command = itk::ReceptorMemberCommand<QmitkLineEditLevelWindowWidget>::New();
   command->SetCallbackFunction(this, &QmitkLineEditLevelWindowWidget::OnPropertyModified);
   m_ObserverTag = m_Manager->AddObserver(itk::ModifiedEvent(), command);
   m_IsObserverTagSet = true;
 
   m_Contextmenu = new QmitkLevelWindowWidgetContextMenu(this); // true);
   
   QVBoxLayout* layout = new QVBoxLayout( this );
   layout->setMargin(0);
   layout->setSpacing(0);
 
   m_LevelInput = new QLineEdit( this );
   m_LevelInput->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Preferred));
   //m_LevelInput->setFrameShape( QLineEdit::LineEditPanel );
   //m_LevelInput->setFrameShadow( QLineEdit::Sunken );
 
   m_WindowInput = new QLineEdit( this );
   m_WindowInput->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Preferred));
   //m_WindowInput->setFrameShape( QLineEdit::LineEditPanel );
   //m_WindowInput->setFrameShadow( QLineEdit::Sunken );
 
   layout->addWidget(m_LevelInput);
   layout->addWidget(m_WindowInput);
 
   // signals and slots connections
   connect( m_LevelInput, SIGNAL(editingFinished()), this, SLOT( SetLevelValue() ) );
   connect( m_WindowInput, SIGNAL(editingFinished()), this, SLOT( SetWindowValue() ) );
 
   // Validator for both LineEdit-widgets, to limit the valid input-range to int.
-  QValidator* validatorWindowInput = new QIntValidator(1, 20000000, this);
+  //QValidator* validatorWindowInput = new QIntValidator(1, 20000000, this);
+  QValidator* validatorWindowInput = new QDoubleValidator(0, numeric_limits<double>::max(), 2, this);
   m_WindowInput->setValidator(validatorWindowInput);
 
-  QValidator* validatorLevelInput = new QIntValidator(-10000000, 10000000, this);
-  m_LevelInput->setValidator(validatorLevelInput);
+  //QValidator* validatorLevelInput = new QIntValidator(-10000000, 10000000, this);
+  QValidator* validatorLevelInput = new QDoubleValidator(numeric_limits<double>::min(), numeric_limits<double>::max(), 2, this);
+  //m_LevelInput->setValidator(validatorLevelInput);
   
   this->hide();
 }
 
 QmitkLineEditLevelWindowWidget::~QmitkLineEditLevelWindowWidget()
 {
   if( m_IsObserverTagSet )
   {
     m_Manager->RemoveObserver(m_ObserverTag);
     m_IsObserverTagSet = false;
   }
 }
 
 void QmitkLineEditLevelWindowWidget::OnPropertyModified(const itk::EventObject& )
 {
   try
   {
     m_LevelWindow = m_Manager->GetLevelWindow();
     //setValidator();
     QString level;
     level.setNum((int)(m_LevelWindow.GetLevel()));
     m_LevelInput->setText(level);
     QString window;
     window.setNum((int)(m_LevelWindow.GetWindow()));
     m_WindowInput->setText(window);
     m_LevelInput->setEnabled(!m_LevelWindow.IsFixed());  
     m_WindowInput->setEnabled(!m_LevelWindow.IsFixed());  
     this->show();
   }
   catch(...)
   {
     try
     {
       this->hide();
     }
     catch(...)
     {
     }
   }
 }
 
 void QmitkLineEditLevelWindowWidget::setLevelWindowManager(mitk::LevelWindowManager* levelWindowManager)
 {
   if( m_IsObserverTagSet )
   {
     m_Manager->RemoveObserver(m_ObserverTag);
     m_IsObserverTagSet = false;
   }
   m_Manager = levelWindowManager;
   if ( m_Manager.IsNotNull() )
   {
     itk::ReceptorMemberCommand<QmitkLineEditLevelWindowWidget>::Pointer command = itk::ReceptorMemberCommand<QmitkLineEditLevelWindowWidget>::New();
     command->SetCallbackFunction(this, &QmitkLineEditLevelWindowWidget::OnPropertyModified);
     m_ObserverTag = m_Manager->AddObserver(itk::ModifiedEvent(), command);
     m_IsObserverTagSet = true;
   }
 }
 
 void QmitkLineEditLevelWindowWidget::SetDataStorage( mitk::DataStorage* ds )
 {
   m_Manager->SetDataStorage(ds);
 }
 
 //read the levelInput and change level and slider when the button "ENTER" was pressed in the windowInput-LineEdit
 void QmitkLineEditLevelWindowWidget::SetLevelValue()
 {
   validLevel();
 }
 
 //read the windowInput and change window and slider when the button "ENTER" was pressed in the windowInput-LineEdit
 void QmitkLineEditLevelWindowWidget::SetWindowValue()
 {
   validWindow();
 }
 
 void QmitkLineEditLevelWindowWidget::contextMenuEvent( QContextMenuEvent * )
 { 
   m_Contextmenu->setLevelWindowManager(m_Manager.GetPointer());
   m_Contextmenu->getContextMenu();
 }
 
 void QmitkLineEditLevelWindowWidget::validLevel()
 {
-  int level = m_LevelInput->text().toInt();
-  if ( level + (int)(m_LevelWindow.GetWindow()/2) > (int)(m_LevelWindow.GetRangeMax()))
+  double level =m_LevelInput->text().toDouble();
+  
+  if ( level + m_LevelWindow.GetWindow()/2 > m_LevelWindow.GetRangeMax())
   {
-    level = (int)(m_LevelWindow.GetRangeMax() - m_LevelWindow.GetWindow()/2);
+    level = m_LevelWindow.GetRangeMax() - m_LevelWindow.GetWindow()/2;
   }
-  if (level - (int)(m_LevelWindow.GetWindow()/2) < (int)(m_LevelWindow.GetRangeMin()))
+  if (level - m_LevelWindow.GetWindow()/2 < m_LevelWindow.GetRangeMin())
   {
-    level = (int)(m_LevelWindow.GetRangeMin() + m_LevelWindow.GetWindow()/2);
+    level = m_LevelWindow.GetRangeMin() + m_LevelWindow.GetWindow()/2;
   }
-  QString qLevel;
-  qLevel.setNum(level);
+  
+  std::stringstream ss;
+  ss << std::setprecision(2) << level;
+  QString qLevel(ss.str().c_str());
+
+  //qLevel.setNum(level);
   m_LevelInput->setText(qLevel);
   m_LevelWindow.SetLevelWindow(level, m_LevelWindow.GetWindow());
   m_Manager->SetLevelWindow(m_LevelWindow);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLineEditLevelWindowWidget::validWindow()
 {
-  int window = m_WindowInput->text().toInt();
-  if ( (int)(m_LevelWindow.GetLevel()) + window/2 > (int)(m_LevelWindow.GetRangeMax()))
+  double window = m_WindowInput->text().toDouble();
+  if ( m_LevelWindow.GetLevel() + window/2 > m_LevelWindow.GetRangeMax())
   {
-    window = (int)((m_LevelWindow.GetRangeMax() - m_LevelWindow.GetLevel())*2);
+    window = (m_LevelWindow.GetRangeMax() - m_LevelWindow.GetLevel())*2;
   }
-  if ((int)(m_LevelWindow.GetLevel()) - window/2 < (int)(m_LevelWindow.GetRangeMin()))
+  if (m_LevelWindow.GetLevel() - window/2 < m_LevelWindow.GetRangeMin())
   {
-    window = (int)((m_LevelWindow.GetLevel() - m_LevelWindow.GetRangeMin())*2);
+    window = (m_LevelWindow.GetLevel() - m_LevelWindow.GetRangeMin())*2;
   }
   QString qWindow;
   qWindow.setNum(window);
   m_WindowInput->setText(qWindow);
   m_LevelWindow.SetLevelWindow(m_LevelWindow.GetLevel(), window);
   m_Manager->SetLevelWindow(m_LevelWindow);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 mitk::LevelWindowManager* QmitkLineEditLevelWindowWidget::GetManager()
 {
   return m_Manager.GetPointer();
 }
diff --git a/CoreUI/Qmitk/QmitkSliderLevelWindowWidget.cpp b/CoreUI/Qmitk/QmitkSliderLevelWindowWidget.cpp
index d71bae382f..b4f2a8d3ed 100644
--- a/CoreUI/Qmitk/QmitkSliderLevelWindowWidget.cpp
+++ b/CoreUI/Qmitk/QmitkSliderLevelWindowWidget.cpp
@@ -1,525 +1,525 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include <QmitkSliderLevelWindowWidget.h>
 
 #include <QCursor>
 #include <QPainter>
 #include <QToolTip>
 #include <QMouseEvent>
 
 #include <itkCommand.h>
 #include <QmitkLevelWindowWidgetContextMenu.h>
 #include <mitkRenderingManager.h>
 
 /**
 * Constructor
 */
 QmitkSliderLevelWindowWidget::QmitkSliderLevelWindowWidget( QWidget * parent, Qt::WindowFlags f )
 : QWidget( parent, f )
 {
   m_Manager = mitk::LevelWindowManager::New();
 
   itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::Pointer command = itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::New();
   command->SetCallbackFunction(this, &QmitkSliderLevelWindowWidget::OnPropertyModified);
   m_ObserverTag = m_Manager->AddObserver(itk::ModifiedEvent(), command);
   m_IsObserverTagSet = true;
 
   setMouseTracking(true);
   m_Resize = false;
   m_Bottom = false;
   m_CtrlPressed = false;
   m_MouseDown = false;
   
   m_Font.setPointSize( 6 );
   
   m_MoveHeight = height() - 25;
   m_ScaleVisible = true;
   m_Contextmenu = new QmitkLevelWindowWidgetContextMenu(this); //, true);
 
   //setBackgroundMode( Qt::NoBackground );
   
   this->hide();
   update();
  
 }
 
 QmitkSliderLevelWindowWidget::~QmitkSliderLevelWindowWidget()
 {
   if ( m_IsObserverTagSet)
   {
     m_Manager->RemoveObserver(m_ObserverTag);
     m_IsObserverTagSet = false;
   }
 }
 
 void QmitkSliderLevelWindowWidget::setLevelWindowManager(mitk::LevelWindowManager* levelWindowManager)
 {
   if ( m_IsObserverTagSet)
   {
     m_Manager->RemoveObserver(m_ObserverTag);
    m_IsObserverTagSet = false;
   }
   m_Manager = levelWindowManager;
   if ( m_Manager.IsNotNull() )
   {
     itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::Pointer command = itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::New();
     command->SetCallbackFunction(this, &QmitkSliderLevelWindowWidget::OnPropertyModified);
     m_ObserverTag = m_Manager->AddObserver(itk::ModifiedEvent(), command);
     m_IsObserverTagSet = true;
   }
 }
 
 void QmitkSliderLevelWindowWidget::OnPropertyModified(const itk::EventObject& )
 {
   try
   {
     m_LevelWindow = m_Manager->GetLevelWindow();
     this->show();
     update();
   }
   catch(...)
   {
     try
     {
       this->hide();
     }
     catch(...)
     {
     }
   }
 }
 
 void QmitkSliderLevelWindowWidget::paintEvent( QPaintEvent* itkNotUsed(e) ) 
 {
   QPixmap pm(width(), height());
   //pm.fill( static_cast<QWidget*>(parent())->paletteBackgroundColor() );
   pm.fill(this, 0, 0);
   QPainter painter(&pm);
 
   painter.setFont( m_Font );
   //painter.setPen(static_cast<QWidget*>(parent())->paletteForegroundColor());
   painter.setPen(this->palette().color(this->foregroundRole()));
   
   QColor c(93,144,169);
   QColor cl = c.light();
   QColor cd = c.dark();
 
   painter.setBrush(c);
   painter.drawRect(m_Rect);
 
   float mr = m_LevelWindow.GetRange();
 
   if ( mr < 1 )
     mr = 1;
  
   float fact = (float) m_MoveHeight / mr;
 
   //begin draw scale
   if (m_ScaleVisible)
   {
     int minRange = (int)m_LevelWindow.GetRangeMin();
     int maxRange = (int)m_LevelWindow.GetRangeMax();
     int yValue = m_MoveHeight + (int)(minRange*fact);
     QString s = " 0";
     if (minRange <= 0 && maxRange >= 0)
     {
       painter.drawLine( 5, yValue , 15, yValue);
       painter.drawText( 21, yValue + 3, s );
     }
 
     int count = 1;
     int k = 5;
     bool enoughSpace = false;
     bool enoughSpace2 = false;
 
     for(int i = m_MoveHeight + (int)(minRange*fact); i < m_MoveHeight;)
     {
       if (-count*20 < minRange)
         break;
       yValue = m_MoveHeight + (int)((minRange + count*20)*fact);
       s = QString::number(-count*20);
       if (count % k && ((20*fact) > 2.5))
       {
         painter.drawLine( 8, yValue, 12, yValue);
         enoughSpace = true;
       }
       else if (!(count % k))
       {
         if ((k*20*fact) > 7)
         {
           painter.drawLine( 5, yValue, 15, yValue);
           painter.drawText( 21, yValue + 3, s );
           enoughSpace2 = true;
         }
         else
         {
           k += 5;
         }
       }
       if (enoughSpace)
       {
         i=yValue;
         count++;
       }
       else if (enoughSpace2)
       {
         i=yValue;
         count += k;
       }
       else
       {
         i=yValue;
         count = k;
       }
     }
     count = 1;
     k = 5;
     enoughSpace = false;
     enoughSpace2 = false;
 
     for(int i = m_MoveHeight + (int)(minRange*fact); i >= 0;)
     {
       if (count*20 > maxRange)
         break;
       yValue = m_MoveHeight + (int)((minRange - count*20)*fact);
       s = QString::number(count*20);
       if(count % k && ((20*fact) > 2.5))
       {
         if (!(minRange > 0 && (count*20) < minRange))
           painter.drawLine( 8, yValue, 12, yValue);
         enoughSpace = true;
       }
       else if (!(count % k))
       {
         if ((k*20*fact) > 7)
         {
           if (!(minRange > 0 && (count*20) < minRange))
           {
             painter.drawLine( 5, yValue, 15, yValue);
             painter.drawText( 21, yValue + 3, s );
           }
           enoughSpace2 = true;
         }
         else
         {
           k += 5;
         }
       }
       if (enoughSpace)
       {
         i=yValue;
         count++;
       }
       else if (enoughSpace2)
       {
         i=yValue;
         count += k;
       }
       else
       {
         i=yValue;
         count = k;
       }
     }
   }
   //end draw scale
   painter.setPen (cl);
   painter.drawLine(m_Rect.topLeft(),m_Rect.topRight());
   painter.drawLine(m_Rect.topLeft(),m_Rect.bottomLeft());
   
   painter.setPen (cd);
   painter.drawLine(m_Rect.topRight(),m_Rect.bottomRight());
   painter.drawLine(m_Rect.bottomRight(),m_Rect.bottomLeft());
   painter.end();
 
   QPainter p (this);
   p.drawPixmap(0, 0, pm);
 }
 
 /**
 *
 */
 void QmitkSliderLevelWindowWidget::mouseMoveEvent( QMouseEvent* mouseEvent ) 
 {
   if(!mouseEvent)
     return;
   if ( m_LevelWindow.IsFixed() )
     return;
   if (!m_MouseDown)
   {
     if ( mouseEvent->pos().y() >= 0 
       && mouseEvent->pos().y() <= (m_Rect.topLeft().y() + 3) )
     {
       setCursor(Qt::SizeVerCursor);
       m_UpperBound.setRect(m_Rect.topLeft().x(), m_Rect.topLeft().y() - 3, 17, 7);
       QToolTip::showText(mouseEvent->globalPos(), "Ctrl + left click to change only upper bound", this, m_UpperBound);
       m_Resize = true;
     }
     else if ( mouseEvent->pos().y() >= (m_Rect.bottomLeft().y() - 3) )
     {
       setCursor(Qt::SizeVerCursor);
       m_LowerBound.setRect(m_Rect.bottomLeft().x(), m_Rect.bottomLeft().y() - 3, 17, 7);
       QToolTip::showText(mouseEvent->globalPos(), "Ctrl + left click to change only lower bound", this, m_LowerBound);
       m_Resize = true;
       m_Bottom = true;
     }
     else
     {
       setCursor(Qt::ArrowCursor);
       m_Resize = false;
       m_Bottom = false;
     }
   }
 
   else {
 
     float fact = (float) m_MoveHeight / m_LevelWindow.GetRange();
 
     if ( m_Leftbutton ) 
     {
       if (m_Resize && !m_CtrlPressed)
       {
         double diff = (mouseEvent->pos().y()) / fact;
         diff -= (m_StartPos.y()) / fact;
         m_StartPos = mouseEvent->pos();
 
         if (diff == 0) return;
         float value;
         if (m_Bottom)
           value = m_LevelWindow.GetWindow() + ( ( 2 * diff ) );
         else
           value = m_LevelWindow.GetWindow() - ( ( 2 * diff ) );
 
-        if ( value < 1 )
-          value = 1;
+        if ( value < 0 )
+          value = 0;
 
         m_LevelWindow.SetLevelWindow( m_LevelWindow.GetLevel(), value );
       } 
       else if(m_Resize && m_CtrlPressed)
       {
         if (!m_Bottom)
         {
           double diff = (mouseEvent->pos().y()) / fact;
           diff -= (m_StartPos.y()) / fact;
           m_StartPos = mouseEvent->pos();
 
           if (diff == 0) return;
           float value;
           
           value = m_LevelWindow.GetWindow() - ( ( diff ) );
 
-          if ( value < 1 )
-            value = 1;
+          if ( value < 0 )
+            value = 0;
           float oldWindow;
           float oldLevel;
           float newLevel;
           oldWindow = m_LevelWindow.GetWindow();
           oldLevel = m_LevelWindow.GetLevel();
           newLevel = oldLevel + (value - oldWindow)/2;
           if (!((newLevel + value/2) > m_LevelWindow.GetRangeMax())) 
             m_LevelWindow.SetLevelWindow( newLevel, value );
         }
         else
         {
           double diff = (mouseEvent->pos().y()) / fact;
           diff -= (m_StartPos.y()) / fact;
           m_StartPos = mouseEvent->pos();
 
           if (diff == 0) return;
           float value;
           
           value = m_LevelWindow.GetWindow() + ( ( diff ) );
 
-          if ( value < 1 )
-            value = 1;
+          if ( value < 0 )
+            value = 0;
           float oldWindow;
           float oldLevel;
           float newLevel;
           oldWindow = m_LevelWindow.GetWindow();
           oldLevel = m_LevelWindow.GetLevel();
           newLevel = oldLevel - (value - oldWindow)/2;
           if (!((newLevel - value/2) < m_LevelWindow.GetRangeMin())) 
             m_LevelWindow.SetLevelWindow( newLevel, value );
         }
       }
       else
       {
         float maxv = m_LevelWindow.GetRangeMax();
         float minv = m_LevelWindow.GetRangeMin();
         float wh = m_LevelWindow.GetWindow() / 2;
   
     float level = (m_MoveHeight - mouseEvent->pos().y()) / fact + minv;
 
     double diff = (mouseEvent->pos().x()) / fact;
     diff -= (m_StartPos.x()) / fact;
     m_StartPos = mouseEvent->pos();
 
     float window;
     if (m_Bottom)
       window = m_LevelWindow.GetWindow() + ( ( 2 * diff ) );
     else
       window = m_LevelWindow.GetWindow() - ( ( 2 * diff ) );
 
-    if ( window < 1 )
-      window = 1;
+    if ( window < 0 )
+      window = 0;
 
     if ( level - wh < minv )
       m_LevelWindow.SetLevelWindow( m_LevelWindow.GetRangeMin() + wh, m_LevelWindow.GetWindow() );
 
     else if ( level + wh > maxv )
       m_LevelWindow.SetLevelWindow( m_LevelWindow.GetRangeMax() - wh, m_LevelWindow.GetWindow() );
 
     else
       m_LevelWindow.SetLevelWindow( level, window );
       }
       m_Manager->SetLevelWindow(m_LevelWindow);
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 }
 void QmitkSliderLevelWindowWidget::enterEvent ( QEvent * /*event*/  )
 {
   /*
   if(event->type() != QEvent::MouseMove)
     return;*/
 
   //mouseMoveEvent( static_cast< QMouseEvent* > ( event ) );
   QPoint p = QCursor::pos();
   p = this->mapFromGlobal(p);
   QMouseEvent ev(QEvent::MouseMove, p, Qt::NoButton, Qt::NoButton , Qt::NoModifier );
   this->mouseMoveEvent( &ev );
 }
 
 /**
 *
 */
 void QmitkSliderLevelWindowWidget::mousePressEvent( QMouseEvent* mouseEvent ) {
   if ( m_LevelWindow.IsFixed() )
     return;
   m_MouseDown = true;
   m_StartPos = mouseEvent->pos();
 
   if ( mouseEvent->button() == Qt::LeftButton )
   {
     if (mouseEvent->modifiers() == Qt::ControlModifier || mouseEvent->modifiers() == Qt::ShiftModifier)
     {
       m_CtrlPressed = true;
     }
     else
     {
       m_CtrlPressed = false;
     }
     m_Leftbutton = true;
   }
   else
     m_Leftbutton = false;
 
   mouseMoveEvent( mouseEvent );
 }
 
 /**
 *
 */
 void QmitkSliderLevelWindowWidget::resizeEvent ( QResizeEvent * event ) {
   m_MoveHeight = event->size().height() - 25;
   update();
 }
 
 /**
 *
 */
 void QmitkSliderLevelWindowWidget::mouseReleaseEvent( QMouseEvent* ) 
 {
   if ( m_LevelWindow.IsFixed() )
     return;
   m_MouseDown = false;
 }
 
 /**
 *
 */
 void QmitkSliderLevelWindowWidget::update() {
   int rectWidth;
   if(m_ScaleVisible)
   {
     rectWidth = 17;
     setMinimumSize ( QSize( 50, 50 ) );
     setMaximumSize ( QSize( 50, 2000 ) );
     setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Expanding ) );
   }
   else
   {
     rectWidth = 26;
     setMinimumSize ( QSize( 40, 50 ) );
     setMaximumSize ( QSize( 50, 2000 ) );
     setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Expanding ) );
   }
   float mr = m_LevelWindow.GetRange();
 
   if ( mr < 1 )
     mr = 1;
 
   float fact = (float) m_MoveHeight / mr;
 
   float rectHeight = m_LevelWindow.GetWindow() * fact;
 
   if ( rectHeight < 15 )
     rectHeight = 15;
 
   if ( m_LevelWindow.GetLowerWindowBound() < 0 )
     m_Rect.setRect( 2, (int) (m_MoveHeight - (m_LevelWindow.GetUpperWindowBound() - m_LevelWindow.GetRangeMin()) * fact) , rectWidth, (int) rectHeight );
   else
     m_Rect.setRect( 2, (int) (m_MoveHeight - (m_LevelWindow.GetUpperWindowBound() - m_LevelWindow.GetRangeMin()) * fact), rectWidth, (int) rectHeight );
   
   QWidget::repaint();
 }
 
 void QmitkSliderLevelWindowWidget::contextMenuEvent( QContextMenuEvent * )
 { 
   m_Contextmenu->setLevelWindowManager(m_Manager.GetPointer());
   QMenu *contextMenu = new QMenu( this );
   Q_CHECK_PTR( contextMenu );
   if (m_ScaleVisible)
     contextMenu->addAction(tr("Hide Scale"), this, SLOT(hideScale()));
   else
     contextMenu->addAction(tr("Show Scale"), this, SLOT(showScale()));
   contextMenu->addSeparator();
   m_Contextmenu->getContextMenu(contextMenu);
 }
 
 void QmitkSliderLevelWindowWidget::hideScale()
 {
   m_ScaleVisible = false;
   update();
 }
 
 void QmitkSliderLevelWindowWidget::showScale()
 {
   m_ScaleVisible = true;
   update();
 }
 
 void QmitkSliderLevelWindowWidget::setDataStorage(mitk::DataStorage* ds)
 {
   m_Manager->SetDataStorage(ds);
 }
 
 mitk::LevelWindowManager* QmitkSliderLevelWindowWidget::GetManager()
 {
   return m_Manager.GetPointer();
 }