Inspector.cxx

Go to the documentation of this file.

#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "Inspector.h"

#include "CanvasSelectionEvent.h"
#include "CanvasWindow.h"
#include "ComboBox.h"
#include "PlotterEvent.h"
#include "WindowController.h"
#include "AxisWidget.h"
#include "QtFont.h"
#include "NewModelDialog.h"
#include "EditModelDialog.h"


#include <qapplication.h>

#if QT_VERSION < 0x040000
#include "qlistview.h"
#include "qbuttongroup.h"
#include "qgroupbox.h"
#include "qwidgetstack.h"
#else
#include <QCustomEvent>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include "q3button.h"
#include "q3listview.h"
#include "q3buttongroup.h"
#include "q3groupbox.h"
#include "q3widgetstack.h"
#endif

#include "qcheckbox.h"
#include "qcolordialog.h"
#include "qabstractlayout.h"
#include "qlineedit.h"
#include "qmessagebox.h"
#include "qpushbutton.h"
#include "qradiobutton.h"
#include "qslider.h"
#include "qlabel.h"
#include "qinputdialog.h"
#include "qfontdialog.h"
#include "qtabwidget.h"
#include "qsettings.h"
#include "qstringlist.h"
#include "qtextstream.h"


#include "controllers/CutController.h"
#include "controllers/DataRepController.h"
#include "controllers/DisplayController.h"
#include "controllers/FunctionController.h"

#include "datareps/FunctionRep.h"

#include "datasrcs/DataSourceController.h"
#include "datasrcs/DataSourceException.h"
#include "datasrcs/NTuple.h"
#include "datasrcs/TupleCut.h"

#include "functions/FunctionFactory.h"

#include "plotters/CutPlotter.h"
#include "plotters/TextPlotter.h"

#include "projectors/FunctionProjector.h"
#include "projectors/NTupleProjector.h"

#include "reps/ContourPointRep.h"
#include "transforms/PeriodicBinaryTransform.h"

#ifdef HAVE_ROOT
#include "root/RootController.h"
#include "boost/tokenizer.hpp"
#include "boost/lexical_cast.hpp"
#endif

// #include <algorithm>
// #include <functional>
#include <sstream>
#include <stdexcept>

#include <cmath>
#include <cassert>

using namespace hippodraw;

using std::map;
using std::string;
using std::vector;


QString    Inspector::s_app_key ( "/HippoDraw/" );
QString    Inspector::s_registry ( "/Trolltech" );


#if QT_VERSION < 0x040000

Inspector::
Inspector ( QWidget * parent, const char * name, bool modal, Qt::WFlags flags )
  : InspectorBase ( parent, name, modal, flags ),
    m_plotter ( 0 )
{
#else
Inspector::
  Inspector ( QWidget * parent )
  : QDialog ( parent ),
    m_plotter ( 0 )
{
  setupUi ( this );
#endif
  init ();

  FunctionController * controller = FunctionController::instance();
  const vector < string > & names = controller -> getFitterNames ();

    for ( unsigned int i = 0; i < names.size(); i++ ) {
#if defined(QT_NO_STL) || QT_VERSION < 0x030100
    QString name ( names[i].c_str() );
#else
    QString name ( names[i] );
#endif
    m_fitter_names -> insertItem ( name );
  }

  connect ( axisWidget1, SIGNAL ( lowTextReturnPressed() ),
            this, SLOT ( setLowText() ) );

  connect ( axisWidget2, SIGNAL ( lowTextReturnPressed() ),
            this, SLOT ( cutText_returnPressed() ) );

  connect ( axisWidget1, SIGNAL ( highTextReturnPressed() ),
            this, SLOT ( setHighText() ) );

  connect ( axisWidget2, SIGNAL ( highTextReturnPressed() ),
            this, SLOT ( cutText_returnPressed() ) );

  connect ( axisWidget1, SIGNAL ( lowSliderReleased() ),
            this, SLOT ( lowRangeDrag() ) );

  connect ( axisWidget2, SIGNAL ( lowSliderReleased() ),
            this, SLOT ( cutLowSlider_sliderReleased() ) );

  connect ( axisWidget1, SIGNAL ( lowSliderPressed() ),
            this, SLOT ( setDragOn() ) );

  connect ( axisWidget1, SIGNAL ( highSliderPressed() ),
            this, SLOT ( setDragOn() ) );

  connect ( axisWidget1, SIGNAL ( lowSliderValueChanged ( int ) ),
            this, SLOT ( setLowRange ( int ) ) );

  connect ( axisWidget2, SIGNAL ( lowSliderValueChanged ( int ) ),
            this, SLOT ( cutLowSlider_sliderMoved ( int ) ) );

  connect ( axisWidget1, SIGNAL ( highSliderReleased() ),
            this, SLOT ( highRangeDrag() ) );

  connect ( axisWidget2, SIGNAL ( highSliderReleased() ),
            this, SLOT ( cutHighSlider_sliderReleased() ) );

  connect ( axisWidget1, SIGNAL ( highSliderValueChanged ( int ) ),
            this, SLOT ( setHighRange ( int ) ) );

  connect ( axisWidget2, SIGNAL ( highSliderValueChanged ( int ) ),
            this, SLOT ( cutHighSlider_sliderMoved ( int ) ) );

  connect ( axisWidget1, SIGNAL ( zoomPanCheckBoxClicked () ),
            this, SLOT ( axisZoomPanCheckBox_clicked () ) );

  connect ( axisWidget2, SIGNAL ( zoomPanCheckBoxClicked () ),
            this, SLOT ( cutZoomPanCheckBox_clicked () ) );

  axisWidget2 -> setCut ( true );
  // Default position of the sliders is center which corrosponds to
  // a value of 50. So initialization takes place as 50.
  m_lowslider1_last_val  = 50;
  m_highslider1_last_val = 50;

  updatePlotTypes ();
}

Inspector::
~Inspector ()
{
}

void
Inspector::
init()
{
  m_new_labels.reserve ( 4 );
  m_new_labels.push_back ( new_binding_0 );
  m_new_labels.push_back ( new_binding_1 );
  m_new_labels.push_back ( new_binding_2 );
  m_new_labels.push_back ( new_binding_3 );

  m_new_combos.reserve ( 4 );
  m_new_combos.push_back ( new_combo_0 );
  m_new_combos.push_back ( new_combo_1 );
  m_new_combos.push_back ( new_combo_2 );
  m_new_combos.push_back ( new_combo_3 );

  m_sel_labels.reserve ( 4 );
  m_sel_labels.push_back ( sel_binding_0 );
  m_sel_labels.push_back ( sel_binding_1 );
  m_sel_labels.push_back ( sel_binding_2 );
  m_sel_labels.push_back ( sel_binding_3 );

  m_sel_combos.reserve ( 4 );
  m_sel_combos.push_back ( sel_combo_0 );
  m_sel_combos.push_back ( sel_combo_1 );
  m_sel_combos.push_back ( sel_combo_2 );
  m_sel_combos.push_back ( sel_combo_3 );

  QSize cur_size = size();
  setFixedSize ( cur_size );

  m_dragging = false;
  m_axis = Axes::X;
  m_layoutWidget = new QWidget( currentPlot, "m_Layout" );
  m_layoutWidget->setGeometry( QRect ( 7, 75, 360, 0 ) );
  m_vLayout = new QVBoxLayout( m_layoutWidget, 0, 6, "m_vLayout");

  newPlotButton->setEnabled( false );

  m_newLayoutWidget = new QWidget ( m_new_plot_box, "m_newLayout" );
  m_newLayoutWidget->setGeometry( QRect ( 7, 75, 360, 0 ) );
  m_newVLayout = new QVBoxLayout( m_newLayoutWidget, 0, 6,
                                  "m_newVLayout");

  DisplayController * controller = DisplayController::instance ();
  const vector < string > & names = controller -> getValueTransformTypes ();
  m_value_combo -> clear ();
  unsigned int size = names.size ();
  for ( unsigned int i = 0; i < size; i++ ) {
    m_value_combo -> insertItem ( names[i].c_str() );
  }

  loadAllUsrModels();
  for ( unsigned int i = size; i < size + usr_models.size (); i++ ) {
    m_value_combo -> insertItem ( usr_models[ i - size ].c_str() );
  }


  m_interval_le->setDisabled ( true );

  // Add fixed sized column headers to the function params group box
  // This we could not do using the designer.
  m_FunctionParamsListView -> addColumn( QString( "Sl." ),    3 );
  m_FunctionParamsListView -> addColumn( QString( "Params" ),40 );
  m_FunctionParamsListView -> addColumn( QString( "Fixed"  ), 3 );
  m_FunctionParamsListView -> addColumn( QString( "Value" ), 40 );
  m_FunctionParamsListView -> addColumn( QString( "Error" ), 40 );

}
void
Inspector::
enableNewPlotBox ( bool yes )
{
  m_new_plot_box->setEnabled ( yes );
  m_summary->setEnabled ( yes );
}

void Inspector::customEvent ( QCustomEvent * event )
{
  PlotterEvent * pev = dynamic_cast < PlotterEvent * > ( event );
  if ( pev != 0 ) {
    m_plotter = pev -> plotter ();
    update ();
  }

  CanvasSelectionEvent * ev
    = dynamic_cast < CanvasSelectionEvent * > ( event );
  if ( ev != 0  ) {
    m_plotter_list = ev -> getPlotters ();
    if ( m_plotter_list.size () == 1 ) {
      m_plotter = m_plotter_list.front ();
    }
    else {
      m_plotter = 0;
    }
    update ();
  }
}

PlotterBase *
Inspector::
getPlotter ()
{
  return m_plotter;
}

void
Inspector::
setZRadioButton ( bool enabled )
{

  if (!enabled && m_axis == Axes::Z )
    {
      QButton * b = axis_button_group -> find ( 0 );
      QRadioButton * button = dynamic_cast< QRadioButton * > ( b );
      button -> setChecked ( true );
      m_axis = Axes::X;
      updateAxisTab ();
    }

  QButton * button = axis_button_group -> find ( 2 );
  button -> setEnabled ( enabled );
}

void
Inspector::
tabChanged ()
{
  update ();
}

void
Inspector::
update ()
{
  if ( isHidden() == true ) return;
  m_is_updating = true;
  int index = m_plot_tab -> currentPageIndex ();

  switch ( index )
    {
    case ( 0 ) :
      updateDataTab();
      break;
    case ( 1 ) :
      updatePlotTab();
      break;
    case ( 2 ) :
      updateAxisTab();
      break;
    case ( 3 ) :
      updateCutsTab();
      break;
    case ( 4 ) :
      updateFunctionsTab();
      break;
    case ( 5 ) :
      updateSummaryTab ();
      break;
    default :
      assert ( false );
      break;
    }

  if ( m_plotter != 0 ) {
    bool hasZ = m_plotter -> hasAxis ( Axes::Z );
    setZRadioButton ( hasZ );
  }

  m_is_updating = false;
  updateCutsActive ();
}

void
Inspector::
updateCutsActive ()
{
  PlotterBase * plotter = getPlotter ();
  bool yes = plotter != 0;
  if ( yes ) yes = plotter -> isTargetable ();
  if ( yes == false ) {
    setAllCutsActive ( true );
    return;
  }
  vector < PlotterBase * > cutlist;
  fillCutsOn ( plotter, cutlist );

  if ( cutlist.empty () ) {
    setAllCutsActive ( true );
    return;
  }
  else {
    setAllCutsActive ( false );
    vector < PlotterBase * >::iterator first = cutlist.begin();
    while ( first != cutlist.end () ) {
      PlotterBase * pb = *first++;
      CutPlotter * cutter = dynamic_cast < CutPlotter * > ( pb );
      assert ( cutter );
      cutter -> setActive ( true );
    }
  }
}

std::string
Inspector::
getSelectedDataSourceName () const
{
  const vector < string > & names
    = DataSourceController::instance () -> getNTupleNames ();
  int index = m_all_ntuples -> currentItem ();

  return names [ index ];
}

void
Inspector::
updateNewPlotControls ()
{
  const vector < string > & nt_vector
    = DataSourceController::instance() -> getNTupleNames ();
  if ( nt_vector.empty () ) {
    m_all_ntuples -> clear ();
    return;
  }

  unsigned int count = m_all_ntuples -> count ();
  if ( count == nt_vector.size () ) return;

#ifdef ITERATOR_MEMBER_DEFECT
  //std::
#endif

  m_all_ntuples -> clear();
  vector < string > ::const_iterator first = nt_vector.begin();
  while ( first != nt_vector.end() ) {
    const string & name = *first++;
    m_all_ntuples->insertItem ( name.c_str() );
  }

  if ( m_all_ntuples -> count () != 0 ) {
    const string & name = nt_vector.back ();

    setNewPlotNTuple ( name );
    availPlotTypesActivated ( name.c_str() );
  }
  else {
    availPlotTypesActivated ( QString::null );
  }
}

void
Inspector::
setNewPlotNTuple ( const std::string & name )
{
  const vector < string > & nt_vector
    = DataSourceController::instance() -> getNTupleNames ();

  for ( unsigned int i = 0; i < nt_vector.size(); i++ ) {
    if ( nt_vector[i] == name ) {
      unsigned int current = m_all_ntuples -> currentItem ();
      if ( current != i ) {
        m_all_ntuples -> setCurrentItem ( i );
      }
      break;
    }
  }
}

void
Inspector::
dataTupleNameChanged ( const QString & text )
{
  m_last_ntuple_edited = m_all_ntuples -> currentItem ();
}

void
Inspector::
changeNTupleName ( const QString & text )
{
  DataSourceController * controller = DataSourceController::instance ();
  const vector < DataSource * > & nt_vector = controller -> getDataSources();
  DataSource * ds = nt_vector [ m_last_ntuple_edited ];
  if ( ds == 0 ) return;

  const string new_name = text.latin1();

  ds -> setName ( new_name );
}

void
Inspector::
dataNTupleSelChanged ( int item )
{
  m_all_ntuples -> setCurrentItem ( item );
  QString text ( "" );

  availPlotTypesActivated ( text );
}

void
Inspector::
allNtupleComboActivated ( const QString & text )
{
  // Change the number and type of axes depending on what is selected
  // inside m_availPlotTypes. Then insert the axis labels based on the
  // selection of nTupleNameComboBox.

  changeNTupleName ( text );
  m_all_ntuples -> setCurrentItem ( m_last_ntuple_edited );
  m_all_ntuples -> changeItem ( text, m_last_ntuple_edited );

  availPlotTypesActivated ( text );
}

void
Inspector::
on_sel_combo_0_activated ( const QString & label )
{
  axisLabelChanged ( 0, label );
}

void
Inspector::
on_sel_combo_1_activated ( const QString & label )
{
  axisLabelChanged ( 1, label );
}

void
Inspector::
on_sel_combo_2_activated ( const QString & label )
{
  axisLabelChanged ( 2, label );
}

void
Inspector::
on_sel_combo_3_activated ( const QString & label )
{
  axisLabelChanged ( 3, label );
}

void
Inspector::
axisLabelChanged ( int index, const QString & label )
{
  if ( m_plotter_list.size () > 1 ) {
    multiplePlotError ();
    return;
  }

  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  QString axisName = m_sel_labels [index] -> text();
  const std::string strAxisName ( axisName.latin1() );
  const std::string strLabel( label.latin1() );

  DisplayController * controller = DisplayController::instance();
  controller -> setAxisBinding ( plotter, strAxisName, strLabel );

  bool valid = controller -> isDataValid ( plotter );
  if ( valid == false ) {
    invalidDataWarning ();
  }
}

void
Inspector::
updatePlotTypes ()
{
  const vector < string > & dataRepNames
    = DisplayController::instance() -> getDisplayTypes ();
  if ( dataRepNames.empty () ) return;
  unsigned int size = m_availPlotTypes -> count ();

  if ( dataRepNames.size() != size ) {
    m_availPlotTypes->clear();

    vector < string > ::const_iterator first = dataRepNames.begin ();
    while ( first != dataRepNames.end() ) {
      const string & name = *first++;
      if ( name.find ( "Static" ) != string::npos ) continue;
      m_availPlotTypes->insertItem ( name.c_str() );
        }
     m_availPlotTypes->setCurrentItem ( 2 ); //Histogram
  }

  newPlotButton->setEnabled( true );
}

void
Inspector::
clearNewBindings ()
{
  unsigned int size = m_new_combos.size ();
  for ( unsigned int i = 0; i < size; i++ ) {
    QComboBox * box = m_new_combos [ i ];
    box -> clear ();
    box -> setEnabled ( false );
    QLabel * label = m_new_labels [ i ];
    label -> setEnabled ( false );
  }
}

void
Inspector::
availPlotTypesActivated ( const QString & )
{
  // Change the number and type of axes depending on what is selected
  // inside m_availPlotTypes. Then insert the axis labels based on the
  // selection of nTupleNameComboBox.

  // Get the labels of the selected NTuple.

  int index = m_all_ntuples->currentItem ();
  const vector < DataSource * > & nt_vector
    = DataSourceController::instance() -> getDataSources ();
  int size = static_cast < int > ( nt_vector.size() );
  if ( size == 0 ) {
    clearNewBindings();
    return;
  }

  if ( ! (index < size ) ) {
    index = 0;
  }

  DataSource * nt = nt_vector[index];
  const vector < string > & cols = nt->getLabels();
  // Get the binding options for the selected Plot Type.
  std::string plotTypeStr( (m_availPlotTypes->currentText()).latin1() );


  DisplayController * controller = DisplayController::instance ();
  const vector < string > & bindingOptions
    = controller -> bindingOptions ( plotTypeStr );
  if ( bindingOptions.empty () ) return;

  //Layout the stuff.

  m_newLayoutWidget->hide();

  clearNewBindings ();
  QString qs1;

  for ( unsigned int i = 0; i < bindingOptions.size(); i++ )
    {
      const string & axisName = bindingOptions[i];

      qs1 = ( axisName.c_str() );
      m_new_labels [i] -> setEnabled ( true );
      m_new_labels [i] -> setText ( qs1 );
      m_new_combos [i] -> setEnabled ( true );

      for (std::vector<string>::size_type j = 0; j < cols.size(); j++)
        {
          m_new_combos [i] -> insertItem ( cols [j].c_str() );
        }
      if ( axisName.find ( "optional" ) != string::npos ) {
        m_new_combos [i] -> insertItem ( "nil" );
        m_new_combos [i] -> setCurrentText ( "nil" );
      }
    }
}

void
Inspector::
updateDataTab()
{
  updateNewPlotControls ();
  dataClearSelectedControls ();

  PlotterBase * plotter = getPlotter ();
  updateSelectedPlotType ( plotter );

  if ( plotter != 0 ) {
    currentPlot->setEnabled ( true );
    bool yes = plotter -> isTargetable ();
    m_addDataRepButton->setEnabled ( yes );
    if ( yes == false ) return;
  }
  else {
    if ( m_plotter_list.empty () == true ) {
      currentPlot -> setDisabled ( true );
    }
    else {
      currentPlot -> setDisabled ( false );
    }
    return;
  }
  updateSelectedPlotData ( plotter );
}

void
Inspector::
updateSelectedPlotDataSource ( const std::string & name )
{
  const vector < string > & nt_vector
    = DataSourceController::instance () -> getNTupleNames ();

  unsigned int size = nt_vector.size ();
  unsigned int count = m_sel_ntuple_name -> count ();
  bool refresh = count != size;
  if ( refresh ) m_sel_ntuple_name -> clear ();
  int jndex = -1;
  for ( std::size_t i = 0; i < size; i++ ) {
    const string & ntname = nt_vector[i];
    if ( ntname == name ) jndex = i;
    if ( refresh ) m_sel_ntuple_name -> insertItem ( ntname.c_str () );
  }

  if ( jndex < 0 ) { // not bound to ntuple
    m_sel_ntuple_name -> setEnabled ( false );
  }
  else {
    m_sel_ntuple_name -> setEnabled ( true );
    m_sel_ntuple_name -> setCurrentItem ( jndex );
  }
}

void
Inspector::
updateSelectedPlotType ( const PlotterBase * plotter )
{
  bool yes = plotter != 0;
  if ( yes ) {
    yes = plotter -> isTargetable ();
    if ( yes ) {
      DataRep * datarep = plotter -> getTarget ();
      yes = datarep != 0;
      if ( yes ) {
        int index = plotter -> indexOf ( datarep );
        DisplayController * controller = DisplayController::instance ();
        const string & dataRepName
          = controller -> getType ( plotter, index );
        QString qst2 ( dataRepName.c_str() );
        m_dataRepNameText->setText ( qst2 );
      }
    }
  }

  m_dataRepNameText -> setEnabled ( yes );
}

void
Inspector::
dataClearSelectedControls ()
{
  QLayoutIterator it = m_vLayout->iterator();
  while ( it.current() != 0 )
    {
      QLayoutItem * ptr = it.current();
      QHBoxLayout * hbox = static_cast <QHBoxLayout *> (ptr);

      QLayoutIterator hit = hbox->iterator();
      while ( hit.current() != 0 )
        {
          QLayoutItem * hptr = hit.current();
          QWidget * hwidget = hptr->widget();
          hit.deleteCurrent();
          if ( hwidget ) delete ( hwidget );
        }

      it.deleteCurrent();

    }
}

void
Inspector::
updateSelectedPlotData ( const PlotterBase * plotter )
{
  DisplayController * controller = DisplayController::instance ();
  DataRep * datarep = plotter -> getTarget ();
  int index = plotter -> indexOf ( datarep );
  assert ( datarep != 0 );

  bool ntuple_bindings = datarep -> hasNTupleBindings ( );
  string name;

  if ( ntuple_bindings ) {
     name  = controller -> getDataSourceName ( plotter, index );
    setNewPlotNTuple ( name );
  }
  else {
    name = "<none>";
  }
  updateSelectedPlotDataSource ( name );

  //Layout the stuff.

  m_layoutWidget->hide();

  const vector < string > & bindings
    = controller -> axisBindings ( plotter, index );
  const vector < string > & bindingOptions
    = controller -> bindingOptions ( plotter, index );
  unsigned int listSize;

  if ( bindings.size() < bindingOptions.size() )
    {
      listSize = bindings.size();
    }
  else
    {
      listSize = bindingOptions.size();
    }

  bool yes = plotter -> isTargetable ();
  if ( ntuple_bindings == false ||
       yes == false ) return;

  // Now add the new hlayouts.

  QString qs1, qs2;

  const vector < string > & cols
    = controller -> getDataSourceLabels ( plotter, index );

  if ( cols.empty () ) return;

  for ( unsigned int i = 0; i < m_sel_combos.size (); i++ ) {
    QLabel * label = m_sel_labels [i];
    label -> setEnabled ( false );
    QComboBox * box = m_sel_combos [i];
    box -> clear ();
    box -> setEnabled ( false );
  }

  for ( unsigned int i = 0; i < m_sel_combos.size (); i++ )
    {
      if ( i == listSize ) break;
      const string & axisLabel = bindings[i];
      const string & axisName = bindingOptions[i];

      qs1 = ( axisName.c_str() );
      m_sel_labels [i] -> setEnabled ( true );
      m_sel_labels [i] -> setText ( qs1 );

      qs2 = ( axisLabel.c_str() );

      // Insert all column labels from the vector cols, and make qs2
      // the current text.

      m_sel_combos [i] -> setEnabled ( true );
      for (std::vector<string>::size_type j = 0; j < cols.size(); j++ )
        {
          m_sel_combos [i] -> insertItem ( cols [j].c_str() );
        }
      if ( axisName.find ( "optional" ) != string::npos )
        {
          m_sel_combos [i] -> insertItem ( "nil" );
        }
      m_sel_combos [i] -> setCurrentText ( qs2 );
    }
}

void
Inspector::
invalidDataWarning ()
{
  const QString message = 
    "One or more columns of the bound data source\n"
    "contains invalid data.";
 QMessageBox::warning ( this, // parent
                        "Invalid data", // caption
                        message,
                        QMessageBox::Ok,
                        Qt::NoButton,
                        Qt::NoButton );
}

void
Inspector::
noNTupleSelectedError ()
{
  const string message =
    "No n-tuple selected error\n"
    "Need to load n-tuple to create a plot";
  QMessageBox::critical ( this, // parent
                          "No n-tuple selected error", // cpation
                          message.c_str(),
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}

void
Inspector::
incompatibleDataRepError ( const std::string & type )
{
  const string message =
    "Plot of type " + type + " can not be added\n"
    "to selected plot\n\n"
    "It might be incompatible.   For example, \n"
    "requiring a Z axis display while selected\n"
    "does not have one.";
  QMessageBox::critical ( this, // parent
                          "Add to plot error", // caption
                          message.c_str(),
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}
void
Inspector::
incompatibleFitterError ( const std::string & type )
{
  const string message =
    "Fitter of type " + type + " can not be used\n"
    "with selected plot\n\n"
    "It might be incompatible.   For example, \n"
    "Maximum Likelihood fitting requires binned\n"
    "data representation.";
  QMessageBox::critical ( this, // parent
                          "Set fitter error", // caption
                          message.c_str(),
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}

void
Inspector::
incompatibleFunctionError ( const std::string & type )
{
  const string message =
    "Funtion of type " + type + " can not be used\n"
    "with selected fitter\n\n"
    "It might be incompatible.   For example, \n"
    "the fitter requires derivatives\n"
    "that function can not supply.";
  QMessageBox::critical ( this, // parent
                          "Set fitter error", // caption
                          message.c_str(),
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}

void
Inspector::
invalidRangeError ( const std::string & bad )
{
  const string message
    = "Attempt to apply invalid range:\n\n"
    + bad + "\n\n"
    + "Low end of range must be less than high end.";

  QMessageBox::critical ( this, // parent
                          "Range error", // caption
                          message.c_str(),
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}
                        
void
Inspector::
multipleDataRepError ( const std::string & type )
{
  const string message
    = "Multiple data representations are active.\n"
    "Can not apply a " + type + ".\n\n"
    "Use Control-click to select only one data representation.";
  QMessageBox::information ( this, // parent
                             "Multiple data representation error", // caption
                             message.c_str(),
                             QMessageBox::Ok,
                             Qt::NoButton,
                             Qt::NoButton );
}

void
Inspector::
multiplePlotError ( )
{
  QString  message (
    "Multiple plots are selected.\n"
    "Can not apply change until only one is selected\n\n"
    "Use shift-click to deselect a selected plot" );
  QMessageBox::information ( this, // parent
                             "Multiple plot error", // caption
                             message, // .c_str(),
                             QMessageBox::Ok,
                             Qt::NoButton,
                             Qt::NoButton );
}

void Inspector::functionAddError ()
{
  const string message =
    "Functions are not supported on the selected data reaxisWitation.";

  QMessageBox::critical ( this, "Function Add Error",
                          message.c_str(),
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}

void
Inspector::
newPlotError ( const DataSourceException & e )
{
  string message ( "New plot could not be created because:\n" );
  message += e.what ();
  QMessageBox::critical ( this, // parent
                          "New plot error", // caption
                          message.c_str(),
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}

#ifdef HAVE_ROOT
std::string
Inspector::
getArrayTupleLabel( const DataSource * rtuple, const std::string & column )
{
  RootController * controller = RootController::instance ();
  vector < int > dimSize;
  controller -> fillDimSize ( dimSize, rtuple, column );

  // Set the caption
  QString caption( "MultiDimensional data in rows of the column ");
  caption.append( QString( column.c_str() ) );

  // Set the label
  std::ostringstream ost;
  ost << " Rows of this column are of size ";

  unsigned int i;
  for( i = 0; i < dimSize.size() - 1; i++ )
    ost << dimSize[i] << " x ";
  ost << dimSize[i];

  ost << "\n Enter C-style index of a single element of this";
  ost << "\n multidimentional data which you wish to analyse.";
  ost << "\n Index should be a comma separated list of ";
  ost << dimSize.size() << " integers.";

  ost << "\n For e.g. ";
  for( i = 0; i < dimSize.size() - 1; i++ )
    ost << "0, ";
  ost << "0 \n";

  string label( ost.str() );

  bool ok;
  QString text = QInputDialog::getText( caption, QString( label.c_str() ),
                                        QLineEdit::Normal,
                                        QString::null, &ok, this );

  // Also create the array tuple label
  std::ostringstream labelstream;
  labelstream << column;

  if ( ok && !text.isEmpty() )
    {
      vector< unsigned int > index;
      string s( text.ascii() );

      // User entered something and pressed OK
      // Creating the list of dropped delimiters.
      boost::char_separator< char > sep( "," );

      // A tokenizer with above dropped delimiters.
      typedef boost::tokenizer< boost::char_separator< char > >  tokenizer;
      tokenizer tok( s, sep );

      // Start extracting the dimension sizes.
      for( tokenizer::iterator tok_iter = tok.begin();
           tok_iter != tok.end();
           ++tok_iter )
        {
          unsigned int idx = boost::lexical_cast< unsigned int >( *tok_iter );
          index.push_back( idx );
          labelstream << "[" << idx << "]";
        }
    }

  return labelstream.str();
}


#endif

void
Inspector::
newPlotButton_clicked()
{
  const vector < DataSource * > & nt_vector
    = DataSourceController::instance() -> getDataSources ();

  if ( nt_vector.empty() )
    {
      noNTupleSelectedError ();
      return;
    }

  // See all comboboxes and create a new plotter.
  int current = m_all_ntuples->currentItem ();
  DataSource * ds = nt_vector[current];

  // Find the datarep.
  std::string plotTypeStr( (m_availPlotTypes -> currentText()).latin1() );

  // Find the axis bindings.
  vector < string > bindings;
  for ( unsigned int i = 0; i < m_new_combos.size(); i++ )
    {
      if ( m_new_combos [i] -> count () == 0 ) break;

      QString qstring = m_new_combos [ i ] -> currentText();
      string column ( qstring.latin1() );
      string label = column;

#ifdef HAVE_ROOT
      if( column != "nil" && ds -> isMultiDimensional( column ) )
        {
            label = getArrayTupleLabel ( ds, column );
            RootController * rcontroller = RootController::instance();
            rcontroller -> smartExpandRootNTuple ( ds, column );
        }
#endif
      bindings.push_back ( label );
    }

  // Create the plotter.
  try {
    DisplayController * controller =  DisplayController::instance();
    PlotterBase * newDisplay =
      controller -> createDisplay ( plotTypeStr, * ds, bindings );
    CanvasWindow * canvas = WindowController::instance() -> currentCanvas();
    canvas->addPlotDisplay ( newDisplay, true );

    bool valid = controller -> isDataValid ( newDisplay );
    if ( valid == false ) {
      invalidDataWarning ();
    }
  }
  catch ( const DataSourceException & e ) {
    newPlotError ( e );
  }
}


void
Inspector::
addDataRepButton_clicked()
{
  // Find the display.

  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;

  // Find the datarep.
  std::string plotTypeStr( (m_availPlotTypes->currentText()).latin1() );

  const vector < DataSource * > & nt_vector
    = DataSourceController::instance() -> getDataSources ();

  int current = m_all_ntuples->currentItem ();
  DataSource * ds = nt_vector[current];

  // Find the axis bindings.

  vector < string > bindings;
  for ( unsigned int i = 0; i < m_new_combos.size(); i++ )
    {
      if ( m_new_combos [i] -> count () == 0 ) break;

      QString qstring = m_new_combos [ i ] -> currentText();
      string column ( qstring.latin1() );
      string label = column;
#ifdef HAVE_ROOT
      if ( column != "nil" && ds -> isMultiDimensional ( column ) ) {
        label = getArrayTupleLabel ( ds, column );
        RootController * rcontroller = RootController::instance ();
        rcontroller -> smartExpandRootNTuple ( ds, column );
      }
#endif
      bindings.push_back ( label );
    }

  // Add the data rep.

  DisplayController * controller = DisplayController::instance();
  DataRep * rep = controller -> addDataRep ( plotter, plotTypeStr, ds,
                                             bindings );

  if ( rep == 0 ) incompatibleDataRepError ( plotTypeStr );

  plotter -> autoScale ();
  bool valid = controller -> isDataValid ( rep );
  if ( valid == false ) {
    invalidDataWarning ();
  }

  update ();
}

void
Inspector::
dataCreateNTuple ()
{
  const PlotterBase * plotter = getPlotter ();
  if ( plotter == 0 ) return;
  DisplayController * controller = DisplayController::instance ();
  controller -> createNTuple ( plotter );

  update ();
}


void
Inspector::
fillPlotterList ( std::vector < PlotterBase * > & plotterlist )
{
  plotterlist.clear();
  CanvasWindow * canvaz = WindowController::instance () ->currentCanvas();

  if ( canvaz != 0 ) {
    canvaz -> fillPlotterList ( plotterlist );
  }
}

void
Inspector::
ntupleChanged ( int index )
{
  unsigned int size = m_plotter_list.size ();
  if ( size == 0 ) return;

  CutController * controller = CutController::instance ();
  vector < PlotterBase * > web;
  controller -> fillCutWeb ( m_plotter_list, web );
  size = web.size ();

  for ( unsigned int i = 0; i < size; i++ ) {
    PlotterBase * plotter = web [ i ];
    bool yes = plotter != 0;
    if ( yes ) yes = plotter -> isTargetable ();
    if ( yes == false ) continue;

    DataRep * rep = plotter -> getTarget ();
    yes = rep -> hasNTupleBindings ();
    if ( yes == false ) continue;

    DataSourceController * ds_controller = DataSourceController::instance ();
    const vector < string > & names = ds_controller -> getNTupleNames ();
    const string & ds_name = names [ index ];
    const DataSource * source = ds_controller -> getDataSource ( ds_name );
    DataRepController * dr_controller = DataRepController::instance ();

    try {
      dr_controller -> changeDataSource ( rep, source );
    }
    catch ( const DataSourceException & e ) {
      string message ( "Could not change binding because\n" );
      message += e.what ();
      QMessageBox::critical ( this, // parent
                              "Data source error",
                              message.c_str (),
                              QMessageBox::Ok,
                              Qt::NoButton,
                              Qt::NoButton );
    }
  }
}

void
Inspector::
updatePlotTab()
{
  bool yes = m_plotter_list.empty();
  m_plot_title -> setDisabled ( yes );

  PlotterBase * plotter = getPlotter ();

  yes = plotter != 0;
  if ( yes ) yes = plotter -> isTargetable ();

  m_plot_symbols->setEnabled ( yes );
  m_plot_color->setEnabled ( yes );
  m_interval_le->setEnabled ( yes );
  m_interval_cb->setEnabled ( yes );
  m_errorBars ->setEnabled ( yes );
  m_pointRepComboBox->setEnabled ( yes );

  if ( yes == false ) return;



  // Point Reps stuff.

  m_pointRepComboBox->clear();

  DisplayController * controller = DisplayController::instance ();
  DataRep * datarep = controller -> activeDataRep ( plotter );
  assert ( datarep != 0 );

  yes = datarep -> hasErrorDisplay ();
  m_errorBars -> setEnabled ( yes );

  ProjectorBase * proj = datarep -> getProjector();
  const vector <string> & pointreps = proj -> getPointReps();

  for (std::vector<string>::size_type i = 0; i < pointreps.size(); i++ ) {
    m_pointRepComboBox->insertItem ( pointreps[i].c_str() );
  }

  if ( pointreps.empty () == false ) {
    RepBase * rep = datarep->getRepresentation();
    const string & curRep = rep->name();
    m_pointRepComboBox->setCurrentText ( curRep.c_str() );
  }

  if ( plotter -> hasAxis ( Axes::Z ) == false ) {
    m_value_combo -> setDisabled ( true );
    m_slider_control -> setDisabled ( true );
    m_model_control -> setDisabled ( true );
  }
  else {
    int jndex = controller -> getValueTransformIndex ( plotter );
    if ( jndex < 0 ) {
      m_value_combo -> setDisabled ( true );
    }
    else {
      m_value_combo -> setEnabled ( true );
      m_value_combo -> setCurrentItem ( jndex );

      bool yes = controller -> hasControlPoints ( plotter );
      m_slider_control -> setEnabled ( yes );
      m_model_control -> setEnabled ( yes );

      if ( yes ) {
        const vector < double > & sv
          = controller -> getValueBrkPt ( plotter );
        brk_pt -> setValue
          ( static_cast<int> ( sv[0] * brk_pt -> maxValue() ) );
        flat_width -> setValue
          ( static_cast<int> (sv[1]* flat_width -> maxValue() ) );
        color_scale -> setValue
          ( static_cast<int> (sv[2]* color_scale -> maxValue() ) );
      }
    }
  }

  const DataSource * nt = controller -> getNTuple ( plotter );

  if ( nt && nt -> empty () ) {
    m_plot_symbols->setDisabled ( true );
    m_plot_title->setDisabled ( true );
    m_plot_color->setDisabled ( true );
    return;
  }

  const std::string & st = plotter->getTitle();
  QString qst ( st.c_str() );
  m_titleText->setText ( qst );

  m_errorBars->setChecked ( plotter->errorDisplay ( Axes::Y ) );

  yes = controller -> hasSymbolRep ( plotter );
  m_symbol_group -> setEnabled ( yes );

  if ( yes  ) {
    m_point_stack -> raiseWidget ( 0 );
    unsigned int index = controller ->getRepStyle ( plotter );
    m_symbol_group -> setButton ( index );
  }


  yes = controller -> hasLineRep ( plotter );
  m_line_group -> setEnabled ( yes );
  if ( yes ) {
    m_point_stack -> raiseWidget ( 1 );
    unsigned int style = controller -> getRepStyle ( plotter );
#if QT_VERSION < 0x040000
    QButton * button = m_line_group -> find ( style );
#else
//    QAbstractButton * button = m_line_group -> find ( style );
#endif
    QRadioButton * rb = dynamic_cast < QRadioButton * > ( button );
    rb -> setChecked ( true );
  }

  float ptsize =  controller -> pointSize ( plotter );
  m_symbolPointSize -> setText ( QString ("%1").arg (ptsize) );

  const Color & color = plotter->repColor ();
  QColor qcolor ( color.getRed(), color.getGreen(), color.getBlue () );
  m_selectedColor->setPaletteBackgroundColor ( qcolor );

  if ( nt == 0 ) {
    m_interval_cb -> setEnabled ( false );
    m_interval_le -> setEnabled ( false );
    return;
  }
  const NTuple * ntuple = dynamic_cast < const NTuple * > ( nt );
  yes = ntuple != 0 && ntuple -> isIntervalEnabled ();
  m_interval_cb->setChecked ( yes );
  m_interval_le->setEnabled ( yes );

  if ( yes ) {
    unsigned int count = ntuple->getIntervalCount ();
    m_interval_le->setText ( QString ("%1").arg ( count ) );
  }
}

void
Inspector::
valueChanged ( int index )
{
  PlotterBase * plotter = getPlotter ();
  if ( plotter != 0 ) {
    loadAllUsrModels ();
    DisplayController * controller = DisplayController::instance ();
    controller -> setValueTransform ( plotter, index , usr_models ,
                                      brk_points, flat_widths,color_scales);

     bool yes = controller -> hasControlPoints ( plotter );
     m_slider_control -> setEnabled ( yes );
     m_model_control -> setEnabled ( yes );
     if ( yes ) {
       flat_width ->setValue(50);
       brk_pt->setValue (50);
       //color_scale -> setValue(50) ;
     }
  }
}

void
Inspector::
loadAllUsrModels ()

{
    usr_models.clear();
    brk_points.clear();
    flat_widths.clear();
    color_scales.clear();

    QSettings settings;
    settings.insertSearchPath ( QSettings::Windows, s_registry );

    int length = ( settings.entryList(s_app_key + "/Model Name/")).size( );
    for ( int i = 0; i < length ; i++ )
      {
        QString name = settings.readEntry ( s_app_key + "/Model Name/" +
                                            QString::number ( i ) );
        usr_models.push_back( name.ascii() );

        double brk_pt = settings.readDoubleEntry ( s_app_key +
                                                   "/break point/" +
                                                   QString::number ( i ) );
        brk_points.push_back( brk_pt );


        double flat_width = settings.readDoubleEntry ( s_app_key +
                                                       "/flat width/" +
                                                       QString::number ( i ) );
        flat_widths.push_back( flat_width );
        

        double color_scale = settings.readDoubleEntry ( s_app_key +
                                                       "/color scale/" +
                                                       QString::number ( i ) );
        color_scales.push_back( color_scale );
        
      }
}
                                                


void
Inspector::
sliderChanged ( int index )
{
    vector < double > sv;

    double m = brk_pt -> maxValue ();
    assert(m != 0);
    sv.push_back ( (brk_pt -> value()) / m + 0.001);

    double w = flat_width -> maxValue();
    assert(w != 0);
    sv.push_back ( (flat_width -> value()) / w + 0.001);

    double c = color_scale -> maxValue ();
    assert( c!= 0 );
    sv.push_back ( ( ( (color_scale -> value()) / c ) ) * 1.5 );

    PlotterBase * plotter = getPlotter ();
    if ( plotter != 0 ) {
    DisplayController * controller = DisplayController::instance ();
    controller -> setValueBrkPt (plotter,sv );
    }
}

void
Inspector::
resetSlider ( )
{
  if ( m_slider_control -> isEnabled () )
    {
      brk_pt -> setValue ( 50 );
      flat_width -> setValue ( 50 );
      color_scale -> setValue ( 50 );
    }
}


void
Inspector::
newColorModel ( )
{
  NewModelDialog * dialog = new NewModelDialog ( this );
  dialog -> set_brk_pt ( brk_pt -> value () );
  dialog -> set_flat_width ( flat_width -> value () );
  dialog -> set_color_scale ( color_scale -> value () );

  int retval = dialog -> exec ( );
  if ( retval == QDialog::Accepted )
    {
      m_value_combo -> insertItem ( dialog -> get_model_name ( ) );
       double bp = static_cast <double>(dialog -> get_brk_pt ()) /
                   static_cast <double>( brk_pt -> maxValue () );

       double fw = static_cast <double>(dialog -> get_flat_width ()) /
                   static_cast <double>( flat_width -> maxValue () );

       double cs = static_cast <double>(dialog -> get_color_scale ()) /
                   static_cast <double>(color_scale -> maxValue () );

       QSettings settings;
       settings.insertSearchPath ( QSettings::Windows, s_registry );

       int length = (settings.entryList(s_app_key + "/Model Name/")).size( );

       settings.writeEntry ( s_app_key + "/Model Name/" +
                             QString::number (length ),
           dialog -> get_model_name ( ) );

       settings.writeEntry ( s_app_key + "/break point/" +
                             QString::number (length ), bp );

       settings.writeEntry ( s_app_key + "/flat width/" +
                             QString::number (length ), fw);

       settings.writeEntry ( s_app_key + "/color scale/" +
                             QString::number (length ), cs);


       loadAllUsrModels ();

    }
  delete dialog;
  if ( retval == QDialog::Rejected ) return;
}


void
Inspector::
editColorModel ( )
{
  loadAllUsrModels ();
  if ( ( usr_models.size() != 0 ) ){

    int i = m_value_combo -> currentItem ();
    int index = i - (m_value_combo -> count () - usr_models.size () );
    if ( index >= 0){
      EditModelDialog * dialog = new EditModelDialog ( this,
                                                       usr_models [ index ] ,
                                                       brk_points[ index ] ,
                                                       flat_widths [ index ],
                                                       color_scales [ index ],
                                                       brk_pt -> maxValue(),
                                                      flat_width -> maxValue(),
                                                  color_scale -> maxValue() );

      int retval = dialog -> exec ( );
      if ( retval == QDialog::Accepted )
        {
          double bp = static_cast <double>(dialog -> get_brk_pt ()) /
            static_cast <double>( brk_pt -> maxValue () );
        
          double fw = static_cast <double>(dialog -> get_flat_width ()) /
            static_cast <double>( flat_width -> maxValue () );

          double cs = static_cast <double>(dialog -> get_color_scale ()) /
            static_cast <double>( color_scale -> maxValue () );
        
          QSettings settings;
          settings.insertSearchPath ( QSettings::Windows, s_registry );

          settings.writeEntry ( s_app_key + "/Model Name/" +
                                QString::number ( index ),
        dialog -> get_model_name ( ) );

          settings.writeEntry ( s_app_key + "/break point/" +
                                QString::number (index ), bp );

          settings.writeEntry ( s_app_key + "/flat width/" +
                                QString::number (index ), fw);
        
          settings.writeEntry ( s_app_key + "/color scale/" +
                                QString::number (index ), cs);
        
          loadAllUsrModels ();

        }
      delete dialog;
      if ( retval == QDialog::Rejected ) return;
    }
  }
}


void
Inspector::
deleteColorModel ( )
{
  loadAllUsrModels();
  if ( usr_models.size () != 0 ){
    int i = m_value_combo -> currentItem ();
    int index = i - (m_value_combo -> count () - usr_models.size () );
    if ( index >= 0 ){
      m_value_combo -> removeItem ( i );
      QSettings settings;
      settings.insertSearchPath ( QSettings::Windows, s_registry );
      for ( unsigned int j = index ; j < usr_models.size () - 1 ; j++ )
        {
        
          QString name = settings.readEntry ( s_app_key + "/Model Name/" +
                                              QString::number ( j + 1  ) );
          settings.writeEntry ( s_app_key + "/Model Name/" +
                                QString::number ( j ),
                                name );
        
          double bp = settings.readDoubleEntry ( s_app_key +
                                               "/break point/" +
                                               QString::number ( j + 1 ) );
          settings.writeEntry ( s_app_key + "/break point/" +
                              QString::number ( j ),
                              bp );

          double fw = settings.readDoubleEntry ( s_app_key +
                                               "/flat width/" +
                                               QString::number ( j + 1 ) );
          settings.writeEntry ( s_app_key + "/flat width/" +
                              QString::number ( j ),
                              fw );

          double cs = settings.readDoubleEntry ( s_app_key +
                                               "/color scale/" +
                                               QString::number ( j + 1 ) );
          settings.writeEntry ( s_app_key + "/color scale/" +
                              QString::number ( j ),
                              cs );
        }


      int last = usr_models.size () - 1 ;
      settings.removeEntry ( s_app_key + "/Model Name/" +
                             QString::number ( last ));
      settings.removeEntry ( s_app_key + "/break point/" +
                             QString::number ( last ));
      settings.removeEntry ( s_app_key + "/flat width/" +
                             QString::number ( last ));
      settings.removeEntry ( s_app_key + "/color scale/" +
                             QString::number ( last ));


      loadAllUsrModels();

    }
  }

}

void
Inspector::
errorBars_toggled( bool )
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;

  bool checked = m_errorBars->isChecked();
  DisplayController * controller = DisplayController::instance ();

  controller -> setErrorDisplayed ( plotter, Axes::Y, checked );
}

void
Inspector::
titleText_returnPressed()
{
  std::string s( (m_titleText->text()).latin1() );
  unsigned int size = m_plotter_list.size();

  for ( unsigned int i = 0; i < size; i++ ) {
    PlotterBase * plotter = m_plotter_list [ i ];
    plotter->setTitle ( s );
  }
}

void Inspector::symbolTypeButtonGroup_clicked ( int id )
{
  m_symbol_group -> setButton ( id );
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  DisplayController * controller = DisplayController::instance ();
  DataRep * rep = controller -> activeDataRep ( plotter );
  if ( rep == 0 ) {
    multipleDataRepError ( "plot symbol change" );
    return;
  }

  rep -> setRepStyle ( id );
}

void Inspector::lineStyleButtonGroup_clicked ( int id )
{

  m_line_group -> setButton ( id );
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  DisplayController * controller = DisplayController::instance ();
  DataRep * rep = controller -> activeDataRep ( plotter );
  if ( rep == 0 ) {
    multipleDataRepError ( "plot symbol change" );
    return;
  }

  rep -> setRepStyle ( id );
}

void Inspector::symbolPointSize_returnPressed()
{

  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;

  DisplayController * controller = DisplayController::instance ();
  DataRep * rep = controller -> activeDataRep ( plotter );
  if ( rep == 0 ) {
    multipleDataRepError ( "plot symbol size change" );
    return;
  }

  QString text = m_symbolPointSize->text();
  float size = text.toFloat();

  rep->setRepSize ( size );

}

/* virtual */
void Inspector::intervalStateChanged ( bool state )
{
  PlotterBase * plotter = getPlotter ();
  if ( plotter == 0 ) return;

  DisplayController * controller = DisplayController::instance ();
  controller->setIntervalEnabled ( plotter, state );
  m_interval_le->setEnabled ( state );
}

/* virtual */
void Inspector::intervalTextChanged ( const QString & text )
{
  PlotterBase * plotter = getPlotter ();
  if ( plotter == 0 ) return;

  DisplayController * controller = DisplayController::instance ();

  unsigned int interval = text.toUInt ();
  controller->setIntervalCount ( plotter, interval );
}

void
Inspector::
colorSelect_clicked()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;

  int index = plotter->activePlotIndex ();

  if ( index < 0 ) {
    multipleDataRepError ( "color change" );
    return;
  }

  const Color & rep_color = plotter->repColor();
  QColor color ( rep_color.getRed(),
                 rep_color.getGreen(),
                 rep_color.getBlue() );
  color = QColorDialog::getColor ( color );
  if ( color.isValid() == false ) return;

  m_selectedColor->setPaletteBackgroundColor ( color );

  Color c ( color.red(), color.green(), color.blue() );
  plotter->setRepColor ( c );
}

void
Inspector::
pointRepComboBox_activated ( const QString & qstr )
{
  PlotterBase * plotter = getPlotter ();

  if ( plotter != 0 ) {
    DisplayController * controller = DisplayController::instance ();
    const string rep ( qstr.latin1() );

    //Must Make CHANGES HERE!!!
    controller -> setRepresentation ( plotter, rep );

    if ( plotter -> hasAxis ( Axes::Z ) == true ) {

      int index = m_value_combo -> currentItem ();
      controller -> setValueTransform ( plotter, index , usr_models ,
                                      brk_points, flat_widths,color_scales);
    }

    updatePlotTab (); // to update the m_point_stack and size.
  }
}

void
Inspector::
on_axis_button_group_clicked ( int id )
{
  m_axis = Axes::convert ( id );
  updateAxisTab ();
}

void
Inspector::
axisZoomPanCheckBox_clicked()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;

  plotter->setAutoRanging ( m_axis, false );
  const Range & r = plotter->getRange ( m_axis, true );

  m_autoScale->setChecked ( false );

  if ( axisWidget1->isZoomPanChecked() ) {
    m_zoompan[plotter] = true;
  }

  else {

    std::map < const PlotterBase *, bool >::const_iterator it
      = m_zoompan.find ( plotter );
    if ( it != m_zoompan.end () ) {
      m_zoompan[plotter] = false;
    }

  }

  axisWidget1->processZoomPanCheckBoxClicked ( r, r );
}

void
Inspector::
highRangeDrag()
{

  int value = axisWidget1->getHighSliderValue ();
  setHighRange ( value, false );

  axisWidget1->setHighSliderValue ( 50 );
}

void
Inspector::
lowRangeDrag()
{
  int value = axisWidget1->getLowSliderValue ();
  setLowRange ( value, false  );

  axisWidget1->setLowSliderValue ( 50 );
}

void
Inspector::
offsetDrag()
{
  int value = m_offset_range->value ();
  setOffset ( value, false );
  m_offset_range->setValue ( 50 );
}

void
Inspector::
widthDrag ()
{
  int value = m_width_range->value ();
  setBinWidth ( value, false );

  m_width_range->setValue ( 50 );
}

void
Inspector::
setWidthText()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;

  DisplayController * controller = DisplayController::instance ();
  int index = controller -> activeDataRepIndex ( plotter );
  bool yes = controller -> hasNTupleBindings ( plotter, index );
  if ( yes ) {
    //Get the string and convert it to double.
    QString text = m_width_text->text();
    double width = text.toDouble();

    if ( width == 0 ) return;    // To prevent it from crashing.

    controller -> setBinWidth ( plotter, m_axis, width );
  }

  updateAxisTab();
}

void
Inspector::
setDragOn ()
{
  m_dragging = true;

  if ( ! axisWidget1->isZoomPanChecked() )
    {
      m_autoScale->setChecked ( false );
      autoScale_clicked ();
    }
  else
    {
      // Save current width and position.
      m_autoScale->setChecked ( false );
      autoScale_clicked ();

      PlotterBase * plotter = getPlotter ();
      if ( !plotter ) return;
      const Range & r = plotter->getRange ( m_axis, true );
     m_range.setRange ( r.low(), r.high(), r.pos() );
    }

}

void
Inspector::
setOffsetText()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;

  DisplayController * controller = DisplayController::instance ();
  int index = controller -> activeDataRepIndex ( plotter );
  bool yes = controller -> hasNTupleBindings ( plotter, index );
  if ( yes ) {
    //Get the string and convert it to double.
    QString text = m_offset_text->text();
    double offset = text.toDouble();

    int value = static_cast < int > ( 50.0 * offset ) + 49;
    setDragOn ();
    setOffset( value );
    offsetDrag ();
  }

  updateAxisTab ();
}

void
Inspector::
setBinWidth ( int value )
{
  setBinWidth ( value, m_dragging );

  if ( m_dragging == false ) m_width_range -> setValue ( 50 );
}

void
Inspector::
setBinWidth ( int value, bool drag )
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  m_dragging = drag;

  const string axis = convertToString ( m_axis );
  DisplayController * controller = DisplayController::instance ();
  controller -> setBinWidth ( plotter, axis, value, m_dragging );
  double width = plotter->getBinWidth ( m_axis );
  m_width_text -> setText ( QString ("%1").arg (width) );
  bool has_ntuple = controller->hasNTupleBindings ( plotter, 0 );
  m_width_text->setReadOnly ( ! has_ntuple );
}

void
Inspector::
axisLabelText()
{
  PlotterBase * plotter = getPlotter ();
  if ( plotter != 0 ) {
    QString text = m_axis_label -> text ();
    const string ltext = text.latin1();
    const string axis = convertToString ( m_axis );
    plotter -> setLabel ( m_axis, ltext );
  }
}

void
Inspector::
setLowText()
{

  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;

  Range r = plotter->getRange ( m_axis, true );

  axisWidget1->processTextBoxReturnPressed ( r, r );

  plotter->setRange ( m_axis, r, true, false ); // scaled, keep bin width
  m_autoScale->setChecked ( false );

  updateAxisTab ();
}

void
Inspector::
setLowRange ( int value )
{
  if ( m_is_updating == false ) {
    setLowRange ( value, m_dragging );
    if ( m_dragging == false ) {
      axisWidget1->setLowSliderValue ( 50 );
    }
  }
}

void
Inspector::
setLowRange ( int value, bool yes )
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  m_dragging = yes;

  plotter->setAutoRanging ( m_axis, false );

  if ( ! axisWidget1->isZoomPanChecked() )
    {
      const string axis = convertToString ( m_axis );
      plotter->setLowRange ( m_axis, value, m_dragging );
      const Range & r = plotter->getRange ( m_axis, true );
      double low = r.low();
      axisWidget1 -> setLowText ( QString("%1").arg(low));
    }
  else
    {
      const Range & r = plotter->getRange ( m_axis, true );
      Range range ( r.low(), r.high(), r.pos() );
      axisWidget1->processLowSliderMoved ( value, range, m_range );
      if ( m_dragging ) plotter->setRange ( m_axis, range, true, false );
    }
}

void
Inspector::
setHighRange ( int value )
{
  if ( m_is_updating == false ) {
    setHighRange ( value, m_dragging );
    if ( m_dragging == false ) {
      axisWidget1->setHighSliderValue ( 50 );
    }
  }
}

void
Inspector::
setHighRange ( int value, bool yes )
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  m_dragging = yes;

  plotter->setAutoRanging ( m_axis, false );

  if ( !axisWidget1->isZoomPanChecked() )
    {
      const string axis = convertToString ( m_axis );
      plotter->setHighRange ( m_axis, value, m_dragging );
      const Range & r = plotter->getRange ( m_axis, true );
      double high = r.high();
      axisWidget1 -> setHighText ( QString("%1").arg(high));
      return;
    }


  BinaryTransform *t =
    dynamic_cast<  BinaryTransform* > ( plotter->getTransform() );

  if ( axisWidget1->isZoomPanChecked() && ! t->isPeriodic() )
    {
      const Range & r = plotter->getRange ( m_axis, true );
      Range range ( r.low(), r.high(), r.pos() );
      axisWidget1->processHighSliderMoved ( value, range, m_range );
      if ( m_dragging ) plotter->setRange ( m_axis, range, true, false );
      return;
    }

  double offset(0.0), incr(0.0);

  if ( axisWidget1->isZoomPanChecked() && t->isPeriodic() )
    {
      PeriodicBinaryTransform *tp =
        dynamic_cast< PeriodicBinaryTransform* > ( t );

      const Range & r = plotter->getRange ( m_axis, true );
      Range * range = new Range ( r.low(), r.high(), r.pos() );

      incr = ( value - m_highslider1_last_val ) * r.length() / 100;
      m_highslider1_last_val = value;

      if ( m_axis == Axes::X )
        {
          offset = tp->xOffset();
          offset = tp->moduloAddX( offset, incr );
          tp->setXOffset( offset );
        }
      else if ( m_axis == Axes::Y )
        {
          offset = tp->yOffset();
          offset = tp->moduloAddY( offset, incr );
          tp->setYOffset( offset );
        }

      axisWidget1 -> setHighText ( QString( "%1" ).arg( offset ) );
      if ( m_dragging ) plotter->setRange ( m_axis, *range, true );
      delete ( range );
      return;
    }
}

void
Inspector::
setHighText()
{

  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;

  Range r = plotter->getRange ( m_axis, true );

  axisWidget1->processTextBoxReturnPressed ( r, r );

  plotter->setRange ( m_axis, r, true, false ); // scaled and keep bin width
  m_autoScale->setChecked ( false );

  updateAxisTab ();
}

void
Inspector::
setOffset ( int value  )
{
  setOffset( value, m_dragging );
}

void
Inspector::
setOffset ( int value, bool yes  )
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  m_dragging = yes;

  const string axis = convertToString ( m_axis );
  DisplayController * controller = DisplayController::instance();
  controller ->  setOffset ( plotter, axis, value, m_dragging );
  double offset = plotter->getOffset ( m_axis );
  m_offset_text -> setText ( QString ("%1").arg (offset) );

}

const std::vector < PlotterBase * > &
Inspector::
getDataCutList ( PlotterBase * plotter )
{
  vector < PlotterBase * > plotterlist;
  fillPlotterList ( plotterlist );

  int numDataReps = plotter -> getNumDataReps();

  DisplayController * controller = DisplayController::instance ();
  int index = controller ->activeDataRepIndex ( plotter );
  const DataSource * tuple;
  CutController * cutcontroller = CutController::instance();

  if( index >= 0 || numDataReps < 2 ) {
    tuple  = controller -> getNTuple( plotter );
  }
  else
    {
      tuple  = controller -> getNTuple( plotter, 0 );

      for( int i = 1; i < numDataReps; i++ ) {
        const DataSource * nt = controller -> getNTuple( plotter, i );
        if ( tuple !=  nt )
          {
            tuple = 0;
            break;
          }
      }
    }

  return cutcontroller->getCutList ( plotterlist, tuple );
}

void
Inspector::
cutText_returnPressed ()
{
  m_is_updating = true;

  bool fit_cut = cut_button_group -> selected () == m_cut_fit_radio;

  int index = m_selCutComboBox -> currentItem ();
  Range currentRange = m_tuple_cuts [index] -> getRange();
  PlotterBase * plotter = getSelectedCut();

  if ( fit_cut == false ) {
    Axes::Type cut_axis = getAxes ( index );
    const Range & fullRange = plotter -> getRange ( cut_axis, false );
    axisWidget2->processTextBoxReturnPressed ( currentRange, fullRange );
    plotter->setCutRangeAt ( currentRange, cut_axis );
  }
  else {
    const Range & fullRange = plotter -> getRange ( Axes::X, false );
    axisWidget2->processTextBoxReturnPressed ( currentRange, fullRange );
    plotter->setCutRangeAt ( currentRange, index );
  }
}

void Inspector::disableCutControls ( bool yes )
{
  axisWidget2->setAllDisabled ( yes );
  colorSelect_2->setDisabled ( yes );
  cutRemovePushButton->setDisabled ( yes );
  cutInvertPushButton->setDisabled ( yes );
  cutEnablePushButton -> setDisabled ( yes );
  m_cutAddSelected->setDisabled ( yes );
  m_cutAddAll -> setDisabled ( yes );

  if ( yes ) {
    int number = m_selCutComboBox -> count ();
    while ( number-- > 0 ) {
      m_selCutComboBox -> removeItem ( 0 );
    }
  }
  m_selCutComboBox -> setDisabled ( yes );
}

void
Inspector::
updateTupleCuts ( const std::vector < PlotterBase * > & cutlist )
{
  m_tuple_cuts.clear ();
  m_tuple_cut_plotters.clear ();

  unsigned int size = cutlist.size ();

  for ( unsigned int i = 0; i < size; i++ ) {
    PlotterBase * plotter = cutlist[i];
    TupleCutList_t cuts;
    plotter -> fillCutList ( cuts );

    for ( unsigned int j = 0; j < cuts.size (); j++ ) {
      m_tuple_cuts.push_back ( cuts[j] );
      m_tuple_cut_plotters.push_back ( plotter );
    }
  }
}

void
Inspector::
updateCutControls ( const std::vector < PlotterBase * > & cutlist )
{
  QString old_current = m_selCutComboBox -> currentText ();
  int numberItems = m_selCutComboBox->count();

  while ( numberItems-- > 0 ) {
    m_selCutComboBox->removeItem(0);
  }

  m_selCutComboBox -> setEnabled ( true );

  updateTupleCuts ( cutlist );
  bool yes = m_tuple_cuts.empty ();
  if ( yes ) {
    cutRemovePushButton -> setEnabled ( false );
    return;
  }

  int index = -1;
  unsigned int size = m_tuple_cuts.size ();

  for ( unsigned int i = 0; i < size; i++ ) {
    const TupleCut * cut = m_tuple_cuts[i];
    const string & label = cut -> getLabel ();
    QString item = label.c_str ();
    m_selCutComboBox -> insertItem ( item );
    if ( item == old_current ) index = i;
  }

  PlotterBase * plotter = getPlotter ();
  assert ( plotter );
  index = -1;
  map < PlotterBase *, int > ::iterator first
    = m_cut_map.find ( plotter );

  if ( first == m_cut_map.end () ) { // not found
    index = 0;
    m_cut_map [ plotter ] = index;
  }
  else {
    index = first -> second;
  }
  int count = m_selCutComboBox -> count ();
  if ( index >= count ) {
    index = count -1;
    m_cut_map [ plotter] = index;
  }

  m_selCutComboBox -> setCurrentItem ( index );
  updateCutEnableButton ();
}

void
Inspector::
updateCutEnableButton ( )
{
  if ( m_tuple_cuts.empty () ) return;

  int index = m_selCutComboBox -> currentItem ();
  const TupleCut * cut = m_tuple_cuts [ index ];
  assert ( cut != 0 );
  bool yes = cut -> isEnabled ();
  m_cut_enable_updating = true;
  cutEnablePushButton -> setOn ( ! yes );
  m_cut_enable_updating = false;
}

Axes::Type
Inspector::
getAxes ( unsigned int index )
{
  Axes::Type axis = Axes::Y;

  PlotterBase * plotter = m_tuple_cut_plotters [ index ];
  unsigned int size = m_tuple_cut_plotters.size ();
  for ( unsigned int i = 0; i < size; i++ ) {
    if ( m_tuple_cut_plotters[i] == plotter ) {
      if ( i == index ) {
        axis = Axes::X;
      }
      break;
    }
  }

  return axis;
}

void
Inspector::
updateCutControlValues ( const PlotterBase * cplotter )
{
  m_is_updating = true;
  int index = m_selCutComboBox -> currentItem ();
  const Range & currentRange = m_tuple_cuts[index] -> getRange ();

  Axes::Type cut_axis = Axes::X;
  bool fit_cut = cut_button_group -> selected () == m_cut_fit_radio;
  if ( fit_cut == false ) {
    cut_axis = getAxes ( index );
  }
  const Range & fullRange = cplotter->getRange ( cut_axis, false );

  axisWidget2->updateCutControlValues ( currentRange, fullRange );
  CutController * controller = CutController::instance ();

  bool yes
    = controller -> isZoomPan ( cplotter, cut_axis );
  axisWidget2 -> setZoomPan ( yes );
  axisWidget2->processZoomPanCheckBoxClicked ( currentRange, fullRange );
  m_is_updating = false;
}

void
Inspector::
fillCutsOn ( const PlotterBase * plotter,
             std::vector < PlotterBase * > & cutlist )
{
  cutlist.clear();

  DisplayController * controller = DisplayController::instance ();
  const DataRep * datarep = controller -> activeDataRep ( plotter );
  if ( datarep != 0 ) {
    CutController * cutcontroller = CutController::instance();

    cutcontroller->fillCutList ( datarep, cutlist );
  }
}

const std::vector < const TupleCut * > &
Inspector::
getCutList ( const PlotterBase * plotter ) const
{
  DisplayController * controller = DisplayController::instance ();
  int index = controller -> activeDataRepIndex ( plotter );
  if ( index < 0 ) {
    string what ( "Inspector::getCutList: " );
    what += "no active DataRep in PlotterBase object.";
    throw std::logic_error ( what );
  }
  const DataRep * datarep = plotter -> getDataRep ( index );
  CutController * cut_controller = CutController::instance ();

  return cut_controller -> getCutList ( datarep );
}

void
Inspector::
selectedCutsRadioButton_toggled ( bool selected )
{
  if ( !m_selectedPlotRadioButton->isChecked() ) return;

  // Change the items in the combo box to only cuts over selected datarep.

  PlotterBase * plotter = getPlotter ();
  bool yes = plotter != 0;
  if ( yes ) yes = plotter -> isTargetable ();
  disableCutControls ( yes == false );
  if ( yes == false ) return;

  vector < PlotterBase * > cutlist;

  if ( cut_button_group -> selected () != m_cut_fit_radio ) {
    fillCutsOn ( plotter, cutlist );

    // Clear the combobox and insert the new strings.

    if ( cutlist.empty () ) {
      disableCutControls ( true );
      cutRemovePushButton->setEnabled ( false );
      return;
    }
  }
  else { // fitting cut
    FunctionController * controller = FunctionController::instance ();
    bool yes = controller -> hasFunction ( plotter, 0 ); // any function
    if ( yes ) cutlist.push_back ( plotter );
  }

  updateCutControls ( cutlist );

  if ( m_tuple_cuts.empty () ) {
    disableCutControls ( true );
    cutRemovePushButton->setEnabled ( false );
    return;
  }

  // Update Controls.

  disableCutControls ( false );
  cutRemovePushButton->setEnabled ( true );
  m_cutAddSelected -> setDisabled ( true );
  m_cutAddAll -> setDisabled ( true );

  // Update texts and sliders.

  int index = m_selCutComboBox -> currentItem ();
  const PlotterBase * cut_plotter = m_tuple_cut_plotters [ index ];
  updateCutControlValues ( cut_plotter );
}

void
Inspector::
cutAddSelected ()
{
  // Take the selected cut from cutlistcombobox and add it to selected
  // plotter on canvas.

  // Find the selected cutplotter.

  PlotterBase * cd = getSelectedCut();

  // Find the selected Plotter.
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  // Add the cut to the plotter.
  CutController * controller = CutController::instance();
  controller -> addCut ( cd, plotter );

}

void
Inspector::
cutAddAll ()
{
  PlotterBase * plotter = getPlotter ();
  if ( plotter == 0 ) return;

  CutController * controller = CutController::instance ();
  const vector < PlotterBase * > & cut_list = getDataCutList ( plotter );
  unsigned int size = cut_list.size ();

  for ( unsigned int i = 0; i < size; i++ ) {
    PlotterBase * cut_plotter = cut_list[i];
    controller -> addCut ( cut_plotter, plotter );
  }
}

void
Inspector::cutRemovePushButton_clicked()
{

  // Take the selected cut from cutlistcombobox and remove it from the selected
  // plotter on canvas.

  // Find the selected Plotter.

  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  // Remove the cut from the plotter.

  // Find the selected cutplotter.
  PlotterBase * cd = getSelectedCut();
  CutController::instance() -> removeCut ( cd, plotter );

  if ( m_selectedPlotRadioButton -> isChecked () ) {
    // post event so we don't delete item that sent us the signal.
    PlotterEvent * event = new PlotterEvent ( plotter );
    QApplication::postEvent ( this, event );
  }
}

void
Inspector::
allCutsRadioButton_toggled ( bool selected )
{

  if ( !allCutsRadioButton->isChecked() ) return;

  PlotterBase * plotter = getPlotter ();

  bool yes = plotter != 0;
  if ( yes ) yes = plotter -> isTargetable ();

  disableCutControls ( yes == false );
  if ( yes == false )  return;

  const vector < PlotterBase * > & cutlist = getDataCutList ( plotter );

  // Clear the combobox and insert the new strings.

  updateCutControls ( cutlist );

  if ( cutlist.empty () ) {
    disableCutControls ( true );
    return;
  }

  // Update Controls.

  disableCutControls ( false );
  cutRemovePushButton->setDisabled ( true );
  m_cutAddSelected -> setEnabled ( true );
  m_cutAddAll -> setEnabled ( true );

  // Update texts and sliders.

  const PlotterBase * cut_plotter = cutlist.back ();
  updateCutControlValues ( cut_plotter );
}

/* virtual */
void Inspector::selCutChanged ( )
{
  PlotterBase * cp = getSelectedCut ();
  CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( cp );
  updateCutControlValues ( cut_plotter );

  PlotterBase * plotter = getPlotter (); // the target
  int index = m_selCutComboBox -> currentItem ();
  m_cut_map [ plotter ] = index;

  updateCutEnableButton ();
}

PlotterBase *
Inspector::
getSelectedCut ()
{
  QButton * button = cut_button_group -> selected ();
  if ( button != m_cut_fit_radio ) {
    PlotterBase * plotter = getPlotter ();
    if ( plotter == 0 ) return 0;

    m_last_cut_index = m_selCutComboBox->currentItem();

    return m_tuple_cut_plotters [ m_last_cut_index ];
  }
  else { // fitting cut
    PlotterBase * plotter = getPlotter ();
    if ( plotter == 0 ) return 0;
    FunctionController * controller = FunctionController::instance ();
    bool yes = controller -> hasFunction ( plotter, 0 ); // any function
    if ( yes ) return plotter;
    else return 0;
  }
}

void
Inspector::
cutNew()
{

  // Get the column label from m_CutVariableComboBox1, and create a cut on
  // the selected plotter with that column label. Also update the list of
  // cuts and the high and low range.

  PlotterBase * plotter = getPlotter ();
  bool yes = plotter != 0;

  if ( yes ) yes = plotter -> isTargetable ();
  if ( yes == false ) {
    int index = plotter -> activePlotIndex ();
    if ( index <  0 ) {
      multipleDataRepError ( "Cut" );
    }
    else { // must be a function
      const string message ( "Can not apply cut to a function" );
      QMessageBox::information ( this, /* parent */
                                 "Cut application error",
                                 message.c_str (),
                                 QMessageBox::Ok,
                                 Qt::NoButton,
                                 Qt::NoButton );
    }
    return;
  }

  DisplayController * controller = DisplayController::instance ();
  int index = controller->activeDataRepIndex ( plotter );
  assert ( index >= 0 );

  vector < string > bindings;
  QButton * button = cut_button_group -> selected ();
  int id = cut_button_group -> id ( button );

  if ( button != m_cut_fit_radio ) {
#if QT_VERSION < 0x030100 // 3.1.0
    string label1 ( m_CutVariableComboBox1 -> currentText() );
    string label2 ( m_CutVariableComboBox2 -> currentText() );
#else
    QString text1 = m_CutVariableComboBox1 -> currentText();
    string label1 = text1.latin1();
    QString text2 = m_CutVariableComboBox2 -> currentText();
    string label2 = text2.latin1();
#endif

    switch ( id ) {
    case 0 : // 1d data cut
      bindings.push_back( label1 );
      break;
    case 1 : // 2d data cut
      bindings.push_back( label1 );
      bindings.push_back( label2 );
    break;
    }
  }
  else {
    const Range & range = plotter -> getRange ( Axes::X, false );
    FunctionController * f_controller = FunctionController::instance ();
    f_controller -> setFitRange ( plotter, range );
  }

  CanvasWindow * canvas = WindowController::instance () ->currentCanvas();
  if ( canvas == 0 ) return;

  if ( id < 2 ) {
    CutController * cutcontroller = CutController::instance();
    PlotterBase * cutplotter = cutcontroller -> addCut ( plotter, bindings );
    canvas -> addPlotDisplay ( cutplotter, false );
  }

  // Update other guys.
  selectedCutsRadioButton_toggled ( true );
  allCutsRadioButton_toggled ( true );
}

int
Inspector::
findCutIndex ( const QString & label )
{
  int index = -1;

  int size = m_selCutComboBox -> count ();
  for ( int i = 0; i < size; i++ ) {
    QString text = m_selCutComboBox -> text ( i );
    if ( text == label ) {
      index = i;
      break;
    }
  }
    return index;
}

void
Inspector::
updateCutsTab ()
{
  if ( m_new_plot_box->isEnabled () == false ) return;

  PlotterBase * plotter = getPlotter ();
  bool yes = plotter != 0;
  m_new_cut_box->setEnabled ( yes );

  if ( yes ) yes = plotter -> isTargetable ();
  m_cut_selected_box->setEnabled ( yes );

  if ( yes ) {
    QButton * button = cut_button_group -> selected ();
    FunctionController * controller = FunctionController::instance ();
    yes = controller -> hasFunction ( plotter, 0 ); // any function
    m_cut_fit_radio -> setEnabled ( yes );
    bool is_fit_radio = button == m_cut_fit_radio;
    if ( yes == false && is_fit_radio ) {
      m_cut_data1 -> setChecked ( true );
    }

    selectedCutsRadioButton_toggled (true  );
    allCutsRadioButton_toggled ( true );

    if ( is_fit_radio == false ) {
      updateDataCutsTab ();
    }
    else {
      updateFitCutsTab ();
    }
  }
}

void
Inspector::
updateFitCutsTab ()
{
}

void
Inspector::
updateDataCutsTab ()
{
  QButton * button = cut_button_group -> selected ();
  int id = cut_button_group -> id ( button );

  if ( id == 0 ) {
    m_CutVariableComboBox2 -> setEnabled ( false );
  }

  PlotterBase * plotter = getPlotter ();
  DisplayController * controller = DisplayController::instance ();
  int index = controller->activeDataRepIndex ( plotter );
  if ( index < 0 ) {
    m_new_cut_box -> setDisabled ( true );
    m_cut_selected_box -> setDisabled ( true );
  }
  else {
    DataRep * datarep = plotter->getDataRep ( index );
    if ( datarep->hasZeroRows() )
      {
        m_new_cut_box->setDisabled ( true );
        m_cut_selected_box->setDisabled ( true );
        return;
      }

    m_new_cut_box->setDisabled ( false );
    const vector < PlotterBase * > & cuts = getDataCutList ( plotter );
    if ( cuts.empty() ) {
      m_cut_selected_box->setDisabled ( true );
    }
    else {
      m_cut_selected_box -> setDisabled ( false );
    }
  }

  updateCutVarGroupBox ( plotter, index );
}

void
Inspector::
setAllCutsActive ( bool yes )
{
  vector < PlotterBase * > plotters;
  fillPlotterList ( plotters );

  if ( plotters.empty () == false ) {
    CutController * controller = CutController::instance ();
    vector < CutPlotter * > cutters;
    controller -> fillCutList ( plotters, cutters );
    vector < CutPlotter * > ::iterator first = cutters.begin ();

    while ( first != cutters.end () ) {
      CutPlotter * cutter = *first++;
      cutter -> setActive ( yes );
    }
  }
}

void
Inspector::
updateCutVarGroupBox ( const PlotterBase * plotter, int index )
{
  const DataSource * tuple
    = DisplayController::instance() -> getNTuple ( plotter, index );

  if (!tuple) return;
  m_CutVariableComboBox1->clear();

  const vector < string > & cols = tuple->getLabels();
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
    vector < string > ::const_iterator first = cols.begin ();
  while ( first != cols.end() ) {
    const string & str = *first++;
    m_CutVariableComboBox1 -> insertItem ( str.c_str() );
    m_CutVariableComboBox2 -> insertItem ( str.c_str() );
  }

  m_CutVariableComboBox1 -> setCurrentItem ( 0 );
  m_CutVariableComboBox2 -> setCurrentItem ( 0 );

  cut_button_group -> setEnabled ( true );
  QButton * button = cut_button_group -> selected ();
  int id = cut_button_group -> id ( button );
  if ( id == 1 ) {
    m_CutVariableComboBox2 -> setEnabled( true );
  }
}


void
Inspector::
on_cut_button_group_clicked ( int id )
{
  switch  ( id ) {
  case 0 : // 1d data cut
    m_CutVariableComboBox1 -> setEnabled ( true );
    m_CutVariableComboBox2 -> setEnabled ( false );
    break;
  case 1 : // 2d data cut
    m_CutVariableComboBox1 -> setEnabled ( true );
    m_CutVariableComboBox2 -> setEnabled ( true );
    break;
  case 2 : // fit cut
    m_CutVariableComboBox1 -> setEnabled ( false );
    m_CutVariableComboBox2 -> setEnabled ( false );
    break;
  }

  updateCutsTab (); // in case of switching from data to fitting
}

void
Inspector::
updateFunctionsTab ()
{
  // Get available function names from the function factory and put them
  // in the newFunctionsComboBox.
  const vector < string > & names = FunctionFactory::instance() -> names ();
  int current = newFunctionsComboBox->currentItem ();
  if ( newFunctionsComboBox -> count () !=
       static_cast < int > ( names.size () ) ) {
    newFunctionsComboBox->clear();

    for ( unsigned int i = 0; i < names.size(); i++) {
      if ( names[i] != "Linear Sum" ) {
        newFunctionsComboBox->insertItem ( names[i].c_str() );
      }
    }
  }

 PlotterBase * plotter = getPlotter();
  bool yes = plotter != 0;
  m_func_new->setEnabled ( yes );

  if ( yes ) yes = plotter -> isTargetable ();
  functionsRemoveButton -> setEnabled ( yes );
  functionsFitToDataButton -> setEnabled ( yes );
  functionsResetButton -> setEnabled ( yes );
  functionsAppliedComboBox -> setEnabled ( yes );
  m_func_parms->setEnabled ( yes );
  m_resid->setEnabled ( yes );
  m_func_parms -> setEnabled ( yes );
  if ( yes == false ) {
    m_functionRep = 0;
    functionsAppliedComboBox -> clear();
    return;
  }

  const DataSource * nt
    = DisplayController::instance()->getNTuple ( plotter );

  if ( nt && nt -> empty () )
    {
      m_func_new->setDisabled ( true );
      functionsRemoveButton -> setEnabled ( false );
      functionsFitToDataButton -> setEnabled ( false );
      functionsResetButton -> setEnabled ( false );
      functionsAppliedComboBox -> clear ();
      functionsAppliedComboBox -> setEnabled ( false );
      m_func_parms->setDisabled ( true );
      m_functionRep = 0;
      return;
    }

  // Update new functions section //
  //------------------------------//
  newFunctionsAddButton->setEnabled ( true );
  m_func_new->setEnabled ( true );

  newFunctionsComboBox->setCurrentItem(current);
  newFunctionsComboBox->setEnabled ( true );

  // Update functionsAppliedComboBox. //
  //----------------------------------//
  bool to_enable = false;
  DisplayController * d_controller = DisplayController::instance ();
  int index = d_controller -> activeDataRepIndex ( plotter );

  FunctionController * f_controller = FunctionController::instance ();

  if ( index >= 0 ) {
    DataRep * datarep = plotter ->getDataRep ( index );
    if ( f_controller -> hasFunction ( plotter, datarep ) ) {

      const vector < string > & fnames
        = f_controller -> functionNames ( plotter, datarep );
        
      if ( fnames.size() != 0 )
        {
          to_enable = true;
          functionsAppliedComboBox->clear();
          m_functionIndexMap.clear();
        
          for ( unsigned i = 0; i < fnames.size(); i++)
            {
              if ( fnames[i].find ( "Linear Sum" ) == string::npos )
                {
                  functionsAppliedComboBox->insertItem ( fnames[i].c_str() );
                  m_functionIndexMap.push_back ( i );
                }
            }
          functionsAppliedComboBox->setCurrentItem (0);
        }
    }
  }

  functionsRemoveButton -> setEnabled ( to_enable );
  functionsFitToDataButton -> setEnabled ( to_enable );
  functionsResetButton -> setEnabled ( to_enable );
  m_func_parms -> setEnabled ( to_enable );
  functionsAppliedComboBox -> setEnabled ( to_enable );
  if ( to_enable == false ) {
    m_FunctionParamsListView -> clear();
    functionsAppliedComboBox -> clear ();
  }

  if ( to_enable )
    {
      // get to original string to avoid possible error in conversion to
      // UNICODE and back.
      const vector < string > & fitters = f_controller -> getFitterNames ();
      Fitter * fitter = f_controller -> getFitter ( plotter );
      string name = "none";
      if ( fitter != 0 ) {
        name = f_controller -> getFitterName ( plotter );
        // Didn't use find because want index
        for ( unsigned int i = 0; i < fitters.size(); i++ ) {
          if ( name == fitters[i] )
            {
              m_fitter_names -> setCurrentItem ( i );
              break;
            }
        }
      }
    }

  m_resid->setEnabled ( to_enable );

  // Update function parameters tab //
  //--------------------------------//

  // Set Parameters in list view as well as in line editor and
  // the check box. Focus is set to the current selected item
  // or in case none is selected 1st item.
  if ( to_enable ) setParameters ( index, plotter );

  // Set the slider to be in the center
  m_FunctionParamsSlider -> setValue(50);

}

/* Updates the tabbed pane that contains the ellipse options*/
void Inspector::updateErrorEllipseTab()
{
  // Clear the error ellipsoid boxes.
  m_ComboBoxEllipsoidParamX -> clear();
  m_ComboBoxEllipsoidParamY -> clear();

  // We by default set the ConfidenceEllipsoidsGroupBox active
  // and disable it on a case by case basis as done below.
  m_ConfidenceEllipsoidsGroupBox -> setDisabled( false );

  // Check if there is plotter, if no then disable the entire panel and return.
  PlotterBase * plotter = getPlotter ();
  TextPlotter * text = dynamic_cast < TextPlotter * > ( plotter );
  bool disable = plotter == 0 || text != 0;

  int index = -1;
  if ( plotter != 0 ) {
    DisplayController * dc = DisplayController::instance ();
    index = dc -> activeDataRepIndex ( plotter );
    disable |= index < 0;
  }

  if ( disable )
    {
      m_ConfidenceEllipsoidsGroupBox -> setDisabled( true );
      return;
    }

  // Check if this plotter has a parent plotter. If there is a parent
  // plotter set plotter to parent plotter and proceed as if focus
  // was on this parent plotter.
  PlotterBase* parentPlotter = plotter -> getParentPlotter();

  if( parentPlotter == 0 )
    {
      DisplayController * dcontroller = DisplayController::instance ();
      index = dcontroller -> activeDataRepIndex ( plotter );
      plotter = plotter;
      m_PushButtonNewErrorPlot -> setText( QString( "New Error Plot" ) );
    }
  else
    {
      index = plotter -> getParentDataRepIndex();
      plotter = parentPlotter;
      m_PushButtonNewErrorPlot -> setText( QString( "Change Error Plot" ) );
    }


  // Check if there is a ntuple associated with the plotter,
  // if no then disable the entire panel and return.
  const DataSource * nt
    = DisplayController::instance()->getNTuple ( plotter );

  if ( nt && nt -> empty () )
    {
       m_ConfidenceEllipsoidsGroupBox -> setDisabled( true );
       return;
    }

  DataRep * datarep = plotter -> getDataRep ( index );
  // Check if there is a function attached to this plotter.
  // If we get answer as no then disable the entire panel and return.
  FunctionController * fcontroller = FunctionController::instance ();
  if ( ! ( fcontroller -> hasFunction ( plotter, datarep ) ) )
    {
      m_ConfidenceEllipsoidsGroupBox -> setDisabled( true );
      return;
    }

  // Get the free parameter names
  FunctionRep * frep = fcontroller -> getFunctionRep( plotter, datarep );
  vector < string >  paramNames;
  const vector < string > & names = frep -> parmNames ();
  const vector < int > & fixed = frep -> getFixedFlags ();
  unsigned int size = names.size ();

  for ( unsigned int i = 0; i < size; i++ ) {
    if ( fixed [i] == 0 ) {
      paramNames.push_back ( names [i] );
    }
  }

  for( unsigned int i = 0; i < paramNames.size(); i++ )
    {
      m_ComboBoxEllipsoidParamX -> insertItem ( paramNames[i].c_str() );
      m_ComboBoxEllipsoidParamY -> insertItem ( paramNames[i].c_str() );
    }

  // Set the initial positioning in function controller as
  // 0 for both the parameters which is the default position
  // for the confidence ellipsoid paramter combo boxes.
  fcontroller -> setEllpsoidParamIndex( Axes::X, 0 );
  fcontroller -> setEllpsoidParamIndex( Axes::Y, 0 );
}

void
Inspector::
functionsRemoveButton_clicked()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  // Get the index of the function selected in functionsAppliedComboBox.
  int count = functionsAppliedComboBox -> count ();
  if ( count <= 0 ) return;
  QString qstr = functionsAppliedComboBox->currentText();

  int item = functionsAppliedComboBox -> currentItem();
  unsigned int funcindex = m_functionIndexMap[item];

  // Remove the function.
  FunctionController::instance() -> removeFunction ( plotter, funcindex );

  // Set Active Plot.
  if ( plotter->activePlotIndex ( ) != 0 )
    plotter->setActivePlot ( -1, true );
  else
    plotter->setActivePlot ( 0, true );

  // Update the rest.
  updateFunctionsTab();
  updateErrorEllipseTab();
}

void
Inspector::
functionsResetButton_clicked()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  DisplayController * dcontroller = DisplayController::instance ();
  int index = dcontroller -> activeDataRepIndex ( plotter );
  if ( index < 0 ) return;
  DataRep * datarep = plotter -> getDataRep ( index );

  FunctionController * fcontroller = FunctionController::instance();
  if ( ! ( fcontroller -> hasFunction ( plotter, datarep ) ) ) {
    return;
  }

  fcontroller -> restoreParameters ( plotter );

  // Set the parameters
  setParameters ( index, plotter );
}

void
Inspector::
setParameters ( int index, PlotterBase * plotter )
{
  m_FunctionParamsListView -> clear();
  m_FunctionParamsCheckBox -> setChecked( false );
  m_FunctionParamsLineEdit -> clear();

  DataRep * datarep = plotter -> getDataRep ( index );
  assert ( datarep != 0 );

  FunctionController * controller = FunctionController::instance ();
  if ( ! ( controller -> hasFunction ( plotter, datarep ) ) )
    {
      m_func_parms -> setDisabled ( true );
      m_functionRep = 0;
      return;
    }

  m_func_parms -> setEnabled ( true );


  const vector < string > & fnames
    = controller -> functionNames ( plotter, datarep );

  if ( fnames.empty () ) {
    m_func_parms -> setDisabled ( true );
    m_functionRep = 0;
    return;
  }

#if defined(QT_NO_STL) || QT_VERSION < 0x030100
  QString qyes( string("Yes").c_str() );
  QString qno( string("No").c_str() );
#else
  QString qyes( string("Yes") );
  QString qno( string("No") );
#endif

  FunctionRep * frep = controller -> getFunctionRep( plotter, datarep );
  m_functionRep = frep;

  const vector < string > & paramNames = frep -> parmNames();
  vector < int >   fixedFlags;
  Fitter * fitter = frep -> getFitter ();
  if ( fitter != 0 ) {
    fixedFlags = frep -> getFixedFlags();
  }
  const vector < double > & parameters = frep -> parameters();
  const vector < double > & principleErrors =  frep -> principleErrors();

  unsigned int size = paramNames.size ();
  assert ( size == parameters.size() );

  for( unsigned int pindex = 0; pindex < size; pindex++ )
    {
#if QT_VERSION < 0x040000
      QListViewItem * item
        = new QListViewItem ( m_FunctionParamsListView );
#else
      Q3ListViewItem * item
        = new Q3ListViewItem ( m_FunctionParamsListView );
#endif
      item -> setText( 0, QString( "%1" ).arg( pindex + 1 ) );

#if defined(QT_NO_STL) || QT_VERSION < 0x030100
      QString pname (  paramNames[ pindex ].c_str() );
#else
      QString pname (  paramNames[ pindex ] );
#endif
      QString fixedFlag ( qno );
      if ( fitter != 0 ) {
        fixedFlag = ( fixedFlags[ pindex ] != 0 ) ? qyes : qno;
      }

      item -> setText( 1, QString( "%1" ).arg( pname ) );
      item -> setText( 2, QString( "%1" ).arg( fixedFlag ) );
      item -> setText( 3, QString( "%1" ).arg( parameters[ pindex ] ) );
      if ( principleErrors.empty () ) {
        item -> setText ( 4, QString ( "nil" ) );
      }
      else{
        item -> setText( 4, QString( "%1" ).arg( principleErrors[ pindex ] ));
      }
      item -> setText( 5, QString( "%1" ).arg( pindex ) ); // This is a hack

      m_FunctionParamsListView -> insertItem( item );
    }

  m_FunctionParamsListView -> setAllColumnsShowFocus ( true );
#if QT_VERSION < 0x040000
  QListViewItem * firstItem = m_FunctionParamsListView -> firstChild ();
#else
  Q3ListViewItem * firstItem = m_FunctionParamsListView -> firstChild ();
#endif
  if ( firstItem != 0 ) {
    m_FunctionParamsListView -> setSelected ( firstItem, true );
    m_FunctionParamsListView -> setCurrentItem ( firstItem );

    QString fixedFlag = firstItem -> text( 2 );
    m_FunctionParamsCheckBox->setChecked( ( fixedFlag == qyes ) ? 
                                          true : false );
    m_FunctionParamsLineEdit -> setText ( firstItem -> text( 3 ) );
  }
}

void
Inspector::
functionAdd ()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  bool yes = plotter -> isTargetable ();
  if ( yes == false ) {
    multipleDataRepError ( "function" );
    return;
  }

  DisplayController * dc = DisplayController::instance();

  DataRep * datarep = dc -> activeDataRep ( plotter );
  assert ( datarep != 0 );

  if ( !datarep->acceptFunction(1) ){
    functionAddError ();
    return;
  }

  // Get the selected function name.

  QString qstr  =  newFunctionsComboBox->currentText();
  std::string fun_name = qstr.latin1();

  // Add the function.

  QString s = m_fitter_names -> currentText ( );
  const string fit_name = s.latin1();

  FunctionController * fc = FunctionController::instance();
  yes = fc -> isCompatible ( fun_name, fit_name );

  if ( yes == false ) {
    incompatibleFunctionError ( fun_name );
    return;
  }

  int index = fc->addFunction ( plotter, fun_name, datarep );
  if ( index < 0 ) return;

  index = m_fitter_names -> currentItem ();
  fitterNamesActivated ( index ); // sets the fitter

  functionsRemoveButton -> setEnabled ( true );
  functionsFitToDataButton -> setEnabled ( true );
  functionsResetButton -> setEnabled ( true );
  functionsAppliedComboBox -> setEnabled ( true );
  fc->saveParameters ( plotter );

  fc -> tryFitFunction ( plotter, datarep ); // try fit

  // Update other tabs that need it.

  updateFunctionsTab();
  updateErrorEllipseTab();
  updateSummaryTab ();

  // Set the current item in functionsAppliedComboBox as the function
  // added just now.
  int curitem = 0;
  for ( int i = 0; i < functionsAppliedComboBox -> count(); i++ )
    if ( newFunctionsComboBox -> currentText() ==
         functionsAppliedComboBox -> text (i) )
      {
        curitem = i;
        break;
      }

  functionsAppliedComboBox->setCurrentItem ( curitem );
}

void
Inspector::
fitterNamesActivated ( int index )
{
  PlotterBase * plotter = getPlotter ();
  if ( plotter != 0 ) {
    FunctionController * controller = FunctionController::instance ();
    const DataRep * datarep = plotter -> getTarget ();
    bool yes = controller -> hasFunction ( plotter, datarep );
    if ( yes ) {
      const vector < string > & fitters = controller -> getFitterNames ();
      bool ok = controller -> setFitter ( plotter, fitters[index] );
      if ( ok == false ) {
        incompatibleFitterError ( fitters[index] );
        functionsFitToDataButton -> setEnabled ( false );
      }
    else functionsFitToDataButton -> setEnabled ( true );
    }
  }
}

void
Inspector::
functionsFitToDataButton_clicked()
{

  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  FunctionController * fcnt = FunctionController::instance();
  if ( ! ( fcnt -> hasFunction ( plotter, 0 ) ) ) { // any function
    return;
  }

  fcnt -> saveParameters ( plotter );

  // Find the index of the function selected.

  int count = functionsAppliedComboBox -> count ();
  if ( count <= 0 ) return;
  QString qstr = functionsAppliedComboBox->currentText();

  // fit to composite, if there is one.
  FunctionRep * fun_rep = fcnt ->getFunctionRep ( plotter );
  bool ok = fcnt -> fitFunction ( plotter, fun_rep );
  if ( ! ok ) {
    const string message ( "The Fit failed to converge" );
    QMessageBox::critical ( this, // parent
                            "Fit failed",
                            message.c_str (),
                            QMessageBox::Ok,
                            Qt::NoButton,
                            Qt::NoButton );
  }

  // Set the parameters
  DisplayController * dcontroller = DisplayController::instance ();
  int index = dcontroller -> activeDataRepIndex ( plotter );

  setParameters ( index, plotter );
}

void
Inspector::
statsStripValue ( QRadioButton * box )
{
  QString text_str = box -> text ();
  int i = text_str.find ( "=" );
  text_str.remove ( i + 1, 1024 );
  box -> setText ( text_str );
}

/* virtual */
void Inspector::updateSummaryTab()
{
  if ( m_new_plot_box->isEnabled() == false ) return;

  PlotterBase * plotter = getPlotter();
  bool yes = plotter == 0;
  if ( yes == false ) {
    TextPlotter * text = dynamic_cast < TextPlotter * > ( plotter );
    yes |= text != 0;
  }
  bool enable = ! yes;
  m_summary->setEnabled ( enable );

  if ( enable == false ) return;

  DisplayController * dcontroller = DisplayController::instance ();
  const DataSource * nt = dcontroller -> getNTuple ( plotter );

  if ( nt && nt -> empty ()  ) {
    m_summary->setEnabled ( false );
    return;
  }

  enable = false; // might be changed below...
  int index = dcontroller -> activeDataRepIndex ( plotter );
  if ( index >= 0 ) {
    DataRep * datarep = plotter -> getDataRep ( index );
    FunctionController * controller = FunctionController::instance();

    enable = controller->hasFunction ( plotter, datarep );
  }
  if ( enable == false ) {
    if ( m_stats_fparms->isChecked () ||
         m_stats_chi->isChecked () ) {
      m_stats_number->setChecked ( true );
    }
  }

  m_stats_fparms->setEnabled ( enable );
  m_stats_chi->setEnabled ( enable );

  yes = index < 0;

  m_stats_number->setDisabled ( yes );
  m_stats_avg_x->setDisabled ( yes );
  m_stats_avg_y->setDisabled ( yes );
  m_stats_text->setDisabled ( yes );
  yes = m_stats_text -> isChecked ();
  m_statsTextField ->setEnabled ( yes );

  statsStripValue ( m_stats_number );
  statsStripValue ( m_stats_avg_x );
  statsStripValue ( m_stats_avg_y );

  if ( index >= 0 ) {
    int number = dcontroller -> getNumberOfEntries ( plotter, index );
    QString text = m_stats_number -> text ();
    QString str;
    str.setNum ( number );
    text += " ";
    text += str;
    m_stats_number -> setText ( text );

    double average = dcontroller -> getAverage ( plotter, Axes::X, index );
    text = m_stats_avg_x -> text ();
    str.setNum ( average );
    text += " ";
    text += str;
    m_stats_avg_x -> setText ( text );

    average = dcontroller -> getAverage ( plotter, Axes::Y, index );
    text = m_stats_avg_y -> text ();
    str.setNum ( average );
    text += " ";
    text += str;
    m_stats_avg_y -> setText ( text );
  }

  updateErrorEllipseTab ();
}

void
Inspector::
statsButtonGroupClicked ( int )
{
  bool yes = m_stats_text -> isChecked ();
  m_statsTextField -> setEnabled ( yes );
}

void Inspector::
summaryNew ()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;

  DisplayController * d_controller = DisplayController::instance ();
  int index = d_controller->activeDataRepIndex ( plotter );
  if ( index < 0 ) {
    multipleDataRepError ( "summary" );
    return;
  }

  CanvasWindow * canvas = WindowController::instance () ->currentCanvas();

  string nullstring ("");

  if ( m_stats_number->isChecked() )
    {
      const string s ("Total Entries");
      canvas->addTextDisplay ( plotter, s, nullstring );
    }

  else if ( m_stats_avg_x->isChecked() )
    {
      const string s ("averagex");
      canvas->addTextDisplay ( plotter, s, nullstring );
    }

  else if ( m_stats_avg_y->isChecked() )
    {
      const string s ("averagey");
      canvas->addTextDisplay ( plotter, s, nullstring );
    }

  else if ( m_stats_fparms->isChecked() )
    {
      const string s ("Function Parameters");
      FunctionController * controller = FunctionController::instance ();
      assert ( controller -> hasFunction ( plotter, 0 ) );
      canvas->addFuncDisplay ( plotter, s );

    }

  else if ( m_stats_chi->isChecked() )
    {
      const string s ("Chi-squared");
      FunctionController * controller = FunctionController::instance ();
      assert ( controller -> hasFunction ( plotter, 0 ) );
      canvas->addFuncDisplay ( plotter, s );

    }

  else if ( m_stats_text->isChecked() )
    {

      QString qtext = m_statsTextField->text();
      string text (qtext.latin1());

      const string s ("Text From Box");
      canvas->addTextDisplay ( plotter, s, text );

    }
}

void Inspector::createResiduals()
{
  PlotterBase * plotter = getPlotter ();
  if ( plotter == 0 ) return;

  FunctionController * controller = FunctionController::instance ();
  PlotterBase * res_plotter = controller -> createResidualsDisplay ( plotter );
  const Range & range = plotter -> getRange ( Axes::X, false );
  res_plotter -> setRange ( Axes::X, range, false );

  CanvasWindow * canvas = WindowController::instance () -> currentCanvas ();

  canvas -> addPlotDisplay ( res_plotter, true );
}

void Inspector::comboBoxEllipsoidParamXHighlighted( int index )
{
  FunctionController * fcontroller = FunctionController::instance ();
  fcontroller -> setEllpsoidParamIndex( Axes::X, index );
}

void Inspector::comboBoxEllipsoidParamYHighlighted( int index )
{
  FunctionController * fcontroller = FunctionController::instance ();
  fcontroller -> setEllpsoidParamIndex( Axes::Y, index );
}

void
Inspector::
pushButtonNewErrorPlotClicked()
{
  PlotterBase * plotter = getPlotter ();
  if ( plotter == 0 ) return;

  FunctionController * fcontroller = FunctionController::instance ();

  // Just to prevent from creating ellipsoids from plots where
  // there are no Functions fitted and there is no parent plotter
  m_functionRep = fcontroller -> getFunctionRep ( plotter );

  FunctionRep * rep = m_functionRep;
  PlotterBase* parentPlotter = plotter -> getParentPlotter();
  if( rep == 0 && parentPlotter == 0) return;

  // Figure out the two selected labels. Later they shall be used
  // for defining the two axis of the error ellipsoids.
  QString xlabel =  m_ComboBoxEllipsoidParamX -> currentText();
  QString ylabel =  m_ComboBoxEllipsoidParamY -> currentText();

  // Check if these labels are not same. If the labels are same this
  // leads in some cases numerical instabilies leading to a crash.
  // So we give user an error box and return instead.
  if( xlabel == ylabel )
    {
      const QString message =
        "Both enteries of the parameter pair, selected for drawing error\n"
        "ellipsoids are same. Please select  x and y parameters which are\n"
        "different.";

      QMessageBox::critical( this, // parent
                             "Invalid Parameter pair  Selection", // caption
                             message,
                             QMessageBox::Ok,
                             Qt::NoButton,
                             Qt::NoButton );
      return;
    }

  // Create / refresh the error plot
  QString stat = m_PushButtonNewErrorPlot -> text();
  if( stat == QString( "Change Error Plot" ) )
    {
      fcontroller -> refreshEllipsoidDisplay ( plotter );

      plotter -> setLabel( Axes::X, xlabel.latin1() );
      plotter -> setLabel( Axes::Y, ylabel.latin1() );

      updateErrorEllipseTab();

    }
  else // "New Error Plot"
    {
      PlotterBase * err_plotter =
        fcontroller -> createNewEllipsoidDisplay ( plotter );
      assert( err_plotter != 0);

      err_plotter -> setLabel( Axes::X, xlabel.latin1() );
      err_plotter -> setLabel( Axes::Y, ylabel.latin1() );

      CanvasWindow * canvas
        = WindowController::instance () -> currentCanvas ();
      assert( canvas != 0 );

      // Add the plot to the display BUT donot select it. Let mother
      // plot be the one which is selected.
      canvas -> addPlotDisplay ( err_plotter, false );
    }
}

const std::string
Inspector::
convertToString ( hippodraw::Axes::Type axis )
{
  if ( m_axis == Axes::X ) return "X";
  else if ( m_axis == Axes::Y ) return "Y";
  else if ( m_axis == Axes::Z ) return "Z";

  return "nil";
}

void
Inspector::
updateLogBox ()
{
  bool yes = m_plotter_list.empty () == false;

  logScale -> setEnabled ( yes );
  if ( yes ) {
    PlotterBase * plotter = m_plotter_list.front ();
    bool log = DisplayController::instance () -> getLog ( plotter, m_axis );
    logScale -> setChecked ( log );
  }
}

void
Inspector::
updateAutoScaleBox ()
{
  bool yes = m_plotter_list.empty () == false;
  m_autoScale -> setEnabled ( yes );
  if ( yes ) {
    PlotterBase * plotter = m_plotter_list.front ();
    bool scaled = plotter -> isAutoRanging ( m_axis );
    m_autoScale -> setChecked ( scaled );
  }
}

void
Inspector::
updateAxisTab ()
{
  updateLogBox ();
  updateAutoScaleBox ();

  PlotterBase * plotter = getPlotter ();
  bool yes = plotter == 0;
  if ( yes == false ) {
    TextPlotter * text = dynamic_cast < TextPlotter * > ( plotter );
    yes |= text != 0;
  }
  m_axis_frame->setEnabled ( ! yes );

  if ( yes ) return;

  DisplayController * controller = DisplayController::instance ();
  int index = -1;
  if ( plotter -> isTargetable () ) {
    index = controller->activeDataRepIndex ( plotter );
  }

  bool has_ntuple = controller->hasNTupleBindings ( plotter, 0 );
  if ( has_ntuple )
    {
      const DataSource * nt
        = DisplayController::instance()->getNTuple ( plotter );
      if ( nt && nt -> empty () ) return;
    }

  if ( plotter -> hasAxis ( m_axis ) == false ) setZRadioButton ( false );

  const string & label = plotter -> getLabel ( m_axis );
  const QString ltext = label.c_str();
  m_axis_label -> setText ( ltext );

  const string s_axis = convertToString ( m_axis );
  bool axis_bined = controller -> isAxisBinned ( plotter, s_axis );
  const Range & r = plotter->getRange(m_axis, true);
  double low = r.low();
  double high = r.high();

  axisWidget1 -> setLowText ( QString("%1").arg(low),
                              axis_bined == true &&
                              has_ntuple == false );
  axisWidget1 -> setHighText ( QString("%1").arg(high),
                               axis_bined == true &&
                               has_ntuple == false );

  axisWidget1 -> setLowSliderValue( 50 );
  m_lowslider1_last_val = 50;
  axisWidget1 -> setHighSliderValue( 50 );
  m_highslider1_last_val = 50;

  if (  axis_bined == false )
    {
      m_width_text->setEnabled ( false );
      m_width_range->setEnabled ( false );
      m_width_text -> setText ( QString ("%1").arg (0) );

      m_offset_text->setEnabled ( false );
      m_offset_range->setEnabled ( false );
      m_offset_text -> setText ( QString ("%1").arg (0) );
    }
  else
    {
      m_width_text->setEnabled ( true );
      m_width_range->setEnabled ( true );
      double width = plotter->getBinWidth ( m_axis );
      m_width_text -> setText ( QString ("%1").arg (width) );

      m_offset_text->setEnabled ( true );
      m_offset_range->setEnabled ( true );
      double offset = plotter->getOffset ( m_axis );
      m_offset_text -> setText ( QString ("%1").arg (offset) );

      // make read only if not bound to ntuple
      m_width_text->setReadOnly ( ! has_ntuple );
      m_width_range->setEnabled ( has_ntuple );
      m_offset_text->setReadOnly ( ! has_ntuple );
      m_offset_range->setEnabled ( has_ntuple );
    }

  //----------------------------//
  // Handling the log check box //
  //----------------------------//
  bool disable_log = has_ntuple == false && axis_bined == true;
  logScale -> setDisabled ( disable_log );
  m_autoScale -> setDisabled ( disable_log );

  const PeriodicBinaryTransform *pbtf =
    dynamic_cast < const PeriodicBinaryTransform * >
    ( plotter->getTransform() );

  if( pbtf == 0   ) {
    bool log = DisplayController::instance() -> getLog ( plotter, m_axis );

    if( log )
      {
        m_offset_text -> setEnabled( false );
        m_offset_range -> setEnabled( false );
      }
  }


  axisWidget1->setAllDisabled ( false );

  //--------------------------------//
  // Handling of zoom pan check box //
  //--------------------------------//
  bool isZoomPan = false;

  std::map < const PlotterBase *, bool >::const_iterator it
    = m_zoompan.find ( plotter );
  if ( it != m_zoompan.end () )
    isZoomPan = it->second;

  // By defalut for periodic binary transforms (pbtf) zoom pan mode should
  // be set for both X and Y axis. For Z axis setting zoom pan mode does
  // not make sense.
  if( pbtf != 0 && m_axis != Axes::Z)
    axisWidget1->setZoomPan ( true, true );
  else
    axisWidget1->setZoomPan ( isZoomPan );

  axisWidget1->processZoomPanCheckBoxClicked ( r, r );

  yes = false;
  if ( index >= 0 ) {
    const DataRep * datarep = plotter -> getDataRep ( index );
    RepBase * rep = datarep -> getRepresentation ();
    ContourPointRep * contourRep = dynamic_cast < ContourPointRep * > ( rep );
    yes = contourRep != 0;
    if ( yes ) {
      bool user = contourRep->getUsingUserValues();
      contourRadioButton1->setChecked ( !user );
      contourRadioButton2->setChecked ( user );
      contourRadioButton1_toggled ( true );
    }
  }

  m_contourBox->setEnabled ( yes );
}


#if QT_VERSION < 0x040000
void Inspector::functionParamsListViewCurrentChanged( QListViewItem * item )
#else
void Inspector::functionParamsListViewCurrentChanged( Q3ListViewItem * item )
#endif
{
#if defined(QT_NO_STL) || QT_VERSION < 0x030100
  QString qyes( string("Yes").c_str() );
  QString qno( string("No").c_str() );
#else
  QString qyes( string("Yes") );
  QString qno( string("No") );
#endif

  QString fixedFlag = item -> text( 2 );
  m_FunctionParamsCheckBox->setChecked(( fixedFlag == qyes ) ? true : false );
  m_FunctionParamsLineEdit -> setText ( item -> text( 3 ) );
}

void Inspector::functionParamsCheckBoxToggled( bool )
{
  // Check if there is plotter.
  PlotterBase * plotter = getPlotter();
  if ( !plotter ) return;

  // Check if there is a function attached to this plotter.
  FunctionController * fcontroller = FunctionController::instance();
  if ( ! ( fcontroller -> hasFunction ( plotter, 0 ) ) ) {
    return;
  }
  m_functionRep = fcontroller -> getFunctionRep ( plotter );

  // Save old parameters
  fcontroller -> saveParameters ( plotter );

  // Get the fixed flags
  FunctionRep * frep   = m_functionRep;
  vector < int >  fixed;
  Fitter * fitter = frep -> getFitter ();
  if ( fitter != 0 ) {
    fixed = frep -> getFixedFlags();
  }

  // Get the current item and item-number
#if QT_VERSION < 0x040000
  QListViewItem * item = m_FunctionParamsListView -> currentItem();
#else
  Q3ListViewItem * item = m_FunctionParamsListView -> currentItem();
#endif
  if( !item ) return;

  QString pidx = item -> text( 5 ); // As a hack we hide in the 5th place
  int paramindex = pidx.toUInt();   // the index of the parameter

  // Set the new fixed flag for the function
  bool flag = m_FunctionParamsCheckBox -> isChecked();
  if ( fitter != 0 ) {
    fixed[ paramindex ] = flag == true ? 1 : 0;
    frep -> setFixedFlags( fixed );
  }

  // Change the new fixed flag in ListView
#if defined(QT_NO_STL) || QT_VERSION < 0x030100
  QString qyes( string("Yes").c_str() );
  QString qno( string("No").c_str() );
#else
  QString qyes( string("Yes") );
  QString qno( string("No") );
#endif

  QString fixedFlag = ( flag == true ) ? qyes : qno;
  item -> setText ( 2, fixedFlag );

  // So that fix items can be made to go away and free items
  // can be made to appear on the confidence ellipsoid combo box
  // choice list.
  updateErrorEllipseTab();
}


void Inspector::functionParamsLineEditReturnPressed()
{
  // Check if there is plotter.
  PlotterBase * plotter = getPlotter();
  if ( !plotter ) return;

  // Check if there is a function attached to this plotter.
  FunctionController * fcontroller = FunctionController::instance();
  if ( ! ( fcontroller -> hasFunction ( plotter, 0 ) ) )
    return;

  // Save old parameters
  fcontroller -> saveParameters ( plotter );

  // Get the parameters
  FunctionRep * frep   = m_functionRep;
  vector < double >  parameters = frep-> parameters();

  // Get the current item and item-number
#if QT_VERSION < 0x040000
  QListViewItem * item = m_FunctionParamsListView -> currentItem();
#else
  Q3ListViewItem * item = m_FunctionParamsListView -> currentItem();
#endif
  if( !item ) return;

  QString pidx = item -> text( 5 ); // As a hack we hide in the 5th place
  int paramindex = pidx.toUInt();   // the index of the parameter

  // Set the new fixed flag for the function
  QString text = m_FunctionParamsLineEdit -> text();
  parameters[ paramindex ] = text.toDouble();
  frep  -> setParameters( parameters );
  frep  -> setDirty();

  // Change the new parameter in ListView
  item -> setText ( 3, QString ( "%1" ).arg ( parameters[ paramindex ] ) );
}


/* Slot which recieves signal when params slider is presssed. It basically
   stores the old values of parameters */
void Inspector::functionParamsSliderSliderPressed()
{
  // Check if there is plotter.
  PlotterBase * plotter = getPlotter();
  if ( !plotter ) return;

  // Check if there is a function attached to this plotter.
  FunctionController * fcontroller = FunctionController::instance();
  if ( ! ( fcontroller -> hasFunction ( plotter, 0 ) ) )
    return;

  // Save old parameters
  fcontroller -> saveParameters ( plotter );

  // Get the parameters
  FunctionRep * frep   = m_functionRep;
  vector < double >  parameters = frep -> parameters();

  // Get the current item
#if QT_VERSION < 0x040000
  QListViewItem * item = m_FunctionParamsListView -> currentItem();
#else
  Q3ListViewItem * item = m_FunctionParamsListView -> currentItem();
#endif
  if( !item ) return;

  // Save the vector of parameters.
  m_oldParameters = parameters;
}


void Inspector::functionParamsSliderSliderMoved( int )
{
  // Check if there is plotter.
  PlotterBase * plotter = getPlotter();
  if ( !plotter ) return;

  // Check if there is a function attached to this plotter.
  FunctionController * fcontroller = FunctionController::instance();
  if ( ! ( fcontroller -> hasFunction ( plotter, 0 ) ) )
    return;

  // Save old parameters
  fcontroller -> saveParameters ( plotter );

  // Get the parameters
  FunctionRep * frep   = m_functionRep;
  vector < double >  parameters = frep -> parameters();

  // Get the current item and item-number
#if QT_VERSION < 0x040000
  QListViewItem * item = m_FunctionParamsListView -> currentItem();
#else
  Q3ListViewItem * item = m_FunctionParamsListView -> currentItem();
#endif
  if( !item ) return;

  QString pidx = item -> text( 5 ); // As a hack we hide in the 5th place
  int paramindex = pidx.toUInt();   // the index of the parameter

  // Set the new parameters based on the value of the sliders.
  vector < double > newParameters = m_oldParameters;

  int sliderValue = m_FunctionParamsSlider -> value();
  int sign = ( m_oldParameters[ paramindex ] < 0 )? -1:1;

  newParameters[ paramindex ]
    = m_oldParameters[ paramindex ] *
    pow ( 2.0,  static_cast<double>( (sliderValue - 50) * sign) / 50.0 );

  frep -> setParameters( newParameters ); // will set projector dirty

  // Change the new parameter in ListView and LineEdit box
  item -> setText ( 3, QString ( "%1" ).arg ( newParameters[ paramindex ] ) );
  m_FunctionParamsLineEdit ->
    setText ( QString ( "%1" ).arg ( newParameters[ paramindex ] ) );
}

void Inspector::functionParamsSliderSliderReleased()
{
  //Set the slider to mid-point
  m_FunctionParamsSlider -> setValue(50);
}

void Inspector::logScale_clicked()
{
  bool log = logScale -> isChecked();
  bool auto_scale = m_autoScale -> isChecked ();

  vector < PlotterBase * > ::iterator first = m_plotter_list.begin ();

  while ( first != m_plotter_list.end () ) {
    PlotterBase * plotter = *first++;
    DisplayController::instance()-> setLog ( plotter, m_axis, log );
    plotter -> setAutoRanging ( m_axis, auto_scale );
  }
}

void Inspector::autoScale_clicked()
{
  bool scale = m_autoScale -> isChecked ();
  vector < PlotterBase * > ::iterator first = m_plotter_list.begin ();

  while ( first != m_plotter_list.end () ) {
    PlotterBase * plotter = *first++;
    plotter -> setAutoRanging ( m_axis, scale );

    // If the transform be periodic it sets both the offsets to be 0.0
    PeriodicBinaryTransform * tp =
      dynamic_cast< PeriodicBinaryTransform* > ( plotter->getTransform() );
    if ( tp != 0 )
      {
        tp->setXOffset( 0.0 );
        tp->setYOffset( 0.0 );
      }
  }
  updateAxisTab();
}

void Inspector::cutHighSlider_sliderMoved ( int value )
{
  if ( m_is_updating == false ) {
    int index = m_selCutComboBox -> currentItem ();
    PlotterBase * plotter = getSelectedCut();
    Range currentRange = m_tuple_cuts [ index] -> getRange ();
    bool fit_cut = cut_button_group -> selected () == m_cut_fit_radio;

    if ( fit_cut == false ) { //data cut
      Axes::Type axis = getAxes ( index );
      const Range & fullRange = plotter -> getRange ( axis, false );
      axisWidget2 -> processHighSliderMoved ( value, currentRange, fullRange );
      plotter -> setCutRangeAt ( currentRange, axis );
    }
    else { // fit cut
      const Range & fullRange = plotter -> getRange ( Axes::X, false );
      axisWidget2 -> processHighSliderMoved ( value, currentRange, fullRange );
      plotter -> setCutRangeAt ( currentRange, index );
    }
  }
}

void Inspector::cutLowSlider_sliderMoved ( int value )
{
  if ( m_is_updating == false ) {
    PlotterBase * plotter = getSelectedCut();
    int index = m_selCutComboBox -> currentItem ();
    Range currentRange = m_tuple_cuts [ index ] -> getRange ();

    bool fit_cut = cut_button_group -> selected () == m_cut_fit_radio;
    if ( fit_cut == false ) { //data cut
      Axes::Type axis = getAxes ( index );
      const Range & fullRange = plotter -> getRange ( axis, false );
      axisWidget2 -> processLowSliderMoved ( value, currentRange, fullRange );
      plotter -> setCutRangeAt ( currentRange, axis );
    }
    else { // fit cut
      const Range & fullRange = plotter -> getRange ( Axes::X, false );
      axisWidget2 -> processLowSliderMoved ( value, currentRange, fullRange );
      plotter -> setCutRangeAt ( currentRange, index );
    }
  }
}

void Inspector::cutLowSlider_sliderReleased()
{
  PlotterBase * cd = getSelectedCut();
  if ( cd == 0 ) return;
  int index = m_selCutComboBox -> currentItem ();
  Axes::Type axis = getAxes ( index );
  const Range & fullRange = cd->getRange ( axis, false );
  axisWidget2->processLowSliderReleased ( fullRange );
}

void Inspector::cutHighSlider_sliderReleased()
{
  PlotterBase * cd = getSelectedCut();
  if ( cd == 0 ) return;
  int index = m_selCutComboBox -> currentItem ();
  Axes::Type axis = getAxes ( index );
  const Range & fullRange = cd->getRange ( axis, false );
  axisWidget2->processHighSliderReleased ( fullRange );
}

void Inspector::cutZoomPanCheckBox_clicked()
{
  PlotterBase * plotter = getSelectedCut();

  int index = m_selCutComboBox -> currentItem ();
  bool fit_cut = cut_button_group -> selected () == m_cut_fit_radio;

  Axes::Type axis = Axes::X;
  if ( fit_cut == false ) {
    axis = getAxes ( index );
  }
  bool yes = axisWidget2 -> isZoomPanChecked ();
  CutController * controller = CutController::instance ();
  controller -> setZoomPan ( plotter, axis, yes );

  Range currentRange = m_tuple_cuts [ index ] -> getRange ();
  const Range & fullRange = plotter -> getRange ( axis, false );

  axisWidget2 -> processZoomPanCheckBoxClicked ( currentRange, fullRange ) ;
}


void Inspector::cutInvertPushButton_clicked()
{
  PlotterBase * plotter = getSelectedCut ();
  bool fit_cut = cut_button_group -> selected () == m_cut_fit_radio;

  if ( fit_cut == false ) { //data cut
    CutPlotter * cp = dynamic_cast < CutPlotter * > ( plotter );
    cp -> toggleInverted ();
  }
  else {
    int index = m_selCutComboBox -> currentItem ();
    bool state = ! m_tuple_cuts [ index ] -> getInversion ();

    XyPlotter * xyplotter = dynamic_cast < XyPlotter * > ( plotter );
    xyplotter -> setCutInverted ( index, state );
  }
}

void
Inspector::
cutEnablePushButton_toggled ( bool on)
{
  if ( m_cut_enable_updating == true ) return;

  PlotterBase * plotter = getSelectedCut ();
  bool fit_cut = cut_button_group -> selected () == m_cut_fit_radio;

  if ( fit_cut == false ) { //data cut
    CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( plotter );
    cut_plotter -> setEnabled ( ! on );
  }
  else {
    int index = m_selCutComboBox -> currentItem ();
    XyPlotter * xyplotter = dynamic_cast < XyPlotter * > ( plotter );
    xyplotter -> setCutEnabled ( index, ! on );
  }
}

void
Inspector::
colorSelect_2_clicked()
{
  PlotterBase * cplotter = getSelectedCut();
  CutPlotter * cp = dynamic_cast < CutPlotter * > ( cplotter );

  const Color & rep_color = cp -> getCutColor ();
  QColor color ( rep_color.getRed(),
                 rep_color.getGreen(),
                 rep_color.getBlue () );

  color = QColorDialog::getColor ( color );

  if ( color.isValid() == true ) {
    Color c( color.red(), color.green(), color.blue() );
    cp -> setCutColor ( c );
  }
}

void
Inspector::
contourSlider_valueChanged ( int val )
{

  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  DisplayController * controller = DisplayController::instance ();
  int index = controller->activeDataRepIndex ( plotter );
  DataRep * datarep = plotter->getDataRep ( index );

  RepBase * rep = datarep->getRepresentation();
  ContourPointRep * contourRep = dynamic_cast < ContourPointRep * > ( rep );

  if ( !contourRep ) return;

  contourRep->setUsingUserValues ( false );
  contourRep->setNumContours ( val );
  m_numContoursTextBox->setText ( QString("%1").arg ( val ) );

  datarep->notifyObservers();

}

void
Inspector::
contourTextBox_returnPressed()
{

  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  DisplayController * controller = DisplayController::instance ();
  int index = controller->activeDataRepIndex ( plotter );
  DataRep * datarep = plotter->getDataRep ( index );

  RepBase * rep = datarep->getRepresentation();
  ContourPointRep * contourRep = dynamic_cast < ContourPointRep * > ( rep );

  if ( !contourRep ) return;

  QString text = m_numContoursTextBox->text();
  int val = text.toInt();

  if ( val < 1 || val > 100 ) {
    int num = contourRep->getNumContours ();
    m_numContourSlider->setValue ( num );
    m_numContoursTextBox->setText ( QString ("%1").arg ( num ) );
    return;
  }

  contourRep->setUsingUserValues ( false );
  contourRep->setNumContours ( val );
  m_numContourSlider->setValue ( val );

  datarep->notifyObservers();

}

void
Inspector::
contourRadioButton1_toggled ( bool )
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  if ( plotter -> isTargetable () == false ) return;

  DataRep * datarep = plotter -> getTarget ( );
  RepBase * rep = datarep->getRepresentation();

  ContourPointRep * contourRep = dynamic_cast < ContourPointRep * > ( rep );

  if ( !contourRep ) return;

  if ( contourRadioButton1->isChecked() ) {

    m_numContourSlider->setEnabled ( true );
    m_numContoursTextBox->setEnabled ( true );
    m_numContoursLabel->setEnabled ( true );
    m_contourLevelsTextBox->setEnabled ( false );

    int num = contourRep->getNumContours ();
    m_numContourSlider->setValue ( num );
    m_numContoursTextBox->setText ( QString ("%1").arg ( num ) );

    contourSlider_valueChanged ( num );

  }

  else {

    m_numContourSlider->setEnabled ( false );
    m_numContoursTextBox->setEnabled ( false );
    m_numContoursLabel->setEnabled ( false );
    m_contourLevelsTextBox->setEnabled ( true );

    contourLevelsTextBox_returnPressed();

  }

}

void
Inspector::
contourError ()
{
  const QString message =
    "Invalid Input String. Please check that\n"
    "1. The string contains only numbers separated by white spaces, and,\n"
    "2. The numbers are in increasing order without any duplicates.\n";
  QMessageBox::critical ( this, // parent
                          "Invalid Input String", // caption
                          message,
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}

void
Inspector::
contourLevelsTextBox_returnPressed ()
{
  if ( contourRadioButton2->isChecked () == false ) return;

  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  DisplayController * controller = DisplayController::instance ();
  int index = controller->activeDataRepIndex ( plotter );
  DataRep * datarep = plotter->getDataRep ( index );

  RepBase * rep = datarep->getRepresentation();
  ContourPointRep * contourRep = dynamic_cast < ContourPointRep * > ( rep );

  if ( !contourRep ) return;

   const QString qstr1 = m_contourLevelsTextBox->text();
   if ( qstr1.isEmpty () ) return;
   const QString qstr2 = qstr1.simplifyWhiteSpace();

   QTextIStream * stream = new QTextIStream ( &qstr2 );

   vector < double > values;
   double prev = 0, cur = 0;
   bool first = true;

   while ( !stream->atEnd() ){

    QString strval;
    (*stream) >> strval;
    bool ok = true;
    cur = strval.toDouble ( &ok );

    // Check if its a legal double value.

    if ( !ok ) {
      contourError();
      return;
    }

    // Check sorted.

    if ( first ) {
      first = false;
    }
    else {
      if ( cur <= prev ) {
        contourError();
        return;
      }
    }

    // Push value.
    values.push_back ( cur );
    prev = cur;

   }

   contourRep->setContourValues ( values, datarep->getProjector() );
   datarep->notifyObservers();

}


void Inspector::editLabelFontClicked()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  QFont labelFont;
  bool ok;

  XyPlotter * xyplotter = dynamic_cast < XyPlotter * > ( plotter );
  assert ( xyplotter != 0 );

  const FontBase * fb = xyplotter -> labelFont ( m_axis );
  if ( fb == 0 ) {
    labelFont = QFontDialog::getFont ( &ok, this);
  }
  else {
    const QtFont * qtfont = dynamic_cast < const QtFont * > ( fb );
    const QFont & qfont = qtfont -> font ();
    labelFont = QFontDialog::getFont ( &ok, qfont, this);
  }

  if ( ok )
    {
      QtFont * font = new QtFont;
      font -> setFont( labelFont );
      xyplotter -> setLabelFont( font, m_axis );
      xyplotter -> notifyObservers ();
    }
}

void Inspector::editTitleFontClicked()
{
  PlotterBase * plotter = getPlotter ();
  if ( plotter == 0 ) return ;

  XyPlotter * xyplotter = dynamic_cast< XyPlotter* > ( plotter );
  assert( xyplotter != 0 );

  QFont titleFont;
  bool ok;

  const FontBase * fb = xyplotter -> titleFont ();
  if ( fb == 0 ) {
    // From the Qt documentation - "The usual way to use QFontDialog class is
    // to call one of the static convenience functions"
    titleFont = QFontDialog::getFont ( &ok, this );
  }
  else {
    const QtFont * qtfont = dynamic_cast < const QtFont * > ( fb );
    const QFont & qfont = qtfont -> font ();
    titleFont = QFontDialog::getFont ( &ok, qfont, this );
  }

  if ( ok )
    {
      QtFont * font = new QtFont;
      font -> setFont( titleFont );
      xyplotter -> setTitleFont( font );
      xyplotter -> notifyObservers ();
    }
}

---