Merge pull request #15256 from mantidproject/14936_SliceSelector

Show the SliceSelector widget when invoquing the DynamicPDF custom-interface

MantidQt/API/CMakeLists.txt

@@ -28,8 +28,9 @@
 	src/PropertyWidgetFactory.cpp
 	src/PythonRunner.cpp
 	src/PythonThreading.cpp
+        src/QScienceSpinBox.cpp
 	src/QtSignalChannel.cpp
-	src/QwtRasterDataMD.cpp
+        src/QwtRasterDataMD.cpp
 	src/QwtWorkspaceBinData.cpp
 	src/QwtWorkspaceSpectrumData.cpp
 	src/RepoModel.cpp
@@ -61,6 +62,7 @@ set ( MOC_FILES
   inc/MantidQtAPI/OptionsPropertyWidget.h
   inc/MantidQtAPI/PropertyWidget.h
   inc/MantidQtAPI/PythonRunner.h
+  inc/MantidQtAPI/QScienceSpinBox.h
   inc/MantidQtAPI/QtSignalChannel.h
   inc/MantidQtAPI/ScriptRepositoryView.h
   inc/MantidQtAPI/RepoTreeView.h
@@ -82,7 +84,7 @@ set ( INC_FILES
 	inc/MantidQtAPI/DllOption.h
 	inc/MantidQtAPI/FileDialogHandler.h
 	inc/MantidQtAPI/GraphOptions.h
-    inc/MantidQtAPI/DistributionOptions.h
+        inc/MantidQtAPI/DistributionOptions.h
 	inc/MantidQtAPI/HelpWindow.h
 	inc/MantidQtAPI/InterfaceFactory.h
 	inc/MantidQtAPI/InterfaceManager.h
@@ -98,8 +100,9 @@ set ( INC_FILES
 	inc/MantidQtAPI/PropertyWidgetFactory.h
 	inc/MantidQtAPI/PythonSystemHeader.h
 	inc/MantidQtAPI/PythonThreading.h
-	inc/MantidQtAPI/QwtRasterDataMD.h
-	inc/MantidQtAPI/QwtWorkspaceBinData.h
+        inc/MantidQtAPI/QScienceSpinBox.h
+        inc/MantidQtAPI/QwtRasterDataMD.h
+        inc/MantidQtAPI/QwtWorkspaceBinData.h
 	inc/MantidQtAPI/QwtWorkspaceSpectrumData.h
 	inc/MantidQtAPI/ScaleEngine.h
 	inc/MantidQtAPI/ScriptRepositoryView.h

MantidQt/API/inc/MantidQtAPI/QScienceSpinBox.h

+#ifndef MANTIDQT_API_QSCIENCESPINBOX_H_
+#define MANTIDQT_API_QSCIENCESPINBOX_H_
+
+#include "MantidQtAPI/DllOption.h"
+
+#include <QtGui/QDoubleSpinBox>
+#include <QtGui/QDoubleValidator>
+#include <QtGui/QLineEdit>
+#include <QtCore/QVariant>
+#include <QtCore/QDebug>
+#include <QtCore/QString>
+
+namespace MantidQt {
+namespace API {
+
+class EXPORT_OPT_MANTIDQT_API QScienceSpinBox : public QDoubleSpinBox {
+  Q_OBJECT
+public:
+  QScienceSpinBox(QWidget *parent = 0);
+
+  int decimals() const;
+  void setDecimals(int value);
+
+  QString textFromValue(double value) const;
+  double valueFromText(const QString &text) const;
+
+  void setLogSteps(bool logSteps);
+
+private:
+  int dispDecimals;
+  QChar delimiter, thousand;
+  QDoubleValidator *v;
+  /// Will step in a log way (multiplicatively)
+  bool m_logSteps;
+
+private:
+  void initLocalValues(QWidget *parent);
+  bool isIntermediateValue(const QString &str) const;
+  QVariant validateAndInterpret(QString &input, int &pos,
+                                QValidator::State &state) const;
+  QValidator::State validate(QString &text, int &pos) const;
+  void fixup(QString &input) const;
+  QString stripped(const QString &t, int *pos) const;
+  double round(double value) const;
+  void stepBy(int steps);
+
+public slots:
+  void stepDown();
+  void stepUp();
+
+signals:
+  void valueChangedFromArrows();
+};
+
+} // namespace API
+} // namespace MantidQt
+#endif /* MANTIDQT_API_QSCIENCESPINBOX_H_ */

MantidQt/API/inc/MantidQtAPI/QwtRasterDataMD.h

@@ -54,6 +54,8 @@ public:
 
   void setZerosAsNan(bool val);
 
+  bool isZerosAsNan() const;
+
   void setNormalization(Mantid::API::MDNormalization normalization);
   Mantid::API::MDNormalization getNormalization() const;
 

MantidQt/API/src/QScienceSpinBox.cpp

+#include "MantidQtAPI/QScienceSpinBox.h"
+#include <limits>
+
+//#define QSPINBOX_QSBDEBUG
+#ifdef QSPINBOX_QSBDEBUG
+#define QSBDEBUG qDebug
+#else
+#define QSBDEBUG                                                               \
+  if (false)                                                                   \
+  qDebug
+#endif
+
+namespace MantidQt {
+namespace API {
+
+// reimplemented function, copied from qspinbox.cpp
+bool isIntermediateValueHelper(qint64 num, qint64 min, qint64 max,
+                               qint64 *match = 0) {
+  QSBDEBUG("%lld %lld %lld", num, min, max);
+
+  if (num >= min && num <= max) {
+    if (match)
+      *match = num;
+    QSBDEBUG("returns true 0");
+    return true;
+  }
+  qint64 tmp = num;
+
+  int numDigits = 0;
+  int digits[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  if (tmp == 0) {
+    numDigits = 1;
+    digits[0] = 0;
+  } else {
+    tmp = qAbs(num);
+    for (int i = 0; tmp > 0; ++i) {
+      digits[numDigits++] = int(tmp) % 10;
+      tmp /= 10;
+    }
+  }
+
+  int failures = 0;
+  qint64 number;
+  for (number = max; number >= min; --number) {
+    tmp = qAbs(number);
+    for (int i = 0; tmp > 0;) {
+      if (digits[i] == (tmp % 10)) {
+        if (++i == numDigits) {
+          if (match)
+            *match = number;
+          QSBDEBUG("returns true 1");
+          return true;
+        }
+      }
+      tmp /= 10;
+    }
+    if (failures++ == 500000) { // upper bound
+      if (match)
+        *match = num;
+      QSBDEBUG("returns true 2");
+      return true;
+    }
+  }
+  QSBDEBUG("returns false");
+  return false;
+}
+
+QScienceSpinBox::QScienceSpinBox(QWidget *parent)
+    : QDoubleSpinBox(parent), m_logSteps(true) {
+  initLocalValues(parent);
+  setDecimals(8);
+  QDoubleSpinBox::setDecimals(1000);
+
+  // set Range to maximum possible values
+  double doubleMax = std::numeric_limits<double>::max();
+  setRange(-doubleMax, doubleMax);
+
+  v = new QDoubleValidator(this);
+  v->setDecimals(1000); // (standard anyway)
+  v->setNotation(QDoubleValidator::ScientificNotation);
+  this->lineEdit()->setValidator(v);
+}
+
+void QScienceSpinBox::initLocalValues(QWidget *parent) {
+  const QString str = (parent ? parent->locale() : QLocale()).toString(4567.1);
+  if (str.size() == 6) {
+    delimiter = str.at(4);
+    thousand = QChar((ushort)0);
+  } else if (str.size() == 7) {
+    thousand = str.at(1);
+    delimiter = str.at(5);
+  }
+  Q_ASSERT(!delimiter.isNull());
+}
+
+int QScienceSpinBox::decimals() const { return dispDecimals; }
+
+void QScienceSpinBox::setDecimals(int value) { dispDecimals = value; }
+
+// overwritten virtual function of QAbstractSpinBox
+void QScienceSpinBox::stepBy(int steps) {
+  if (steps < 0)
+    stepDown();
+  else
+    stepUp();
+}
+
+void QScienceSpinBox::setLogSteps(bool logSteps) { m_logSteps = logSteps; }
+
+void QScienceSpinBox::stepDown() {
+  if (m_logSteps)
+    setValue(value() / this->singleStep());
+  else
+    setValue(value() - this->singleStep());
+  emit valueChangedFromArrows();
+}
+
+void QScienceSpinBox::stepUp() {
+  if (m_logSteps)
+    setValue(value() * this->singleStep());
+  else
+    setValue(value() + this->singleStep());
+  emit valueChangedFromArrows();
+}
+
+/*!
+ *  text to be displayed in spinbox
+ */
+QString QScienceSpinBox::textFromValue(double value) const {
+
+  // convert to string -> Using exponetial display with internal decimals
+  QString str = locale().toString(value, 'e', dispDecimals);
+  // remove thousand sign
+  if (qAbs(value) >= 1000.0) {
+    str.remove(thousand);
+  }
+  return str;
+}
+
+double QScienceSpinBox::valueFromText(const QString &text) const {
+  QString copy = text;
+  int pos = this->lineEdit()->cursorPosition();
+  QValidator::State state = QValidator::Acceptable;
+  return validateAndInterpret(copy, pos, state).toDouble();
+}
+
+/**
+ * Round
+ * @param value: Value to round.
+ * @return rounded value
+ */
+double QScienceSpinBox::round(double value) const {
+  // this function is never used...?
+  const QString strDbl = locale().toString(value, 'g', dispDecimals);
+  return locale().toDouble(strDbl);
+}
+
+// overwritten virtual function of QAbstractSpinBox
+QValidator::State QScienceSpinBox::validate(QString &text, int &pos) const {
+  QValidator::State state;
+  validateAndInterpret(text, pos, state);
+  return state;
+}
+
+// overwritten virtual function of QAbstractSpinBox
+void QScienceSpinBox::fixup(QString &input) const { input.remove(thousand); }
+
+// reimplemented function, copied from
+// QDoubleSpinBoxPrivate::isIntermediateValue
+bool QScienceSpinBox::isIntermediateValue(const QString &str) const {
+  QSBDEBUG() << "input is" << str << minimum() << maximum();
+  qint64 dec = 1;
+
+  for (int i = 0; i < decimals(); ++i)
+    dec *= 10;
+
+  const QLatin1Char dot('.');
+
+  /*!
+   * determine minimum possible values on left and right of Decimal-char
+   */
+  // I know QString::number() uses CLocale so I use dot
+  const QString minstr =
+      QString::number(minimum(), 'f', QDoubleSpinBox::decimals());
+  qint64 min_left = minstr.left(minstr.indexOf(dot)).toLongLong();
+  qint64 min_right = minstr.mid(minstr.indexOf(dot) + 1).toLongLong();
+
+  const QString maxstr =
+      QString::number(maximum(), 'f', QDoubleSpinBox::decimals());
+  qint64 max_left = maxstr.left(maxstr.indexOf(dot)).toLongLong();
+  qint64 max_right = maxstr.mid(maxstr.indexOf(dot) + 1).toLongLong();
+
+  /*!
+   * determine left and right long values (left and right of delimiter)
+   */
+  const int dotindex = str.indexOf(delimiter);
+  const bool negative = maximum() < 0;
+  qint64 left = 0, right = 0;
+  bool doleft = true;
+  bool doright = true;
+  // no separator -> everthing in left
+  if (dotindex == -1) {
+    left = str.toLongLong();
+    doright = false;
+  }
+  // separator on left or contains '+'
+  else if (dotindex == 0 || (dotindex == 1 && str.at(0) == QLatin1Char('+'))) {
+    // '+' at negative max
+    if (negative) {
+      QSBDEBUG() << __FILE__ << __LINE__ << "returns false";
+      return false;
+    }
+    doleft = false;
+    right = str.mid(dotindex + 1).toLongLong();
+  }
+  // contains '-'
+  else if (dotindex == 1 && str.at(0) == QLatin1Char('-')) {
+    // '-' at positiv max
+    if (!negative) {
+      QSBDEBUG() << __FILE__ << __LINE__ << "returns false";
+      return false;
+    }
+    doleft = false;
+    right = str.mid(dotindex + 1).toLongLong();
+  } else {
+    left = str.left(dotindex).toLongLong();
+    if (dotindex == str.size() - 1) { // nothing right of Separator
+      doright = false;
+    } else {
+      right = str.mid(dotindex + 1).toLongLong();
+    }
+  }
+  // left > 0, with max < 0 and no '-'
+  if ((left >= 0 && max_left < 0 && !str.startsWith(QLatin1Char('-')))
+      // left > 0, with min > 0
+      ||
+      (left < 0 && min_left >= 0)) {
+    QSBDEBUG("returns false");
+    return false;
+  }
+
+  qint64 match = min_left;
+  if (doleft && !isIntermediateValueHelper(left, min_left, max_left, &match)) {
+    QSBDEBUG() << __FILE__ << __LINE__ << "returns false";
+    return false;
+  }
+  if (doright) {
+    QSBDEBUG("match %lld min_left %lld max_left %lld", match, min_left,
+             max_left);
+    if (!doleft) {
+      if (min_left == max_left) {
+        const bool ret = isIntermediateValueHelper(
+            qAbs(left), negative ? max_right : min_right,
+            negative ? min_right : max_right);
+        QSBDEBUG() << __FILE__ << __LINE__ << "returns" << ret;
+        return ret;
+      } else if (qAbs(max_left - min_left) == 1) {
+        const bool ret = isIntermediateValueHelper(qAbs(left), min_right,
+                                                   negative ? 0 : dec) ||
+                         isIntermediateValueHelper(
+                             qAbs(left), negative ? dec : 0, max_right);
+        QSBDEBUG() << __FILE__ << __LINE__ << "returns" << ret;
+        return ret;
+      } else {
+        const bool ret = isIntermediateValueHelper(qAbs(left), 0, dec);
+        QSBDEBUG() << __FILE__ << __LINE__ << "returns" << ret;
+        return ret;
+      }
+    }
+    if (match != min_left) {
+      min_right = negative ? dec : 0;
+    }
+    if (match != max_left) {
+      max_right = negative ? 0 : dec;
+    }
+    qint64 tmpl = negative ? max_right : min_right;
+    qint64 tmpr = negative ? min_right : max_right;
+    const bool ret = isIntermediateValueHelper(right, tmpl, tmpr);
+    QSBDEBUG() << __FILE__ << __LINE__ << "returns" << ret;
+    return ret;
+  }
+  QSBDEBUG() << __FILE__ << __LINE__ << "returns true";
+  return true;
+}
+
+/*!
+    \internal Multi purpose function that parses input, sets state to
+    the appropriate state and returns the value it will be interpreted
+    as.
+ */
+// reimplemented function, copied from
+// QDoubleSpinBoxPrivate::validateAndInterpret
+QVariant QScienceSpinBox::validateAndInterpret(QString &input, int &pos,
+                                               QValidator::State &state) const {
+  /*! return 'cachedText' if
+   *   input = cachedText, or input Empty
+   */
+
+  static QString cachedText;
+  static QValidator::State cachedState;
+  static QVariant cachedValue;
+
+  if (cachedText == input && !input.isEmpty()) {
+    state = cachedState;
+    QSBDEBUG() << "cachedText was"
+               << "'" << cachedText << "'"
+               << "state was " << state << " and value was " << cachedValue;
+    return cachedValue;
+  }
+  const double max = maximum();
+  const double min = minimum();
+
+  // removes prefix & suffix
+  QString copy = stripped(input, &pos);
+  QSBDEBUG() << "input" << input << "copy" << copy;
+
+  int len = copy.size();
+  double num = min;
+  const bool plus = max >= 0;
+  const bool minus = min <= 0;
+
+  // Test possible 'Intermediate' reasons
+  switch (len) {
+  case 0:
+    // Length 0 is always 'Intermediate', except for min=max
+    if (max != min) {
+      state = QValidator::Intermediate;
+    } else {
+      state = QValidator::Invalid;
+    }
+    goto end;
+  case 1:
+    // if only char is '+' or '-'
+    if (copy.at(0) == delimiter || (plus && copy.at(0) == QLatin1Char('+')) ||
+        (minus && copy.at(0) == QLatin1Char('-'))) {
+      state = QValidator::Intermediate;
+      goto end;
+    }
+    break;
+  case 2:
+    // if only chars are '+' or '-' followed by Comma seperator (delimiter)
+    if (copy.at(1) == delimiter &&
+        ((plus && copy.at(0) == QLatin1Char('+')) ||
+         (minus && copy.at(0) == QLatin1Char('-')))) {
+      state = QValidator::Intermediate;
+      goto end;
+    }
+    break;
+  default:
+    break;
+  } // end switch
+
+  // First char must not be thousand-char
+  if (copy.at(0) == thousand) {
+    QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+    state = QValidator::Invalid;
+    goto end;
+  }
+  // Test possible 'Invalid' reasons
+  else if (len > 1) {
+    const int dec = copy.indexOf(delimiter); // position of delimiter
+    // if decimal separator (delimiter) exists
+    if (dec != -1) {
+      // not two delimiters after one other (meaning something like ',,')
+      if (dec + 1 < copy.size() && copy.at(dec + 1) == delimiter &&
+          pos == dec + 1) {
+        copy.remove(dec + 1,
+                    1); // typing a delimiter when you are on the delimiter
+      }                 // should be treated as typing right arrow
+      // too many decimal points
+      if (copy.size() - dec > QDoubleSpinBox::decimals() + 1) {
+        QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+        state = QValidator::Invalid;
+        goto end;
+      }
+      // after decimal separator no thousand char
+      for (int i = dec + 1; i < copy.size(); ++i) {
+        if (copy.at(i).isSpace() || copy.at(i) == thousand) {
+          QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+          state = QValidator::Invalid;
+          goto end;
+        }
+      }
+      // if no decimal separator exists
+    } else {
+      const QChar &last = copy.at(len - 1);
+      const QChar &secondLast = copy.at(len - 2);
+      // group of two thousand or space chars is invalid
+      if ((last == thousand || last.isSpace()) &&
+          (secondLast == thousand || secondLast.isSpace())) {
+        state = QValidator::Invalid;
+        QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+        goto end;
+      }
+      // two space chars is invalid
+      else if (last.isSpace() &&
+               (!thousand.isSpace() || secondLast.isSpace())) {
+        state = QValidator::Invalid;
+        QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+        goto end;
+      }
+    }
+  } // end if (len > 1)
+
+  // block of remaining test before 'end' mark
+  {
+    bool ok = false;
+    bool notAcceptable = false;
+
+    // convert 'copy' to double, and check if that was 'ok'
+    QLocale loc(locale());
+    num = loc.toDouble(copy, &ok);
+    QSBDEBUG() << __FILE__ << __LINE__ << loc << copy << num << ok;
+
+    // conversion to double did fail
+    if (!ok) {
+      // maybe thousand char was responsable
+      if (thousand.isPrint()) {
+        // if no thousand sign is possible, then
+        // something else is responable -> Invalid
+        if (max < 1000 && min > -1000 && copy.contains(thousand)) {
+          state = QValidator::Invalid;
+          QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+          goto end;
+        }
+
+        // two thousand-chars after one other are not valid
+        const int len = copy.size();
+        for (int i = 0; i < len - 1; ++i) {
+          if (copy.at(i) == thousand && copy.at(i + 1) == thousand) {
+            QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+            state = QValidator::Invalid;
+            goto end;
+          }
+        }
+
+        // remove thousand-chars
+        const int s = copy.size();
+        copy.remove(thousand);
+        pos = qMax(0, pos - (s - copy.size()));
+
+        num = loc.toDouble(copy, &ok);
+        QSBDEBUG() << thousand << num << copy << ok;
+
+        // if conversion still not valid, then reason unknown -> Invalid
+        if (!ok) {
+          state = QValidator::Invalid;
+          QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+          goto end;
+        }
+        notAcceptable = true; // -> state = Intermediate
+      }                       // endif: (thousand.isPrint())
+    }
+
+    // no thousand sign, but still invalid for unknown reason
+    if (!ok) {
+      state = QValidator::Invalid;
+      QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+    }
+    // number valid and within valid range
+    else if (num >= min && num <= max) {
+      if (notAcceptable) {
+        state = QValidator::Intermediate; // conversion to num initially failed
+      } else {
+        state = QValidator::Acceptable;
+      }
+      QSBDEBUG() << __FILE__ << __LINE__ << "state is set to "
+                 << (state == QValidator::Intermediate ? "Intermediate"
+                                                       : "Acceptable");
+    }
+    // when max and min is the same the only non-Invalid input is max (or min)
+    else if (max == min) {
+      state = QValidator::Invalid;
+      QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+    } else {
+      // value out of valid range (coves only special cases)
+      if ((num >= 0 && num > max) || (num < 0 && num < min)) {
+        state = QValidator::Invalid;
+        QSBDEBUG() << __FILE__ << __LINE__ << "state is set to Invalid";
+      } else {
+        // invalid range, further test with 'isIntermediateValue'
+        if (isIntermediateValue(copy)) {
+          state = QValidator::Intermediate;
+        } else {
+          state = QValidator::Invalid;
+        }
+        QSBDEBUG() << __FILE__ << __LINE__ << "state is set to "
+                   << (state == QValidator::Intermediate ? "Intermediate"
+                                                         : "Acceptable");
+      }
+    }
+  }
+
+end:
+  // if something went wrong, set num to something valid
+  if (state != QValidator::Acceptable) {
+    num = max > 0 ? min : max;
+  }
+
+  // save (private) cache values
+  cachedText = prefix() + copy + suffix();
+  cachedState = state;
+  cachedValue = QVariant(num);
+  // return resulting valid num
+  return QVariant(num);
+}
+
+/*!
+    \internal
+    Strips any prefix/suffix from \a text.
+ */
+// reimplemented function, copied from QAbstractSpinBoxPrivate::stripped
+QString QScienceSpinBox::stripped(const QString &t, int *pos) const {
+  QString text = t;
+  QString prefixtext = prefix();
+  QString suffixtext = suffix();
+
+  if (specialValueText().size() == 0 || text != specialValueText()) {
+    int from = 0;
+    int size = text.size();
+    bool changed = false;
+    if (prefixtext.size() && text.startsWith(prefixtext)) {
+      from += prefixtext.size();
+      size -= from;
+      changed = true;
+    }
+    if (suffixtext.size() && text.endsWith(suffixtext)) {
+      size -= suffixtext.size();
+      changed = true;
+    }
+    if (changed)
+      text = text.mid(from, size);
+  }
+
+  const int s = text.size();
+  text = text.trimmed();
+  if (pos)
+    (*pos) -= (s - text.size());
+  return text;
+}
+
+} // namespace API
+} // namespace MantidQt

MantidQt/API/src/QwtRasterDataMD.cpp

@@ -108,6 +108,10 @@ void QwtRasterDataMD::setFastMode(bool fast) { this->m_fast = fast; }
  */
 void QwtRasterDataMD::setZerosAsNan(bool val) { this->m_zerosAsNan = val; }
 
+bool QwtRasterDataMD::isZerosAsNan() const {
+  return this->m_zerosAsNan;
+}
+
 //------------------------------------------------------------------------------------------------------
 /** Set how the signal is normalized
  *

MantidQt/CustomInterfaces/CMakeLists.txt

 set ( SRC_FILES
 	src/DataComparison.cpp
 	src/DirectConvertToEnergy.cpp
+        src/DynamicPDF/SliceSelector.cpp
 	src/EnggDiffraction/EnggDiffractionPresenter.cpp
 	src/EnggDiffraction/EnggDiffractionViewQtGUI.cpp
 	src/Homer.cpp
@@ -94,7 +95,7 @@ set ( SRC_FILES
 	src/SANSEventSlicing.cpp
 	src/SANSPlotSpecial.cpp
 	src/SANSRunWindow.cpp
-	src/SampleTransmission.cpp
+        src/SampleTransmission.cpp
 	src/StepScan.cpp
 	src/Tomography/ImageROIPresenter.cpp
 	src/Tomography/ImageROIViewQtWidget.cpp
@@ -115,10 +116,12 @@ set ( SRC_FILES
 )
 
 # Include files aren't required, but this makes them appear in Visual Studio
+# IMPORTANT: Include files are required in the MOC_FILES set. Scroll down to find it.
 set ( INC_FILES
 	inc/MantidQtCustomInterfaces/Background.h
 	inc/MantidQtCustomInterfaces/DataComparison.h
 	inc/MantidQtCustomInterfaces/DirectConvertToEnergy.h
+        inc/MantidQtCustomInterfaces/DynamicPDF/SliceSelector.h
 	inc/MantidQtCustomInterfaces/DllConfig.h
 	inc/MantidQtCustomInterfaces/EnggDiffraction/EnggDiffCalibSettings.h
 	inc/MantidQtCustomInterfaces/EnggDiffraction/EnggDiffractionPresWorker.h
@@ -142,7 +145,7 @@ set ( INC_FILES
 	inc/MantidQtCustomInterfaces/Indirect/ISISEnergyTransfer.h
 	inc/MantidQtCustomInterfaces/Indirect/IndirectBayes.h
 	inc/MantidQtCustomInterfaces/Indirect/IndirectBayesTab.h
-	inc/MantidQtCustomInterfaces/Indirect/IndirectCorrections.h
+        inc/MantidQtCustomInterfaces/Indirect/IndirectCorrections.h
 	inc/MantidQtCustomInterfaces/Indirect/IndirectDataAnalysis.h
 	inc/MantidQtCustomInterfaces/Indirect/IndirectDataAnalysisTab.h
 	inc/MantidQtCustomInterfaces/Indirect/IndirectDataReduction.h
@@ -261,6 +264,7 @@ set ( SRC_UNITY_IGNORE_FILES )
 set ( MOC_FILES inc/MantidQtCustomInterfaces/Background.h
                 inc/MantidQtCustomInterfaces/DataComparison.h
                 inc/MantidQtCustomInterfaces/DirectConvertToEnergy.h
+                inc/MantidQtCustomInterfaces/DynamicPDF/SliceSelector.h
                 inc/MantidQtCustomInterfaces/EnggDiffraction/EnggDiffractionPresenter.h
                 inc/MantidQtCustomInterfaces/EnggDiffraction/EnggDiffractionPresWorker.h
                 inc/MantidQtCustomInterfaces/EnggDiffraction/EnggDiffractionViewQtGUI.h
@@ -349,6 +353,7 @@ set ( MOC_FILES inc/MantidQtCustomInterfaces/Background.h
 
 set ( UI_FILES inc/MantidQtCustomInterfaces/DataComparison.ui
                inc/MantidQtCustomInterfaces/DirectConvertToEnergy.ui
+               inc/MantidQtCustomInterfaces/DynamicPDF/SliceSelector.ui
                inc/MantidQtCustomInterfaces/EnggDiffraction/EnggDiffractionQtGUI.ui
                inc/MantidQtCustomInterfaces/EnggDiffraction/EnggDiffractionQtTabCalib.ui
                inc/MantidQtCustomInterfaces/EnggDiffraction/EnggDiffractionQtTabFocus.ui
@@ -455,6 +460,7 @@ else ( ${Boost_VERSION} GREATER 104799 AND ${qt_version} VERSION_GREATER 4.7.3 )
 endif ( ${Boost_VERSION} GREATER 104799 AND ${qt_version} VERSION_GREATER 4.7.3 )
 
 qt4_wrap_cpp ( MOCCED_FILES ${MOC_FILES} OPTIONS ${extra_options} )
+
 qt4_add_resources ( RES_FILES icons/CustomInterfacesIcons.qrc )
 
 set ( ALL_SRC ${SRC_FILES} ${MOCCED_FILES} )#${RES_FILES})

MantidQt/CustomInterfaces/inc/MantidQtCustomInterfaces/DynamicPDF/BackgroundRemover.h

+#ifndef MANTIDQTCUSTOMINTERFACES_DYNAMICPDF_BACKGROUNDREMOVER_H_
+#define MANTIDQTCUSTOMINTERFACES_DYNAMICPDF_BACKGROUNDREMOVER_H_
+
+#include <QDialog>
+#include "ui_BackgroundRemover.h"
+#include <boost/shared_ptr.hpp>
+
+namespace MantidQt {
+namespace CustomInterfaces {
+namespace DynamicPDF {
+
+// Forward declaration
+class WorkspaceRecord;
+class SliceSelector;
+
+class BackgroundRemover: public QDialog
+{
+  Q_OBJECT
+
+public:
+
+  BackgroundRemover(SliceSelector *parent);
+
+  void refreshSlice(const boost::shared_ptr<WorkspaceRecord> loadedWorkspace,
+                const size_t &workspaceIndex);
+
+private:
+  Ui::BackgroundRemover m_uiForm;
+};
+
+}
+}
+}
+
+#endif // MANTIDQTCUSTOMINTERFACES_DYNAMICPDF_BACKGROUNDREMOVER_H_

MantidQt/CustomInterfaces/inc/MantidQtCustomInterfaces/DynamicPDF/BackgroundRemover.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>BackgroundRemover</class>
+ <widget class="QDialog" name="BackgroundRemover">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>349</width>
+    <height>177</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Background remover tool</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_2">
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>BackgroundRemover</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>BackgroundRemover</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

MantidQt/CustomInterfaces/inc/MantidQtCustomInterfaces/DynamicPDF/SliceSelector.h

+#ifndef MANTIDQTCUSTOMINTERFACES_DYNAMICPDF_SLICESELECTOR_H_
+#define MANTIDQTCUSTOMINTERFACES_DYNAMICPDF_SLICESELECTOR_H_
+#include "MantidAPI/MatrixWorkspace.h"
+#include "MantidQtCustomInterfaces/DllConfig.h"
+#include "MantidQtAPI/UserSubWindow.h"
+#include "ui_SliceSelector.h"
+#include <qwt_plot_spectrogram.h>
+
+namespace MantidQt {
+namespace MantidWidgets {
+  class MWView;
+}
+namespace CustomInterfaces {
+namespace DynamicPDF {
+
+// Forward Declarations
+//class BackgroundRemover;
+
+/// Helper class containing pointer and some metadata for the loaded workspace
+class WorkspaceRecord{
+
+public:
+  WorkspaceRecord(const std::string &workspaceName);
+  void updateMetadata(const size_t &newIndex);
+
+  boost::shared_ptr<Mantid::API::MatrixWorkspace> m_ws;
+  const std::string m_name;
+  double m_energy;
+  std::string m_label;
+};
+
+class MANTIDQT_CUSTOMINTERFACES_DLL SliceSelector
+    : public MantidQt::API::UserSubWindow {
+  Q_OBJECT
+
+public:
+  /// The name of the interface as registered into the factory
+  static std::string name() { return "Dynamic PDF Slice Selector"; }
+  // This interface's categories.
+  static QString categoryInfo() { return "DynamicPDF"; }
+
+public:
+  SliceSelector(QWidget *parent = nullptr);
+  ~SliceSelector();
+
+private slots:
+  void showHelp();
+  void loadSlices(const QString &workspaceName);
+  void updateSelectedSlice(const int &newSelectedIndex);
+  void updatePlotSelectedSlice();
+  void launchBackgroundRemover();
+
+private:
+  void initLayout();
+  /// The form generated by Qt Designer
+  Ui::SliceSelector m_uiForm;
+  boost::shared_ptr<WorkspaceRecord> m_loadedWorkspace;
+  size_t m_selectedWorkspaceIndex;
+  /// The child dialog to remove the multiphonon background
+  //boost::shared_ptr<BackgroundRemover> m_BackgroundRemover;
+};
+
+}
+}
+}
+#endif //MANTIDQTCUSTOMINTERFACES_DYNAMICPDF_SLICESELECTOR_H_

MantidQt/CustomInterfaces/inc/MantidQtCustomInterfaces/DynamicPDF/SliceSelector.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>SliceSelector</class>
+ <widget class="QMainWindow" name="SliceSelector">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>613</width>
+    <height>850</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string>Dynamic PDF Slice Selector</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <property name="sizePolicy">
+    <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+     <horstretch>0</horstretch>
+     <verstretch>0</verstretch>
+    </sizepolicy>
+   </property>
+   <layout class="QVBoxLayout" name="verticalLayout">
+    <item>
+     <widget class="QGroupBox" name="groupLoadSlices">
+      <property name="sizePolicy">
+       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+        <horstretch>0</horstretch>
+        <verstretch>0</verstretch>
+       </sizepolicy>
+      </property>
+      <property name="title">
+       <string>Input</string>
+      </property>
+      <layout class="QGridLayout" name="loRangeBinning">
+       <property name="topMargin">
+        <number>9</number>
+       </property>
+       <property name="bottomMargin">
+        <number>9</number>
+       </property>
+       <item row="0" column="0">
+        <widget class="MantidQt::MantidWidgets::DataSelector" name="dataSelector" native="true"/>
+       </item>
+      </layout>
+     </widget>
+    </item>
+    <item>
+     <layout class="QHBoxLayout" name="layoutSliceSelector">
+      <item>
+       <widget class="QLabel" name="labelWorkspaceIndex">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text">
+         <string>Workspace Index</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QSpinBox" name="spinboxSliceSelector">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="labelSliceEnergy">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text">
+         <string>Energy  = NAN</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </item>
+    <item>
+     <layout class="QHBoxLayout" name="layout2Dview">
+      <item>
+       <widget class="QSlider" name="sliderSelectSlice">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="MantidQt::MantidWidgets::MWView" name="slices2DPlot" native="true">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </item>
+    <item>
+     <widget class="QGroupBox" name="groupPlotSelectedSlice">
+      <property name="title">
+       <string>Plots Selected Slice</string>
+      </property>
+      <layout class="QHBoxLayout" name="horizontalLayout_3">
+       <item>
+        <widget class="MantidQt::MantidWidgets::PreviewPlot" name="previewPlotSelectedSlice" native="true">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="showLegend" stdset="0">
+          <bool>false</bool>
+         </property>
+         <property name="canvasColour" stdset="0">
+          <color>
+           <red>255</red>
+           <green>255</green>
+           <blue>255</blue>
+          </color>
+         </property>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+    </item>
+    <item>
+     <layout class="QHBoxLayout" name="layoutActionButtons">
+      <item>
+       <widget class="QPushButton" name="pushHelp">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>25</width>
+          <height>25</height>
+         </size>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>25</width>
+          <height>25</height>
+         </size>
+        </property>
+        <property name="toolTip">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Opens the help page for the interface.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
+        <property name="text">
+         <string>?</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <spacer name="sActionButtons">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item>
+       <widget class="QPushButton" name="pushLaunchBackgroundRemover">
+        <property name="toolTip">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Launch the background removal tool.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
+        <property name="text">
+         <string>Launch Background Remover</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </item>
+   </layout>
+  </widget>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>MantidQt::MantidWidgets::DataSelector</class>
+   <extends>QWidget</extends>
+   <header>MantidQtMantidWidgets/DataSelector.h</header>
+  </customwidget>
+  <customwidget>
+   <class>MantidQt::MantidWidgets::PreviewPlot</class>
+   <extends>QWidget</extends>
+   <header>MantidQtMantidWidgets/PreviewPlot.h</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>MantidQt::MantidWidgets::MWView</class>
+   <extends>QWidget</extends>
+   <header>MantidQtMantidWidgets/MWView.h</header>
+  </customwidget>
+ </customwidgets>
+ <tabstops>
+  <tabstop>spinboxSliceSelector</tabstop>
+  <tabstop>pushLaunchBackgroundRemover</tabstop>
+  <tabstop>pushHelp</tabstop>
+ </tabstops>
+ <resources/>
+ <connections/>
+</ui>

MantidQt/CustomInterfaces/src/DynamicPDF/BackgroundRemover.cpp

+#include "MantidQtCustomInterfaces/DynamicPDF/BackgroundRemover.h"
+#include "MantidQtCustomInterfaces/DynamicPDF/SliceSelector.h"
+
+namespace
+{
+  Mantid::Kernel::Logger g_log("DynamicPDF");
+}
+
+namespace MantidQt
+{
+namespace CustomInterfaces
+{
+namespace DynamicPDF
+{
+
+  BackgroundRemover::BackgroundRemover(SliceSelector *parent) : QDialog(parent) {
+    m_uiForm.setupUi(this);
+  }
+
+  void BackgroundRemover::refreshSlice(const boost::shared_ptr<WorkspaceRecord> loadedWorkspace,
+                              const size_t &workspaceIndex){
+    UNUSED_ARG(loadedWorkspace);
+    UNUSED_ARG(workspaceIndex);
+    std::cout << "hello world";
+  }
+
+}
+}
+}

MantidQt/CustomInterfaces/src/DynamicPDF/SliceSelector.cpp

+#include <iostream>
+#include <iomanip>
+// includes for workspace handling
+#include "MantidAPI/AnalysisDataService.h"
+#include "MantidAPI/MatrixWorkspace.h"
+// includes for interface
+#include "MantidQtAPI/HelpWindow.h"
+#include "MantidQtCustomInterfaces/DynamicPDF/SliceSelector.h"
+#include <qwt_plot_spectrogram.h>
+
+//#include "MantidQtCustomInterfaces/DynamicPDF/BackgroundRemover.h"
+
+namespace {
+Mantid::Kernel::Logger g_log("DynamicPDF");
+}
+
+namespace MantidQt {
+namespace CustomInterfaces {
+namespace DynamicPDF {
+
+WorkspaceRecord::WorkspaceRecord(const std::string &workspaceName)
+    : m_name{workspaceName} {
+  m_ws = Mantid::API::AnalysisDataService::Instance()
+             .retrieveWS<Mantid::API::MatrixWorkspace>(workspaceName);
+}
+
+void WorkspaceRecord::updateMetadata(const size_t &newIndex) {
+  m_energy = m_ws->getAxis(1)->getValue(newIndex);
+  std::stringstream energyLabelStream;
+  energyLabelStream << std::fixed;
+  energyLabelStream.precision(2);
+  energyLabelStream << "Energy = " << m_energy;
+  energyLabelStream << " meV";
+  m_label = energyLabelStream.str();
+}
+
+// Add this class to the list of specialised dialogs in this namespace
+DECLARE_SUBWINDOW(SliceSelector)
+
+/// Constructor
+// SliceSelector::SliceSelector(QWidget *parent) : UserSubWindow{parent},
+// m_loadedWorkspace{nullptr}, m_BackgroundRemover{nullptr} {
+SliceSelector::SliceSelector(QWidget *parent) :
+  UserSubWindow{parent},
+  m_loadedWorkspace() {
+
+}
+
+SliceSelector::~SliceSelector() { m_selectedWorkspaceIndex = 0; }
+
+/// Initialize the ui form and connect SIGNALS to SLOTS
+void SliceSelector::initLayout() {
+  m_uiForm.setupUi(this);
+  connect(m_uiForm.dataSelector, SIGNAL(dataReady(const QString &)), this,
+          SLOT(loadSlices(const QString &)));
+  connect(m_uiForm.pushHelp, SIGNAL(clicked()), this, SLOT(showHelp()));
+  connect(m_uiForm.spinboxSliceSelector, SIGNAL(valueChanged(int)), this,
+          SLOT(updateSelectedSlice(int)));
+  connect(m_uiForm.sliderSelectSlice, SIGNAL(valueChanged(int)), this,
+          SLOT(updateSelectedSlice(int)));
+  connect(m_uiForm.pushLaunchBackgroundRemover, SIGNAL(clicked()), this,
+          SLOT(launchBackgroundRemover()));
+}
+
+/// Load file or workspace containing energy slices
+void SliceSelector::loadSlices(const QString &workspaceName) {
+  m_loadedWorkspace =
+      boost::make_shared<WorkspaceRecord>(workspaceName.toStdString());
+  m_selectedWorkspaceIndex = 0;
+  m_loadedWorkspace->updateMetadata(m_selectedWorkspaceIndex);
+  int maximumWorkspaceIndex =
+      static_cast<int>(m_loadedWorkspace->m_ws->getNumberHistograms()) - 1;
+
+  /// initialize the label displaying the energy
+  m_uiForm.labelSliceEnergy->setText(
+      QString::fromStdString(m_loadedWorkspace->m_label));
+
+  /// initialize the spin box that selects the energy slice
+  m_uiForm.spinboxSliceSelector->setMinimum(0);
+  m_uiForm.spinboxSliceSelector->setMaximum(maximumWorkspaceIndex);
+  m_uiForm.spinboxSliceSelector->setValue(0);
+  m_uiForm.spinboxSliceSelector->setSingleStep(1);
+
+  /// initialize the slider next to the 2D view
+  m_uiForm.sliderSelectSlice->setMinimum(0);
+  m_uiForm.sliderSelectSlice->setMaximum(maximumWorkspaceIndex);
+  m_uiForm.spinboxSliceSelector->setValue(0);
+
+  /// initialize the 2D view of the slices;
+  m_uiForm.slices2DPlot->setWorkspace(m_loadedWorkspace->m_ws);
+  m_uiForm.slices2DPlot->updateDisplay();
+
+  /// initialize the preview plot
+  updatePlotSelectedSlice();
+}
+
+///
+void SliceSelector::updatePlotSelectedSlice() {
+  m_uiForm.previewPlotSelectedSlice->clear();
+  m_uiForm.previewPlotSelectedSlice->addSpectrum(
+      QString::fromStdString(m_loadedWorkspace->m_label),
+      m_loadedWorkspace->m_ws, m_selectedWorkspaceIndex);
+}
+
+/// Update all widgets in the form with the new selected index
+void SliceSelector::updateSelectedSlice(const int &newSelectedIndex) {
+  m_selectedWorkspaceIndex = static_cast<size_t>(newSelectedIndex);
+  /// Check  pointer m_loadedWorkspace because the user may attemp to manipulate
+  /// the widgets before (s)he loads any data
+  if (m_loadedWorkspace) {
+    m_loadedWorkspace->updateMetadata(m_selectedWorkspaceIndex);
+    m_uiForm.labelSliceEnergy->setText(
+        QString::fromStdString(m_loadedWorkspace->m_label));
+    m_uiForm.spinboxSliceSelector->setValue(newSelectedIndex);
+    m_uiForm.sliderSelectSlice->setValue(newSelectedIndex);
+    updatePlotSelectedSlice();
+  }
+}
+
+/// Initialize and/or update the dialog to remove the multiphonon background
+void SliceSelector::launchBackgroundRemover() {
+  /// parent of BackgroundRemover is this main window
+  // if (!m_BackgroundRemover){
+  //  m_BackgroundRemover = boost::make_shared<BackgroundRemover>(this);
+  //}
+  // m_BackgroundRemover->refreshSlice(m_loadedWorkspace,
+  // m_selectedWorkspaceIndex);
+  g_log.error("Not implemented...yet");
+}
+
+/// Opens the Qt help page for the interface
+void SliceSelector::showHelp() {
+  MantidQt::API::HelpWindow::showCustomInterface(
+      NULL, QString("Dynamic PDF Calculator"));
+}
+}
+}
+}

MantidQt/DesignerPlugins/inc/MantidQtDesignerPlugins/PluginCollectionInterface.h

@@ -16,6 +16,7 @@
 #include "MantidQtSliceViewer/SliceViewer.h"
 #include "MantidQtSliceViewer/LineViewer.h"
 #include "MantidQtMantidWidgets/SafeQwtPlot.h"
+#include "MantidQtMantidWidgets/MWView.h"
 #include "MantidQtAPI/AlgorithmPropertiesWidget.h"
 #include "MantidQtMantidWidgets/ProcessingAlgoWidget.h"
 #include "MantidQtMantidWidgets/MessageDisplay.h"
@@ -132,6 +133,10 @@ DECLARE_WIDGET_PLUGIN(SafeQwtPlotPlugin,
     MantidQt::MantidWidgets::SafeQwtPlot,
     "Version of QwtPlot with workspace-level thread safety");
 
+DECLARE_WIDGET_PLUGIN(MWViewPlugin,
+    MantidQt::MantidWidgets::MWView,
+    "2D view of a MatrixWorkspace");
+
 DECLARE_WIDGET_PLUGIN(AlgorithmPropertiesWidgetPlugin,
     MantidQt::API::AlgorithmPropertiesWidget,
     "List of algorithm properties");
@@ -147,5 +152,4 @@ DECLARE_WIDGET_PLUGIN(MessageDisplayPlugin,
 DECLARE_WIDGET_PLUGIN(DataSelectorPlugin,
     MantidQt::MantidWidgets::DataSelector,
     "Choose a file path or workspace to work with");
-
 #endif

MantidQt/DesignerPlugins/src/PluginCollectionInterface.cpp

@@ -21,6 +21,7 @@ PluginCollectionInterface::PluginCollectionInterface(QObject *parent) : QObject(
   m_widgets.append(new SliceViewerPlugin(this));
   m_widgets.append(new LineViewerPlugin(this));
   m_widgets.append(new SafeQwtPlotPlugin(this));
+  m_widgets.append(new MWViewPlugin(this));
   m_widgets.append(new AlgorithmPropertiesWidgetPlugin(this));
   m_widgets.append(new ProcessingAlgoWidgetPlugin(this));
   m_widgets.append(new DataSelectorPlugin(this));

MantidQt/MantidWidgets/CMakeLists.txt

@@ -4,6 +4,7 @@ set ( SRC_FILES
     src/CatalogSearch.cpp
     src/CatalogSelector.cpp
     src/CheckboxHeader.cpp
+    src/ColorBarWidget.cpp
     src/DataSelector.cpp
     src/DiagResults.cpp
     src/DoubleDialogEditor.cpp
@@ -23,6 +24,7 @@ set ( SRC_FILES
     src/MantidHelpWindow.cpp
     src/MWDiag.cpp
     src/MWRunFiles.cpp
+    src/MWView.cpp
     src/MessageDisplay.cpp
     src/MultifitSetupDialog.cpp
     src/MuonFitPropertyBrowser.cpp
@@ -101,6 +103,7 @@ set ( SRC_FILES
 set ( MOC_FILES 
     inc/MantidQtMantidWidgets/AlgorithmSelectorWidget.h
     inc/MantidQtMantidWidgets/CheckboxHeader.h
+    inc/MantidQtMantidWidgets/ColorBarWidget.h
     inc/MantidQtMantidWidgets/DataSelector.h
     inc/MantidQtMantidWidgets/DiagResults.h
     inc/MantidQtMantidWidgets/DoubleDialogEditor.h
@@ -125,6 +128,7 @@ set ( MOC_FILES
     inc/MantidQtMantidWidgets/MuonSequentialFitDialog.h
     inc/MantidQtMantidWidgets/MWDiag.h
     inc/MantidQtMantidWidgets/MWRunFiles.h
+    inc/MantidQtMantidWidgets/MWView.h
     inc/MantidQtMantidWidgets/PeakPicker.h
     inc/MantidQtMantidWidgets/PeriodicTableWidget.h
     inc/MantidQtMantidWidgets/pqHelpWindow.h
@@ -232,9 +236,11 @@ set ( UI_FILES
     inc/MantidQtMantidWidgets/DataSelector.ui
     inc/MantidQtMantidWidgets/CatalogSearch.ui
     inc/MantidQtMantidWidgets/CatalogSelector.ui
+    inc/MantidQtMantidWidgets/ColorBarWidget.ui
     inc/MantidQtMantidWidgets/IndirectInstrumentConfig.ui
     inc/MantidQtMantidWidgets/MWDiag.ui
     inc/MantidQtMantidWidgets/MWRunFiles.ui
+    inc/MantidQtMantidWidgets/MWView.ui
     inc/MantidQtMantidWidgets/MultifitSetupDialog.ui
     inc/MantidQtMantidWidgets/MuonSequentialFitDialog.ui
     inc/MantidQtMantidWidgets/ProcessingAlgoWidget.ui

MantidQt/MantidWidgets/inc/MantidQtMantidWidgets/ColorBarWidget.h

+#ifndef MANTID_MANTIDWIDGETS_COLORBARWIDGET_H_
+#define MANTID_MANTIDWIDGETS_COLORBARWIDGET_H_
+
+#include <QtGui/QWidget>
+#include "ui_ColorBarWidget.h"
+#include <qwt_color_map.h>
+#include <qwt_scale_widget.h>
+#include "MantidQtAPI/MantidColorMap.h"
+#include <QKeyEvent>
+#include <QtGui>
+#include "MantidQtMantidWidgets/WidgetDllOption.h"
+
+namespace MantidQt
+{
+namespace MantidWidgets
+{
+
+//=============================================================================
+/** Extended version of QwtScaleWidget */
+class QwtScaleWidgetExtended : public QwtScaleWidget
+{
+  Q_OBJECT
+
+public:
+  QwtScaleWidgetExtended(QWidget *parent = NULL)
+  : QwtScaleWidget(parent)
+  {
+    this->setMouseTracking(true);
+  }
+
+  void mouseMoveEvent(QMouseEvent * event)
+  {
+    double val = 1.0 - double(event->y()) / double(this->height());
+    emit mouseMoved(event->globalPos(), val);
+  }
+
+signals:
+  void mouseMoved(QPoint, double);
+
+};
+
+
+//=============================================================================
+/** Widget for showing a color bar, modifying its
+ * limits, etc.
+ *
+ * @author Janik Zikovsky
+ * @date Oct 31, 2011.
+ */
+class EXPORT_OPT_MANTIDQT_MANTIDWIDGETS ColorBarWidget : public QWidget
+{
+  Q_OBJECT
+  Q_PROPERTY(double minimum READ getMinimum WRITE setMinimum)
+  Q_PROPERTY(double maximum READ getMaximum WRITE setMaximum)
+
+public:
+  ColorBarWidget(QWidget *parent = 0);
+  ~ColorBarWidget();
+
+  void updateColorMap();
+
+  void setViewRange(double min, double max);
+  void setViewRange(QwtDoubleInterval range);
+  void setMinimum(double min);
+  void setMaximum(double max);
+  void setRenderMode(bool rendering);
+
+  double getMinimum() const;
+  double getMaximum() const;
+  QwtDoubleInterval getViewRange() const;
+  MantidColorMap & getColorMap();
+
+  bool getLog();
+
+  int getScale();
+  void setScale(int);
+
+  void setExponent(double);
+  double getExponent();
+
+  void setAutoScale(bool autoscale);
+  bool getAutoScale() const;
+
+public slots:
+  void changedMinimum();
+  void changedMaximum();
+  void colorBarMouseMoved(QPoint, double);
+  void changedScaleType(int);
+  void changedExponent(double);
+
+signals:
+  /// Signal sent when the range or log mode of the color scale changes.
+  void changedColorRange(double min, double max, bool log);
+  /// When the user double-clicks the color bar (e.g. load a new color map)
+  void colorBarDoubleClicked();
+
+private:
+  void setSpinBoxesSteps();
+  void mouseDoubleClickEvent(QMouseEvent * event);
+  void updateMinMaxGUI();
+  void resizeEvent(QResizeEvent * event);
+
+  /// Auto-gen UI classes
+  Ui::ColorBarWidgetClass ui;
+
+  /// The color bar widget from QWT
+  QwtScaleWidget * m_colorBar;
+
+  /// Color map being displayed
+  MantidColorMap m_colorMap;
+
+  /// Logarithmic scale?
+  bool m_log;
+
+  /// Min value being displayed
+  double m_min;
+
+  /// Min value being displayed
+  double m_max;
+
+  /// Show the value tooltip (off by default)
+  bool m_showTooltip;
+};
+
+} // namespace MantidWidgets
+} // namespace Mantid
+
+#endif // MANTID_MANTIDWIDGETS_COLORBARWIDGET_H_

MantidQt/MantidWidgets/inc/MantidQtMantidWidgets/ColorBarWidget.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ColorBarWidgetClass</class>
+ <widget class="QWidget" name="ColorBarWidgetClass">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>184</width>
+    <height>306</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>ColorBarWidget</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_2">
+   <property name="spacing">
+    <number>0</number>
+   </property>
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
+    <number>0</number>
+   </property>
+   <item>
+    <layout class="QVBoxLayout" name="verticalLayout">
+     <property name="spacing">
+      <number>3</number>
+     </property>
+     <item>
+      <widget class="QComboBox" name="cmbScaleType"/>
+     </item>
+     <item>
+      <layout class="QHBoxLayout" name="horizontalLayout">
+       <item>
+        <widget class="QLabel" name="lblN">
+         <property name="text">
+          <string>n =</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QDoubleSpinBox" name="dspnN"/>
+       </item>
+      </layout>
+     </item>
+     <item>
+      <widget class="MantidQt::API::QScienceSpinBox" name="valMax">
+       <property name="toolTip">
+        <string>Maximum value in the color scale</string>
+       </property>
+       <property name="wrapping">
+        <bool>false</bool>
+       </property>
+       <property name="buttonSymbols">
+        <enum>QAbstractSpinBox::UpDownArrows</enum>
+       </property>
+       <property name="accelerated">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="MantidQt::API::QScienceSpinBox" name="valMin">
+       <property name="toolTip">
+        <string>Minimum value in the color scale</string>
+       </property>
+       <property name="accelerated">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QCheckBox" name="autoScaleForCurrentSlice">
+       <property name="toolTip">
+        <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When this is checked the color scale range will be automatically set to the current slice whenever the user zooms to a new peak, pans through the view or changes the slice with the slider control&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+       </property>
+       <property name="text">
+        <string>Autoscale to current slice</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QCheckBox" name="autoScale">
+       <property name="toolTip">
+        <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;This flag signals that the color scale range should be set automatically to the current slice range when a workspace is loaded. Note that auto scaling will be applied when a workspace is loaded for the very first time. This option is mainly relevant for live data workspaces, which are continuously being updated and reloaded.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+       </property>
+       <property name="text">
+        <string>Autoscale on load</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <customwidgets>
+  <customwidget>
+   <class>MantidQt::API::QScienceSpinBox</class>
+   <extends>QDoubleSpinBox</extends>
+   <header>MantidQtAPI/QScienceSpinBox.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

MantidQt/MantidWidgets/inc/MantidQtMantidWidgets/MWView.h

+#ifndef MANTID_MANTIDWIDGETS_MWVIEW_H_
+#define MANTID_MANTIDWIDGETS_MWVIEW_H_
+
+// includes for interface development
+#include <QWidget>
+#include <qwt_plot_spectrogram.h>
+#include "ui_MWView.h"
+#include "MantidQtAPI/MdSettings.h"
+#include "MantidQtMantidWidgets/WidgetDllOption.h"
+// includes for workspace handling
+#include "MantidAPI/MatrixWorkspace_fwd.h"
+#include "MantidAPI/IMDWorkspace.h"
+#include "MantidGeometry/MDGeometry/MDHistoDimension.h"
+
+namespace Mantid {
+namespace API {
+class MWDimension;
+}
+}
+
+namespace MantidQt {
+
+namespace API {
+class QwtRasterDataMD;
+class MdSettings;
+}
+
+namespace MantidWidgets {
+class ColorBarWidget;
+
+using MWDimension_sptr = boost::shared_ptr<Mantid::API::MWDimension>;
+using MWDimension_const_sptr =
+    boost::shared_ptr<const Mantid::API::MWDimension>;
+
+/** A viewer for a Matrix Workspace.
+ *
+ * Before drawing, it acquires a ReadLock to prevent
+ * an algorithm from modifying the underlying workspace while it is
+ * drawing.
+ *
+ * If no workspace is set, no drawing occurs (silently).
+
+  @date 2016-02-05
+
+  Copyright &copy; 2012 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
+ National Laboratory & European Spallation Source
+
+  This file is part of Mantid.
+
+  Mantid is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 3 of the License, or
+  (at your option) any later version.
+
+  Mantid is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+  File change history is stored at: <https://github.com/mantidproject/mantid>
+  Code Documentation is available at: <http://doxygen.mantidproject.org>
+*/
+class EXPORT_OPT_MANTIDQT_MANTIDWIDGETS MWView : public QWidget {
+  Q_OBJECT
+
+public:
+  MWView(QWidget *parent = 0);
+  ~MWView();
+  void loadColorMap(QString filename = QString());
+  void setWorkspace(Mantid::API::MatrixWorkspace_sptr ws);
+  void updateDisplay();
+
+signals:
+  /// Signal emitted when someone uses setWorkspace() on MWView
+  void workspaceChanged();
+
+public slots:
+  void colorRangeChangedSlot();
+  void loadColorMapSlot();
+  void setTransparentZerosSlot(bool transparent);
+
+private:
+  void initLayout();
+  void loadSettings();
+  void saveSettings();
+  void checkRangeLimits();
+  void findRangeFull();
+  void setVectorDimensions();
+
+  Ui::MWView m_uiForm;
+  /// Spectrogram plot of MWView
+  QwtPlotSpectrogram *m_spect;
+  /// Data presenter
+  API::QwtRasterDataMD *m_data;
+  /// File of the last loaded color map.
+  QString m_currentColorMapFile;
+  /// Md Settings for color maps
+  boost::shared_ptr<MantidQt::API::MdSettings> m_mdSettings;
+  /// Workspace being shown
+  Mantid::API::MatrixWorkspace_sptr m_workspace;
+  /// The calculated range of values in the FULL data set
+  QwtDoubleInterval m_colorRangeFull;
+  Mantid::API::MDNormalization m_normalization;
+  /// Vector of the dimensions to show.
+  std::vector<Mantid::Geometry::MDHistoDimension_sptr> m_dimensions;
+};
+
+} // namespace MantidWidgets
+} // namespace MantidQt
+
+#endif /* MANTID_MANTIDWIDGETS_MWVIEW_H_ */

MantidQt/MantidWidgets/inc/MantidQtMantidWidgets/MWView.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MWView</class>
+ <widget class="QWidget" name="MWView">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>706</width>
+    <height>462</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <widget class="QWidget" name="horizontalLayoutWidget">
+   <property name="geometry">
+    <rect>
+     <x>19</x>
+     <y>19</y>
+     <width>681</width>
+     <height>441</height>
+    </rect>
+   </property>
+   <layout class="QHBoxLayout" name="viewer">
+    <item>
+     <widget class="MantidQt::MantidWidgets::SafeQwtPlot" name="plot2D">
+      <property name="sizePolicy">
+       <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+        <horstretch>0</horstretch>
+        <verstretch>0</verstretch>
+       </sizepolicy>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <widget class="MantidQt::MantidWidgets::ColorBarWidget" name="colorBar" native="true">
+      <property name="sizePolicy">
+       <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+        <horstretch>0</horstretch>
+        <verstretch>0</verstretch>
+       </sizepolicy>
+      </property>
+     </widget>
+    </item>
+   </layout>
+  </widget>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QwtPlot</class>
+   <extends>QFrame</extends>
+   <header>qwt_plot.h</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>MantidQt::MantidWidgets::SafeQwtPlot</class>
+   <extends>QwtPlot</extends>
+   <header>MantidQtMantidWidgets/SafeQwtPlot.h</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>MantidQt::MantidWidgets::ColorBarWidget</class>
+   <extends>QWidget</extends>
+   <header>MantidQtMantidWidgets/ColorBarWidget.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

MantidQt/MantidWidgets/src/ColorBarWidget.cpp

+#include "MantidQtAPI/MantidColorMap.h"
+#include "MantidQtMantidWidgets/ColorBarWidget.h"
+#include "MantidQtAPI/QScienceSpinBox.h"
+#include "qwt_scale_div.h"
+#include "MantidQtAPI/PowerScaleEngine.h"
+#include <iosfwd>
+#include <qwt_scale_map.h>
+#include <qwt_scale_widget.h>
+#include <QKeyEvent>
+#include <qwt_plot.h>
+#include <qwt_scale_engine.h>
+
+namespace MantidQt
+{
+namespace MantidWidgets
+{
+
+//-------------------------------------------------------------------------------------------------
+/** Constructor */
+ColorBarWidget::ColorBarWidget(QWidget *parent)
+: QWidget(parent)
+{
+  ui.setupUi(this);
+
+  // Default values.
+  m_min = 0;
+  m_max = 1000;
+  m_showTooltip = false;
+  m_log = false;
+
+  // Scales
+  ui.cmbScaleType->addItem(tr("linear"));
+  ui.cmbScaleType->addItem(tr("logarithmic"));
+  ui.cmbScaleType->addItem(tr("power"));
+  m_colorMap.changeScaleType( GraphOptions::Linear );
+  ui.dspnN->setMinimum(-100.0);
+  ui.dspnN->setEnabled(false);
+
+  // Create and add the color bar
+  m_colorBar = new QwtScaleWidgetExtended();
+  m_colorBar->setToolTip("");
+  m_colorBar->setColorBarEnabled(true);
+  m_colorBar->setColorBarWidth(20);
+  m_colorBar->setAlignment(QwtScaleDraw::RightScale);
+  m_colorBar->setLabelAlignment( Qt::AlignRight | Qt::AlignVCenter);
+  //m_colorBar->setCursor(Qt::OpenHandCursor);
+  ui.verticalLayout->insertWidget(2,m_colorBar, 1,0 );
+
+  // Hook up signals
+  QObject::connect(ui.dspnN, SIGNAL(valueChanged(double)), this, SLOT(changedExponent(double)));
+  QObject::connect(ui.cmbScaleType,SIGNAL(currentIndexChanged(int)), this, SLOT(changedScaleType(int)));
+  QObject::connect(ui.valMin, SIGNAL(editingFinished()), this, SLOT(changedMinimum()));
+  QObject::connect(ui.valMax, SIGNAL(editingFinished()), this, SLOT(changedMaximum()));
+  QObject::connect(ui.valMin, SIGNAL(valueChangedFromArrows()), this, SLOT(changedMinimum()));
+  QObject::connect(ui.valMax, SIGNAL(valueChangedFromArrows()), this, SLOT(changedMaximum()));
+  QObject::connect(m_colorBar, SIGNAL(mouseMoved(QPoint, double)), this, SLOT(colorBarMouseMoved(QPoint, double)));
+
+  // Initial view
+  this->updateColorMap();
+}
+
+
+//-------------------------------------------------------------------------------------------------
+/// @return the minimum value of the min of the color scale
+double ColorBarWidget::getMinimum() const
+{ return m_min; }
+
+/// @return the maximum value of the max of the color scale
+double ColorBarWidget::getMaximum() const
+{ return m_max; }
+
+/// @return then min/max range currently viewed
+QwtDoubleInterval ColorBarWidget::getViewRange() const
+{ return QwtDoubleInterval(m_min, m_max); }
+
+/// @return the color map in use (ref)
+MantidColorMap & ColorBarWidget::getColorMap()
+{ return m_colorMap;
+}
+
+//-------------------------------------------------------------------------------------------------
+/** Turn "rendering mode" on/off, where GUI widgets are hidden
+ * for the purposes of rendering an image.
+ *
+ * @param rendering :: true if you are going to render
+ */
+void ColorBarWidget::setRenderMode(bool rendering)
+{
+  bool visible = !rendering;
+  this->ui.valMin->setVisible(visible);
+  this->ui.valMax->setVisible(visible);
+  this->ui.cmbScaleType->setVisible(visible);
+  this->ui.lblN->setVisible(visible);
+  this->ui.dspnN->setVisible(visible);
+}
+
+// Get the current colorbar scaling type
+int ColorBarWidget::getScale()
+{
+  // Get value from GUI
+  return ui.cmbScaleType->currentIndex();
+}
+
+// Set the current colorbar scaling type
+void ColorBarWidget::setScale(int type)
+{
+  // Set scale in GUI
+  ui.cmbScaleType->setCurrentIndex(type);
+  // Update plot
+  changedScaleType(type);
+}
+
+bool ColorBarWidget::getLog()
+{
+  if (getScale() == 1)
+  {
+    return true;
+  }
+  else return false;
+}
+
+// Set exponent value for power scale
+void ColorBarWidget::setExponent(double nth_power)
+{
+  // Set value in GUI
+  ui.dspnN->setValue(nth_power);
+  // Update plot
+  changedExponent(nth_power);
+}
+
+// Get exponent value for power scale
+double ColorBarWidget::getExponent()
+{
+  // Get value from GUI
+  return ui.dspnN->value();
+}
+
+// Change the colormap to match new exponent value
+void ColorBarWidget::changedExponent(double nth_power)
+{
+  m_colorMap.setNthPower(nth_power);
+  updateColorMap();
+
+  emit changedColorRange(m_min,m_max,m_log);
+}
+
+//-------------------------------------------------------------------------------------------------
+/** Send a double-clicked event but only when clicking the color bar */
+void ColorBarWidget::mouseDoubleClickEvent(QMouseEvent * event)
+{
+  if (m_colorBar->rect().contains(event->x(), event->y()))
+    emit colorBarDoubleClicked();
+}
+
+//-------------------------------------------------------------------------------------------------
+/// Event called after resizing
+void ColorBarWidget::resizeEvent(QResizeEvent * event)
+{
+  updateColorMap();
+  QWidget::resizeEvent(event);
+}
+
+
+//-------------------------------------------------------------------------------------------------
+/** Adjust the steps of the spin boxes for log/linear mode */
+void ColorBarWidget::setSpinBoxesSteps()
+{
+  // Large maximum value
+  ui.valMin->setMaximum( +1e100 );
+  ui.valMax->setMaximum( +1e100 );
+
+  double step = 1.1;
+  if (m_log)
+  {
+    // Logarithmic color scale: move by logarithmic steps
+    double logRange;
+    double temp_min = m_min;
+    if (temp_min <= 0)
+    {
+      // Try to guess at a valid min range if 0 for log scale
+      logRange = log10(m_max);
+      if (logRange >= 3) temp_min = 1;
+      else if (logRange >= 0) temp_min = 1e-3;
+      // Default to 1/10000 of the max
+      else temp_min = pow(10., double(int(logRange))-4.);
+    }
+    logRange = log10(m_max) - log10(temp_min);
+    if (logRange > 6) logRange = 6;
+    step = pow(10., logRange/100.);
+
+    // Small positive value for the minimum
+    ui.valMin->setMinimum( 1e-99 );
+    ui.valMax->setMinimum( 1e-99 );
+    // Limit the current min/max to positive values
+    if (m_min < temp_min) m_min = temp_min;
+    if (m_max < temp_min) m_max = temp_min;
+  }
+  else
+  {
+    // --- Linear scale ----
+    // Round step that is between 1/100 to 1/1000)
+    int exponent = int(log10(m_max)) - 2;
+    step = pow(10., double(exponent));
+
+    // Large negative value for the minimum
+    ui.valMin->setMinimum( -1e100 );
+    ui.valMax->setMinimum( -1e100 );
+  }
+
+  ui.valMin->setSingleStep(step);
+  ui.valMax->setSingleStep(step);
+  int dec = 2;
+  ui.valMin->setDecimals(dec);
+  ui.valMax->setDecimals(dec);
+
+  updateMinMaxGUI();
+}
+
+
+//-------------------------------------------------------------------------------------------------
+/** Set the range of values viewed in the color bar
+ *
+ * @param min :: min value = start of the color map
+ * @param max :: max value = end of the color map
+ */
+void ColorBarWidget::setViewRange(double min, double max)
+{
+  m_min = min;
+  m_max = max;
+  updateMinMaxGUI();
+}
+
+/** Set the range of values viewed in the color bar
+ *
+ * @param min :: min value = start of the color map
+ */
+void ColorBarWidget::setMinimum(double min)
+{
+  m_min = min;
+  updateMinMaxGUI();
+}
+
+/** Set the range of values viewed in the color bar
+ *
+ * @param max :: max value = start of the color map
+ */
+void ColorBarWidget::setMaximum(double max)
+{
+  m_max = max;
+ updateMinMaxGUI();
+}
+
+void ColorBarWidget::setViewRange(QwtDoubleInterval range)
+{ this->setViewRange(range.minValue(), range.maxValue()); }
+
+//-------------------------------------------------------------------------------------------------
+/*
+ * Update display if different scale type is selected
+ */
+void ColorBarWidget::changedScaleType(int type)
+{
+  // If power scale option is selected, enable "n =" widget
+  ui.dspnN->setEnabled(type == 2);
+
+  // Record if log scale option is selected
+  m_log = (type == 1);
+
+  m_colorMap.changeScaleType( GraphOptions::ScaleType(type) );
+  ui.valMin->setLogSteps( m_log );
+  ui.valMax->setLogSteps( m_log );
+  setSpinBoxesSteps();
+  updateColorMap();
+
+  emit changedColorRange(m_min,m_max,m_log);
+}
+
+//-------------------------------------------------------------------------------------------------
+/** SLOT called when minValue changes */
+void ColorBarWidget::changedMinimum()
+{
+  m_min = ui.valMin->value();
+  if (m_min > m_max)
+  {
+    m_max = m_min+0.001;
+    ui.valMax->setValue( m_max );
+  }
+  updateColorMap();
+  emit changedColorRange(m_min,m_max,m_log);
+}
+
+//-------------------------------------------------------------------------------------------------
+/** SLOT called when maxValue changes */
+void ColorBarWidget::changedMaximum()
+{
+  m_max = ui.valMax->value();
+  if (m_max < m_min)
+  {
+    m_min = m_max-0.001;
+    ui.valMin->setValue( m_min );
+  }
+  updateColorMap();
+  emit changedColorRange(m_min,m_max,m_log);
+}
+
+//-------------------------------------------------------------------------------------------------
+/** SLOT called when the mouse moves over the color bar*/
+void ColorBarWidget::colorBarMouseMoved(QPoint globalPos, double fraction)
+{
+  if (m_showTooltip)
+  {
+    double val = 0;
+    if (m_log)
+      val = pow(10., fraction * (log10(m_max)-log10(m_min)) + log10(m_min));
+    else
+      val = fraction * (m_max-m_min) + m_min;
+    QString tooltip = QString::number(val,'g', 4);
+    QToolTip::showText(globalPos, tooltip, m_colorBar);
+  }
+}
+
+
+//-------------------------------------------------------------------------------------------------
+/** Update the widget when the color map is changed */
+void ColorBarWidget::updateColorMap()
+{
+  // The color bar always shows the same range. Doesn't matter since the ticks don't show up
+  QwtDoubleInterval range(1.0, 100.0);
+  m_colorBar->setColorBarEnabled(true);
+  m_colorBar->setColorMap( range, m_colorMap);
+  m_colorBar->setColorBarWidth(15);
+  m_colorBar->setEnabled(true);
+
+  // Try to limit the number of steps based on the height of the color bar
+  int maxMajorSteps = m_colorBar->height()/15; // 15 pixels per div looked about right
+  //std::cout << "maxMajorSteps" << maxMajorSteps << std::endl;
+  if (maxMajorSteps > 10) maxMajorSteps = 10;
+
+  // Show the scale on the right
+  double minValue = m_min;
+  double maxValue = m_max;
+  GraphOptions::ScaleType type = m_colorMap.getScaleType();
+  if( type == GraphOptions::Linear )
+  {
+    QwtLinearScaleEngine linScaler;
+    m_colorBar->setScaleDiv(linScaler.transformation(), linScaler.divideScale(minValue, maxValue, maxMajorSteps, 5));
+    m_colorBar->setColorMap(QwtDoubleInterval(minValue, maxValue),m_colorMap);
+  }
+  else if ( type == GraphOptions::Power ) {
+    PowerScaleEngine powScaler;
+    m_colorBar->setScaleDiv(powScaler.transformation(), powScaler.divideScale(minValue, maxValue, maxMajorSteps, 5));
+    m_colorBar->setColorMap(QwtDoubleInterval(minValue, maxValue), m_colorMap);
+  }
+  else
+ {
+    QwtLog10ScaleEngine logScaler;
+    m_colorBar->setScaleDiv(logScaler.transformation(), logScaler.divideScale(minValue, maxValue, maxMajorSteps, 5));
+    m_colorBar->setColorMap(QwtDoubleInterval(minValue, maxValue), m_colorMap);
+  }
+
+}
+
+//-------------------------------------------------------------------------------------------------
+/** Updatet the widget when changing min/max*/
+void ColorBarWidget::updateMinMaxGUI()
+{
+  ui.valMin->setValue( m_min );
+  ui.valMax->setValue( m_max );
+}
+
+/**
+ * Sets the state of the "Autoscale" checkbox
+ * @param autoscale :: [input] Autoscale on/off
+ */
+void ColorBarWidget::setAutoScale(bool autoscale) {
+  ui.autoScale->setChecked(autoscale);
+  updateColorMap();
+}
+
+/**
+ * Gets the state of the "Autoscale" checkbox
+ * @returns Whether the box is checked or not
+ */
+bool ColorBarWidget::getAutoScale() const { return ui.autoScale->isChecked(); }
+
+ColorBarWidget::~ColorBarWidget()
+{
+}
+
+} // namespace MantidQt
+} // namespace MantidWidgets