diff --git a/Modules/QtWidgetsExt/QmitkColorTransferFunctionCanvas.cpp b/Modules/QtWidgetsExt/QmitkColorTransferFunctionCanvas.cpp
index df120bc9ff..daef0d636c 100755
--- a/Modules/QtWidgetsExt/QmitkColorTransferFunctionCanvas.cpp
+++ b/Modules/QtWidgetsExt/QmitkColorTransferFunctionCanvas.cpp
@@ -1,165 +1,169 @@
 /*===================================================================
 
 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 "QmitkColorTransferFunctionCanvas.h"
 
 #include <QPainter>
 #include <QLineEdit>
 #include <QColorDialog>
 
 QmitkColorTransferFunctionCanvas::QmitkColorTransferFunctionCanvas(
     QWidget * parent, Qt::WindowFlags f) :
   QmitkTransferFunctionCanvas(parent, f), m_ColorTransferFunction(0)
 {
   // used for drawing a border
   setContentsMargins(1,1,1,1);
 }
 
 void QmitkColorTransferFunctionCanvas::SetTitle(const QString& title)
 {
   m_Title=title;
 }
 
 
 void QmitkColorTransferFunctionCanvas::paintEvent(QPaintEvent*)
 {
   QPainter painter(this);
 
   // Render gray background
   QRect contentsRect = this->contentsRect();
   painter.setPen(Qt::gray);
   painter.drawRect(0, 0, contentsRect.width()+1, contentsRect.height()+1);
 
   if( ! this->isEnabled() )
     return;
 
   if (m_ColorTransferFunction)
   {
     for (int x = contentsRect.x(); x < contentsRect.x() + contentsRect.width(); x++)
     {
       double xVal = m_Min + ((float) x) / contentsRect.width() * (m_Max
           - m_Min);
       QColor col((int) (m_ColorTransferFunction->GetRedValue(xVal) * 255),
           (int) (m_ColorTransferFunction->GetGreenValue(xVal) * 255),
           (int) (m_ColorTransferFunction->GetBlueValue(xVal) * 255));
       painter.setPen(col);
       painter.drawLine(x, 1, x, contentsRect.height());
     }
   }
 
  //paint title
   if (m_Title.size()>0)
   {
     painter.setPen(Qt::black);
     painter.drawText(QPoint(11,21),m_Title);
     painter.setPen(Qt::white);
     painter.drawText(QPoint(10,20),m_Title);
   }
 
   //paint min and max
   QString qs_min = QString::number( m_Min );
   QString qs_max = QString::number( m_Max );
 
   QRect qr_min = painter.fontMetrics().boundingRect( qs_min );
   QRect qr_max = painter.fontMetrics().boundingRect( qs_max );
 
   int y,x;
 
   y=this->contentsRect().height()-qr_min.height()+5;
   x=10;
 
   painter.setPen(Qt::black);
   painter.drawText(QPoint(x+1,y+1),qs_min);
   painter.setPen(Qt::white);
   painter.drawText(QPoint(x  ,y  ),qs_min);
 
   y=this->contentsRect().height()-qr_max.height()+5;
   x=this->contentsRect().width()-qr_max.width()-6;
 
   painter.setPen(Qt::black);
   painter.drawText(QPoint(x,y+1),qs_max);
   painter.setPen(Qt::white);
   painter.drawText(QPoint(x,y  ),qs_max);
 
   if (m_ColorTransferFunction)
   {
     // now paint the handles
     painter.setBrush(Qt::black);
     painter.setPen(Qt::black);
     for (int i = 0; i < this->GetFunctionSize(); i++)
     {
       int handleHeight = (i == m_GrabbedHandle) ? (int) (contentsRect.height() / 1.5)
           : contentsRect.height() / 2;
       int handleWidth = (i == m_GrabbedHandle) ? 6 : 4;
       std::pair<int,int> point = this->FunctionToCanvas(std::make_pair(
           GetFunctionX(i), 0.0f));
       int y = height() / 2;
       painter.drawRoundRect(point.first - handleWidth / 2,
           y - handleHeight / 2, handleWidth, handleHeight, 50, 50);
 
       if (i == m_GrabbedHandle && m_LineEditAvailable)
+      {
+        int xCursor = m_XEdit->cursorPosition();
         m_XEdit->setText(QString::number(GetFunctionX(m_GrabbedHandle)));
+        m_XEdit->setCursorPosition( xCursor );
+      }
     }
   }
 }
 
 int QmitkColorTransferFunctionCanvas::GetNearHandle(int x, int,
     unsigned int maxSquaredDistance)
 {
   for (int i = 0; i < this->GetFunctionSize(); i++)
   {
     std::pair<int,int> point = this->FunctionToCanvas(std::make_pair(
         GetFunctionX(i), (double) 0.0));
     if ((unsigned int) ((point.first - x) * (point.first - x))
         < maxSquaredDistance)
     {
       return i;
     }
   }
   return -1;
 }
 
 void QmitkColorTransferFunctionCanvas::DoubleClickOnHandle(int handle)
 {
   double xVal = GetFunctionX(handle);
   QColor col((int) (m_ColorTransferFunction->GetRedValue(xVal) * 255),
       (int) (m_ColorTransferFunction->GetGreenValue(xVal) * 255),
       (int) (m_ColorTransferFunction->GetBlueValue(xVal) * 255));
   QColor result = QColorDialog::getColor(col);
   if (result.isValid())
   {
     m_ColorTransferFunction->AddRGBPoint(xVal, result.red() / 255.0,
         result.green() / 255.0, result.blue() / 255.0);
     this->update();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkColorTransferFunctionCanvas::MoveFunctionPoint(int index,
     std::pair<double,double> pos)
 {
   double color[3];
   m_ColorTransferFunction->GetColor(GetFunctionX(index), color);
   RemoveFunctionPoint( GetFunctionX(index));
   m_ColorTransferFunction->AddRGBPoint(pos.first, color[0], color[1], color[2]);
 }
 
 void QmitkColorTransferFunctionCanvas::AddRGB(double x, double r, double g,
     double b)
 {
   m_ColorTransferFunction->AddRGBPoint(x, r, g, b);
 }
 
diff --git a/Modules/QtWidgetsExt/QmitkTransferFunctionWidget.cpp b/Modules/QtWidgetsExt/QmitkTransferFunctionWidget.cpp
index d421e2b910..8c410c3e06 100755
--- a/Modules/QtWidgetsExt/QmitkTransferFunctionWidget.cpp
+++ b/Modules/QtWidgetsExt/QmitkTransferFunctionWidget.cpp
@@ -1,266 +1,268 @@
 /*===================================================================
 
 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 "QmitkTransferFunctionWidget.h"
 
 #include <mitkTransferFunctionProperty.h>
 #include <QPlastiqueStyle>
 
 QmitkTransferFunctionWidget::QmitkTransferFunctionWidget(QWidget* parent,
                                                          Qt::WindowFlags f) :
   QWidget(parent, f)
 {
   this->setupUi(this);
 
 
 
   // signals and slots connections
   connect(m_XEditScalarOpacity, SIGNAL(textEdited ( const QString & )), this, SLOT(SetXValueScalar( const QString & )));
   connect(m_YEditScalarOpacity, SIGNAL(textEdited ( const QString & )), this, SLOT(SetYValueScalar( const QString & )));
 
   connect(m_XEditGradientOpacity, SIGNAL(textEdited ( const QString & )), this, SLOT(SetXValueGradient( const QString & )));
   connect(m_YEditGradientOpacity, SIGNAL(textEdited ( const QString & )), this, SLOT(SetYValueGradient( const QString & )));
 
   connect(m_XEditColor, SIGNAL( textEdited ( const QString & ) ), this, SLOT(SetXValueColor( const QString & )));
 
   QPlastiqueStyle *sliderStyle = new QPlastiqueStyle();
 
   m_RangeSlider->setMaximum(2048);
   m_RangeSlider->setMinimum(-2048);
   m_RangeSlider->setHandleMovementMode(QxtSpanSlider::NoOverlapping);
   m_RangeSlider->setStyle(sliderStyle);
   connect(m_RangeSlider, SIGNAL(spanChanged(double,double)),this, SLOT(OnSpanChanged(double,double)));
 
   //reset button
   connect(m_RangeSliderReset, SIGNAL(pressed()), this, SLOT(OnResetSlider()));
 
   m_ScalarOpacityFunctionCanvas->SetQLineEdits(m_XEditScalarOpacity, m_YEditScalarOpacity);
   m_GradientOpacityCanvas->SetQLineEdits(m_XEditGradientOpacity, m_YEditGradientOpacity);
   m_ColorTransferFunctionCanvas->SetQLineEdits(m_XEditColor, 0);
 
   m_ScalarOpacityFunctionCanvas->SetTitle("Grayvalue -> Opacity");
   m_GradientOpacityCanvas->SetTitle("Grayvalue/Gradient -> Opacity");
   m_ColorTransferFunctionCanvas->SetTitle("Grayvalue -> Color");
 
 }
 
 QmitkTransferFunctionWidget::~QmitkTransferFunctionWidget()
 {
 }
 
 void QmitkTransferFunctionWidget::SetIntegerMode(bool intMode)
 {
   m_RangeSlider->setIntegerMode(intMode);
 }
 
 void QmitkTransferFunctionWidget::SetScalarLabel(const QString& scalarLabel)
 {
   m_textLabelX->setText(scalarLabel);
   m_textLabelX_2->setText(scalarLabel);
   m_textLabelX_3->setText(scalarLabel);
 
   m_ScalarOpacityFunctionCanvas->SetTitle(scalarLabel + " -> Opacity");
   m_GradientOpacityCanvas->SetTitle(scalarLabel + "/Gradient -> Opacity");
   m_ColorTransferFunctionCanvas->SetTitle(scalarLabel + " -> Color");
 }
 
 void QmitkTransferFunctionWidget::ShowScalarOpacityFunction(bool show)
 {
   m_ScalarOpacityWidget->setVisible(show);
 }
 
 void QmitkTransferFunctionWidget::ShowColorFunction(bool show)
 {
   m_ColorWidget->setVisible(show);
 }
 
 void QmitkTransferFunctionWidget::ShowGradientOpacityFunction(bool show)
 {
   m_GradientOpacityWidget->setVisible(show);
 }
 
 void QmitkTransferFunctionWidget::SetScalarOpacityFunctionEnabled(bool enable)
 {
   m_ScalarOpacityWidget->setEnabled(enable);
 }
 
 void QmitkTransferFunctionWidget::SetColorFunctionEnabled(bool enable)
 {
   m_ColorWidget->setEnabled(enable);
 }
 
 void QmitkTransferFunctionWidget::SetGradientOpacityFunctionEnabled(bool enable)
 {
   m_GradientOpacityWidget->setEnabled(enable);
 }
 
 void QmitkTransferFunctionWidget::SetDataNode(mitk::DataNode* node)
 {
   if (node)
   {
     tfpToChange = dynamic_cast<mitk::TransferFunctionProperty*>(node->GetProperty("TransferFunction"));
 
     if(!tfpToChange)
     {
       if (! dynamic_cast<mitk::Image*>(node->GetData()))
       {
         MITK_WARN << "QmitkTransferFunctionWidget::SetDataNode called with non-image node";
         goto turnOff;
       }
 
       node->SetProperty("TransferFunction", tfpToChange = mitk::TransferFunctionProperty::New() );
     }
 
     mitk::TransferFunction::Pointer tf = tfpToChange->GetValue();
 
     if( mitk::BaseData* data = node->GetData() )
     {
       mitk::SimpleHistogram *h = histogramCache[data];
 
       m_RangeSliderMin= h->GetMin();
       m_RangeSliderMax= h->GetMax();
 
       m_RangeSlider->blockSignals(true);
       m_RangeSlider->setMinimum(m_RangeSliderMin);
       m_RangeSlider->setMaximum(m_RangeSliderMax);
       m_RangeSlider->setSpan( m_RangeSliderMin, m_RangeSliderMax);
       m_RangeSlider->blockSignals(false);
 
       m_ScalarOpacityFunctionCanvas->SetHistogram( h );
       m_GradientOpacityCanvas->SetHistogram( h );
+      m_ColorTransferFunctionCanvas->SetHistogram( h );
     }
 
     OnUpdateCanvas();
 
     return;
   }
 
 turnOff:
 
   m_ScalarOpacityFunctionCanvas->setEnabled(false);
   m_ScalarOpacityFunctionCanvas->SetHistogram(0);
   m_GradientOpacityCanvas->setEnabled(false);
   m_GradientOpacityCanvas->SetHistogram(0);
   m_ColorTransferFunctionCanvas->setEnabled(false);
+  m_ColorTransferFunctionCanvas->SetHistogram(0);
   tfpToChange = 0;
 }
 
 void QmitkTransferFunctionWidget::OnUpdateCanvas()
 {
 
   if(tfpToChange.IsNull())
     return;
 
   mitk::TransferFunction::Pointer tf = tfpToChange->GetValue();
 
   if(tf.IsNull())
     return;
 
   m_ScalarOpacityFunctionCanvas->SetPiecewiseFunction( tf->GetScalarOpacityFunction() );
   m_GradientOpacityCanvas->SetPiecewiseFunction( tf->GetGradientOpacityFunction() );
   m_ColorTransferFunctionCanvas->SetColorTransferFunction( tf->GetColorTransferFunction() );
 
   UpdateRanges();
 
   m_ScalarOpacityFunctionCanvas->update();
   m_GradientOpacityCanvas->update();
   m_ColorTransferFunctionCanvas->update();
 }
 
 void QmitkTransferFunctionWidget::SetXValueScalar( const QString text )
 {
   if ( !text.endsWith( "." ))
   {
     m_ScalarOpacityFunctionCanvas->SetX(text.toFloat());
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkTransferFunctionWidget::SetYValueScalar( const QString text )
 {
   if ( !text.endsWith( "." ))
   {
     m_ScalarOpacityFunctionCanvas->SetY(text.toFloat());
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkTransferFunctionWidget::SetXValueGradient( const QString text )
 {
   if ( !text.endsWith( "." ))
   {
     m_GradientOpacityCanvas->SetX(text.toFloat());
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkTransferFunctionWidget::SetYValueGradient( const QString text )
 {
   if ( !text.endsWith( "." ))
   {
     m_GradientOpacityCanvas->SetY(text.toFloat());
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkTransferFunctionWidget::SetXValueColor( const QString text )
 {
   if ( !text.endsWith( "." ))
   {
     m_ColorTransferFunctionCanvas->SetX(text.toFloat());
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkTransferFunctionWidget::UpdateRanges()
 {
   double lower =  m_RangeSlider->lowerValue();
   double upper =  m_RangeSlider->upperValue();
 
   m_ScalarOpacityFunctionCanvas->SetMin(lower);
   m_ScalarOpacityFunctionCanvas->SetMax(upper);
 
   m_GradientOpacityCanvas->SetMin(lower);
   m_GradientOpacityCanvas->SetMax(upper);
 
   m_ColorTransferFunctionCanvas->SetMin(lower);
   m_ColorTransferFunctionCanvas->SetMax(upper);
 }
 
 
 void QmitkTransferFunctionWidget::OnSpanChanged(double, double)
 {
   UpdateRanges();
 
   m_GradientOpacityCanvas->update();
   m_ColorTransferFunctionCanvas->update();
   m_ScalarOpacityFunctionCanvas->update();
 }
 
 void QmitkTransferFunctionWidget::OnResetSlider()
 {
   m_RangeSlider->blockSignals(true);
   m_RangeSlider->setUpperValue(m_RangeSliderMax);
   m_RangeSlider->setLowerValue(m_RangeSliderMin);
   m_RangeSlider->blockSignals(false);
 
   UpdateRanges();
   m_GradientOpacityCanvas->update();
   m_ColorTransferFunctionCanvas->update();
   m_ScalarOpacityFunctionCanvas->update();
 }