Inspector.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

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

#include "Inspector.h"

#include "CanvasSelectionEvent.h"
#include "CanvasWindow.h"
#include "PlotterEvent.h"
#include "WindowController.h"
#include "AxisWidget.h"
#include "QtFont.h"

#include <qapplication.h>

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

#include "qtooltip.h"
#include "qcheckbox.h"
#include "qcolordialog.h"
#include "qcombobox.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 "colorreps/BinToColor.h"
#include "controllers/CutController.h"
#include "controllers/DataRepController.h"
#include "controllers/DisplayController.h"
#include "controllers/FunctionController.h"

#include "datareps/FunctionParameter.h"
#include "datareps/CompositeFunctionRep.h"

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

#include "plotters/CutPlotter.h"
#include "plotters/TextPlotter.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 "pattern/string_convert.h"

#include <algorithm>
#include <iostream>
#include <stdexcept>

using std::cout;
using std::endl;

#include <cmath>
#include <cassert>

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

using namespace hippodraw;

namespace {
   void stringTokenize(std::string input, const std::string & delimiters,
                       std::vector<std::string> & tokens, bool clear=true) {
      if (clear) {
         tokens.clear();
      }
      std::string::size_type j;
      while ( (j = input.find_first_of(delimiters)) != std::string::npos ) {
         if (j != 0) {
            tokens.push_back(input.substr(0, j));
         }
         input = input.substr(j+1);
      }
      tokens.push_back(input);
      if (tokens.back() == "") {
         tokens.pop_back();
      }
   }
}

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


Inspector::
Inspector ( QWidget * parent, const char * name, bool modal, Qt::WFlags flags )
  : InspectorBase ( parent, name, modal, flags ),
    m_plotter ( 0 ),
    m_is_updating ( false ),
    m_user_models_loaded ( false )
{
  init ();
  FunctionController * controller = FunctionController::instance();
  const vector < string > & names = controller -> getFitterNames ();
    for ( unsigned int i = 0; i < names.size(); i++ ) {
    QString name ( names[i].c_str() );
    m_fitter_names -> insertItem ( name );
  }
#if QT_VERSION < 0x040000
#else // correct code generated by uic3 with release 4.1.1
//     for ( int i = 0; i < 3; i++ ) {
// o      QAbstractButton * b = axis_button_group -> find ( i );
//       axis_button_group -> remove ( b );
//     }
//     radioButton38 = new QRadioButton(axis_button_group);
//     radioButton38->setObjectName(QString::fromUtf8("radioButton38"));
//     radioButton38->setEnabled(true);
//     radioButton38->setGeometry(QRect(10, 0, 65, 30));
//     radioButton38->setMinimumSize(QSize(60, 0));
//     radioButton38->setChecked(true);

//     radioButton39 = new QRadioButton(axis_button_group);
//     radioButton39->setObjectName(QString::fromUtf8("radioButton39"));
//     radioButton39->setEnabled(true);
//     radioButton39->setGeometry(QRect(80, 0, 65, 30));
//     radioButton39->setMinimumSize(QSize(65, 0));
//     radioButton39->setChecked(false);

//     radioButton40 = new QRadioButton(axis_button_group);
//     radioButton40->setObjectName(QString::fromUtf8("radioButton40"));
//     radioButton40->setEnabled(true);
//     radioButton40->setGeometry(QRect(150, 0, 65, 30));
//     radioButton40->setMinimumSize(QSize(65, 0));
//     radioButton40->setChecked(false);

    // add index change for Qt 4
    connect ( m_all_ntuples, SIGNAL ( currentIndexChanged ( int ) ),
              this, SLOT ( dataNTupleSelChanged ( int ) ) );
#endif


  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 ()
{
  DisplayController * controller = DisplayController::instance ();
  delete controller;

}

void
Inspector::
init()
{

  unsigned int n = 5;
  m_new_labels.reserve ( n );
  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_labels.push_back ( new_binding_4 );

  m_new_combos.reserve ( n );
  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_new_combos.push_back ( new_combo_4 );

  m_sel_labels.reserve ( n );
  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_labels.push_back ( sel_binding_4 );

  m_sel_combos.reserve ( n );
  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 );
  m_sel_combos.push_back ( sel_combo_4 );

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

  m_min_entries = 0;
  m_rotate_enable = true;
  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");

  updateValueCombo ();

  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( "Function" ),40 );
  m_FunctionParamsListView -> addColumn( QString( "Params" ),  20 );
  m_FunctionParamsListView -> addColumn( QString( "Value" ),   20 );
  m_FunctionParamsListView -> addColumn( QString( "Error" ),   20 );
  m_FunctionParamsListView -> addColumn( QString( "Fixed"  ),   3 );
  m_FunctionParamsListView -> setSorting ( -1 );

  // vector of QRadioButtons on transform tabbed panel.  Needed for
  // workaround of faulty code generation of Qt 4.1.1
  m_transform_buttons.push_back ( m_linear );
  m_transform_buttons.push_back ( m_logy );
  m_transform_buttons.push_back ( m_logx );
  m_transform_buttons.push_back ( m_logxy );
  m_transform_buttons.push_back ( m_hammer );
  m_transform_buttons.push_back ( m_lambert );
  m_transform_buttons.push_back ( m_Car );
  m_transform_buttons.push_back ( m_Mer );
  m_transform_buttons.push_back ( m_Gls );
  m_transform_buttons.push_back ( m_Arc );
  m_transform_buttons.push_back ( m_Tan );
  m_transform_buttons.push_back ( m_Sin );
  m_transform_buttons.push_back ( m_Stg );
  m_transform_buttons.push_back ( m_Air );
}

void
Inspector::
updateValueCombo ()
{
  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() );
  }
}

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

#if QT_VERSION < 0x040000
void Inspector::customEvent ( QCustomEvent * event )
#else
void Inspector::customEvent ( QEvent * event )
#endif
{
  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 )
    {
#if QT_VERSION < 0x040000
      QButton * b = axis_button_group -> find ( 0 );
#else
      QAbstractButton * b = axis_button_group -> find ( 2 );
#endif
      QRadioButton * button = dynamic_cast< QRadioButton * > ( b );
      button -> setChecked ( true );
      m_axis = Axes::X;
      updateAxisTab ();
    }

#if QT_VERSION < 0x040000
  QButton * button = axis_button_group -> find ( 2 );
#else
  QAbstractButton * button = axis_button_group -> find ( 2 );
#endif

  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;
    case ( 6 ) :
      updateTransformTab ();
      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 ();
  if ( plotter == 0 ) {
    setAllCutsActive ( true );
  }
  else {
    vector < PlotterBase * > cutlist;
    CutController * controller = CutController::instance ();
    controller -> fillCutList ( plotter, cutlist );

    if ( cutlist.empty () ) {
      setAllCutsActive ( false );
      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
{
  string s;
  const vector < string > & names
    = DataSourceController::instance () -> getNTupleNames ();
  int index = m_all_ntuples -> count () == 0 ? -1 : m_all_ntuples -> currentItem ();
  if ( index >= 0 &&
       names.empty () == false ) {
    s = names [ index ];
  }

  return s;
}

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;
    }
  }

  // Update tip tool.
  QToolTip::remove(m_all_ntuples);
  const QString tip=getSelectedDataSourceName().c_str();
  QToolTip::add( m_all_ntuples, tip );

}

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

}

void
Inspector::
changeNTupleName ( const QString & text )
{
  DataSourceController * controller = DataSourceController::instance ();
  vector < DataSource * > nt_vector;
  controller -> getDataSources ( nt_vector ); // get all
  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 )
{
  DataSourceController * controller = DataSourceController::instance ();
  controller -> setCurrentIndex ( item );

  m_all_ntuples -> setCurrentItem ( item );
  QString text ( "" );

  availPlotTypesActivated ( text );

  // Update tip tool.
  QToolTip::remove(m_all_ntuples);
  const QString tip=getSelectedDataSourceName().c_str();
  QToolTip::add( m_all_ntuples, tip );

}

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 );

  DataSourceController * controller = DataSourceController::instance ();
  int index = m_all_ntuples -> currentItem ();
  controller -> setCurrentIndex( index );

  availPlotTypesActivated ( text );
}

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

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

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

void
Inspector::
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::
clear ( std::vector < QLabel * > & labels,
        std::vector < QComboBox * > & combos )
{
  unsigned int size = combos.size ();
  for ( unsigned int i = 0; i < size; i++ ) {
    QComboBox * box = combos [ i ];
    box -> clear ();
    box -> setEnabled ( false );
    QLabel * label = labels [ i ];
    label -> setEnabled ( false );
  }
}

void
Inspector::
availPlotTypesActivated ( const QString & )
{
  int index = m_all_ntuples -> count () == 0 ? -1 : m_all_ntuples -> currentItem ();
  vector < DataSource * > nt_vector;
  DataSourceController::instance() -> getDataSources ( nt_vector );


  int size = static_cast < int > ( nt_vector.size() );
  if ( size == 0 ) {
    clear ( m_new_labels, m_new_combos );
    return;
  }
 

  if ( ! (index < size ) ) {
    index = 0;
  }
  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();

  vector < int > indices;
  unsigned int s = m_new_combos.size ();
  for ( unsigned int i = 0; i < s; i++ ) {
    indices.push_back ( m_new_combos[i] -> currentItem () );
  }
  clear ( m_new_labels, m_new_combos );
  QString qs1;

  if ( index >= 0 ) {
    DataSource * nt = nt_vector[index];
    const vector < string > & cols = nt->getLabels();

    for ( unsigned int i = 0; i < m_new_combos.size (); i++ ) {
      if ( i < bindingOptions.size () ) {
        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" );
          indices[i] = -1;
        }
      }
    }
  }
  

  for ( unsigned int i = 0; i < m_new_combos.size(); i++ ) {
          

    if ( indices[i] >= 0 &&
         indices[i] < m_new_combos[i] -> count () ) {
      m_new_combos[i] ->setCurrentItem ( indices[i] );
    }
  }
  
}

void
Inspector::
updateDataTab()
{

  
  updateNewPlotControls ();
  

  dataClearSelectedControls ();
  

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

  

  if ( plotter != 0 ) {
          
    currentPlot->setEnabled ( true );
    bool yes = plotter -> isTargetable ();
    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 );
  }
  // Update tip tool.
  QToolTip::remove(m_sel_ntuple_name );
  const QString tip = m_sel_ntuple_name -> currentText ();
  QToolTip::add( m_sel_ntuple_name, tip );


}

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;

  clear ( m_sel_labels, m_sel_combos );

  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 QString 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,
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}

void
Inspector::
incompatibleDataRepError ( const std::string & type )
{
  QString message ("Plot of type " );
  message += type.c_str();
  message += " 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,
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}
void
Inspector::
incompatibleFitterError ( const std::string & type )
{
  QString message ( "Fitter of type " );
  message += type.c_str();
  message += " 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,
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}

void
Inspector::
badFunctionError ( const std::string & name, const char * what )
{
  QString message = "Function`";
  message += name.c_str();
  message += "' could not be used because ...\n";
  message += what;
  message +="\nMaybe the copy constructor or clone function is bad.";

  QMessageBox::critical ( this, // parent
                          "Function error", // caption
                          message,
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}

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

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

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

bool
Inspector::
multipleDataRepInfo ( const std::string & type )
{
  bool ok = false;
  QString message ( "Multiple data representations are active.\n"
                    "Apply " );
  message += type.c_str();
  message += " to each?\n\n";

#ifdef Q_OS_MACX
  message += "One can use Control-click to apply a ";
#else
  message += "One can use Command-click to apply a ";
#endif
  message += type.c_str();
  message +=" to a selected data representation.";

  int result = QMessageBox::
    information ( this, // parent
                  "Multiple data representation error", // caption
                  message,
                  QMessageBox::Yes,
                  QMessageBox::No,
                  QMessageBox::NoButton );

  ok = result == QMessageBox::Ok;

  return ok;
}

void
Inspector::
cutOnCutError ()
{
  const QString message ( "Attempt to add cut to itself\n"
                          "The request was ignorned" );
  QMessageBox::information ( this, // parent
                             "Applying cut error", // caption
                             message,
                             QMessageBox::Ok,
                             Qt::NoButton,
                             Qt::NoButton );
}

void
Inspector::
multiplePlotError ( )
{
  const 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 QString message =
    "Functions are not supported on the selected data reaxisWitation.";

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

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

std::string
Inspector::
getArrayTupleLabel( const DataSource * rtuple, const std::string & column )
{
#ifdef HAVE_ROOT
  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();
#else
  return string(); // will not be used.
#endif
}

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

  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 ) ) {
        bool yes = ds -> isUseable ( column );
        if ( yes == false ) {
          const QString
            message ( "This column is not useable because it contains\n"
                      "a multidimension array that varies is size or is\n"
                      "an unsupported data type." );
          QMessageBox::critical ( this, // parent
                                  "DataSource error",
                                  message,
                                  QMessageBox::Ok,
                                  QMessageBox::NoButton,
                                  QMessageBox::NoButton );
          return;
        }

        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 ) {
  catch ( const std::exception & 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() );

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

  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 incompatible, do nothing.
  if ( rep == 0 ) 
    {
      incompatibleDataRepError ( plotTypeStr );
      return;
    }

  rep->set(Color::getColor());

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

  update ();
}

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

  int num_active = plotter->activePlotIndex();
  int num_rep = plotter -> getNumDataReps();

  // If more than one active datarep or only one datarep 
  // in the plot, show warning message and do nothing.
  if (( num_active < 0) || ( num_rep <= 1 ))
    {
      const QString message=
        "You must have more than one DataReps \n"
        "in this view AND only one DataRep \n"
        "selected to be removed.";

      QMessageBox::warning ( this, // parent
                             "Unable to remove DataRep", // caption
                             message,
                             QMessageBox::Ok,
                             Qt::NoButton,
                             Qt::NoButton );
      return;
    }

  DataRep * rep = plotter -> getDataRep( num_active );
  //Reset index before remove the datarep.
  plotter->setActivePlot(-1,false);
  plotter -> removeDataRep ( rep );
  plotter -> autoScale ();
  delete rep;

  update();
}


void
Inspector::
dataCreateNTuple ()
{
  const PlotterBase * plotter = getPlotter ();
  if ( plotter == 0 ) return;
  FunctionController * fc = FunctionController::instance ();
  NTuple * ntuple = fc -> createNTuple ( plotter, 0 );
  DataSourceController::instance () -> registerNTuple ( ntuple );

  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 )
{
  // Update tip tool.
  QToolTip::remove ( m_sel_ntuple_name );
  const QString tip = m_sel_ntuple_name -> currentText ();
  QToolTip::add ( m_sel_ntuple_name, tip );

  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 runtime_error & e ) {
      QString message ( "Could not change binding because\n" );
      message += e.what ();
      QMessageBox::critical ( this, // parent
                              "Data source error",
                              message,
                              QMessageBox::Ok,
                              Qt::NoButton,
                              Qt::NoButton );
    }
  }
}

void
Inspector::
updateColorMapCtrls (const PlotterBase * plotter )
{
  DisplayController * controller = DisplayController::instance ();

  const vector < double > & sv =
    controller -> getValueCtrlPts ( plotter );
  unsigned int size = sv.size ();
  if ( size > 0 ) {
    brk_pt -> setEnabled ( true );
    brk_label -> setEnabled ( true );
    brk_pt -> setValue ( static_cast <int> ( sv[0] * brk_pt -> maxValue() ));
  }
  if ( size > 1 ) {
    flat_width -> setEnabled ( true );
    flatlabel -> setEnabled ( true );
    flat_width->setValue(static_cast <int>( sv[1] * flat_width->maxValue()));
  }
  if ( size > 2 ) {
    color_scale -> setEnabled ( true );
    colorlabel -> setEnabled ( true);
    color_scale->setValue(static_cast<int>( sv[2] * color_scale->maxValue()));
  }
  if ( size < 3 ) {
    color_scale -> setEnabled ( false );
    colorlabel -> setEnabled ( false);
  }
  if ( size < 2 ) {
    flat_width -> setEnabled ( false );
    flatlabel -> setEnabled ( false );
  }
  if ( size < 1 ) {
    brk_pt -> setEnabled ( false );
    brk_label -> setEnabled ( false );
  }
}

void
Inspector::
updatePlotTab()
{ 
  
  loadAllUserModels ();

  bool yes = m_plotter_list.empty();

  m_plot_title -> setDisabled ( yes );

  PlotterBase * plotter = getPlotter ();

  yes = plotter != 0;
  if ( yes ) {
    int number = plotter -> getNumDataReps ();
    int index = plotter -> activePlotIndex ();
    yes = ( number < 2 ) || index >= 0;
  }

  m_plot_symbols->setEnabled ( yes );
//   m_plot_color->setEnabled ( yes );
//   m_selectedColor -> setEnabled ( yes );
  m_interval_le->setEnabled ( yes );
  m_interval_cb->setEnabled ( yes );
  m_errorBars ->setEnabled ( yes );
  m_grid -> setEnabled ( yes );
  m_boxedge->setEnabled ( yes );
  m_pointRepComboBox->setEnabled ( yes );
  if ( yes == false ) {
    m_selectedColor->setPaletteBackgroundColor ( "black" );
    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();

  if ( proj != 0 ) {
    const vector <string> & pointreps = proj -> getPointReps();
        

    if ( pointreps.empty () == false ) {
      for (std::vector<string>::size_type i = 0; i < pointreps.size(); i++ ) {
                  

        m_pointRepComboBox->insertItem ( pointreps[i].c_str() );
      }
    }
    RepBase * rep = datarep->getRepresentation();
        
    const string & curRep = rep->name();
    m_pointRepComboBox->setCurrentText ( curRep.c_str() );
  }

  if ( plotter -> hasAxis ( Axes::Z ) == false ) { // no Z axis (colormap)
    m_value_combo -> setDisabled ( true );
    m_slider_control -> setDisabled ( true );
  }
  else { // has z axis (colormap)

    int jndex = controller -> getValueTransformIndex ( plotter ); // return the index to the list

        
        // of value to color transform names of the plotter. from 0 to size-1
    if ( jndex < 0 ) {  // no value available, jndex=-1
      m_value_combo -> setDisabled ( true );
    }
    else {
      m_value_combo -> setEnabled ( true );
      m_value_combo -> setCurrentItem ( jndex );
     
          // ***************************
         const BinToColor * repp=plotter -> getValueRep ();
         
         if (repp != 0) {
         bool yess = repp -> acceptChangeColor ();
         m_plot_color -> setEnabled (yess);
         m_selectedColor -> setEnabled (yess);
         }
         // *****************************

          bool yes = controller -> hasControlPoints ( plotter ); //return true if the value to color transform has control points
      m_slider_control -> setEnabled ( yes );
      yes = controller -> isUserDefinedValueTransform ( plotter );
      edit_model -> setEnabled ( yes );
      updateColorMapCtrls ( plotter );
    }// end of jndex<0
  }// end of plotter -> hasAxis ( Axes::Z ) == false

  // data source
  const DataSource * nt = controller -> getDataSource ( plotter, 0 );

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

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

  // error bar and show grid checkbox
  m_errorBars->setChecked ( plotter->errorDisplay ( Axes::Y ) );
  m_grid->setChecked ( plotter->getShowGrid () );
  m_boxedge->setChecked (plotter->getBoxEdge ());

  // whether use symbols(triangle,plus,circle...) to represent data
  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 );
  }

  // whether use line(solid, dash...)to represent data
  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 );
  }
  // set the point size
  float ptsize =  controller -> pointSize ( plotter );
  m_symbolPointSize -> setText ( QString ("%1").arg (ptsize) );

  // set color the user choose by RGB
  const Color & color = plotter->repColor ();
  QColor qcolor ( color.getRed(), color.getGreen(), color.getBlue () ); // constructor
  m_selectedColor->setPaletteBackgroundColor ( qcolor );

  // display interval
  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 ) {

    DisplayController * controller = DisplayController::instance ();
    controller -> setValueTransform ( plotter, index );

    const BinToColor * rep = plotter -> getValueRep();
    bool yes = false;
    if ( rep != 0 ) {
      yes = rep -> acceptChangeColor ();
    }
    m_plot_color -> setEnabled ( yes );
    m_selectedColor -> setEnabled ( yes );

     yes = controller -> hasControlPoints ( plotter );
     m_slider_control -> setEnabled ( yes );
     bool y = rep -> isUserDefined ();
     edit_model -> setEnabled ( y );
     if ( yes ) {
       m_is_updating = true;
         updateColorMapCtrls ( plotter );
           m_is_updating = false;
     }
  }
}

void
Inspector::
setAppKey ()
{
  CanvasWindow * canvas = WindowController::instance () ->currentCanvas();
  if ( canvas != 0 ) {
    m_app_key = canvas -> getAppKey ();
    m_model_name  = m_app_key + "/Model Name/";
    m_break_point = m_app_key + "/break point/";
    m_flat_width  = m_app_key + "/flat width/";
    m_color_scale = m_app_key + "/color scale/";
  }
}

void
Inspector::
loadAllUserModels ()
{
  if ( m_user_models_loaded == false ) {    
    setAppKey ();

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

    QString model_name_key ( m_model_name );
    QStringList model_list 
        = settings.entryList ( model_name_key );

    QStringList::size_type size = model_list.size ();
    for ( QStringList::size_type i = 0; i < size ; i++ )
      {
        QString number = model_list [ i ];
        QString name 
          = settings.readEntry ( model_name_key + number );
        
        double brk_pt 
          = settings.readDoubleEntry ( m_break_point + number );
        double flat_width 
          = settings.readDoubleEntry ( m_flat_width + number );
        double color_scale 
          = settings.readDoubleEntry ( m_color_scale + number );

        string mname ( name.latin1() );
        vector < double > cpts;
        cpts.push_back ( brk_pt );
        cpts.push_back ( flat_width );
        cpts.push_back ( color_scale );

        DisplayController * controller = DisplayController::instance ();
        controller -> addValueTransform ( mname, cpts );
      }

    updateValueCombo ();
    m_user_models_loaded = true;
  }
}

void
Inspector::
sliderChanged ( int )
{
  if ( m_is_updating == false ) {
    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 -> setValueCtrlPts (plotter,sv );
    }
  }
}

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


void
Inspector::
convertCtrlPts ( std::vector < double > & sv )
{
  sv.clear();

  int ibp = brk_pt -> value ();
  int ifw = flat_width -> value ();
  int ics = color_scale -> value ();

  double bp = static_cast < double > ( ibp) /
    static_cast <double>( brk_pt -> maxValue () );

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

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

  sv.push_back ( bp );
  sv.push_back ( fw );
  sv.push_back ( cs );
}

void
Inspector::
newColorModel ( )
{
  setAppKey ();

  bool ok = false;
  QString text =  QInputDialog::getText ( "Save color model", // caption
                                          "Enter name", // label
                                          QLineEdit::Normal,
                                          QString::null, // default text
                                          & ok, this );

  if ( ok )
    {
      const string name ( text.latin1() );
      vector < double > sv;
      convertCtrlPts ( sv );
      DisplayController * controller = DisplayController::instance ();
      controller -> addValueTransform ( name, sv );

      updateValueCombo ();

      PlotterBase * plotter = getPlotter ();
      controller -> setValueTransform ( plotter, name );
      int index = controller -> getValueTransformIndex ( plotter );
      m_value_combo -> setCurrentItem ( index );

      QSettings settings;
      settings.insertSearchPath ( QSettings::Windows, s_registry );
      QString model_name_key ( m_model_name );

      QStringList model_list 
        = settings.entryList ( model_name_key );
      
      int iat = 0;
      while ( true ) {
        int index = model_list.findIndex ( QString::number ( iat )) ;
        if ( index == -1 ) break;
        iat++;
      }

      QString at ( QString::number ( iat ) );
      settings.writeEntry ( m_model_name + at, text );
      settings.writeEntry ( m_break_point + at, sv[0] );
      settings.writeEntry ( m_flat_width + at, sv[1] );
      settings.writeEntry ( m_color_scale + at, sv[2] );
    }
}

void
Inspector::
editColorModel ( )
{
  // If it's the first time to save the variable rainbow color scale,
  // we will need special handling. 
  bool isFirstVR = true;
  
  QString item = m_value_combo -> currentText ();
  vector < double > sv;
  convertCtrlPts ( sv );

  PlotterBase * plotter = getPlotter ();
  DisplayController * controller = DisplayController::instance ();
  // Use saveValueCtrlPts instead of setValueCtrlPts to make the 
  // changes effective in this session.
  controller -> saveValueCtrlPts ( plotter, sv );
      
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );

  QString model_name_key ( m_model_name );
  QStringList model_list 
    = settings.entryList ( model_name_key );

#if QT_VERSION < 0x040000
  for ( unsigned int i = 0; i < model_list.size(); i++ ) {
#else
  for ( int i = 0; i < model_list.size(); i++ ) {
#endif
    QString at ( QString::number ( i ) );
    QString name_key ( model_name_key + at );
    QString name = settings.readEntry ( name_key );
    if ( name == item ) {
      settings.writeEntry ( m_break_point + at, sv[0] );
      settings.writeEntry ( m_flat_width + at, sv[1] );
      settings.writeEntry ( m_color_scale + at, sv[2] );
      isFirstVR = false;
      break;
    }
  }

  // For the first time, save the variable rainbow color scale.
  if ( isFirstVR ) {
    // Find the end of the settings.
    int iat = 0;
    while ( true ) {
      int index = model_list.findIndex ( QString::number ( iat )) ;
      if ( index == -1 ) break;
      iat++;
    }
    
    QString at ( QString::number ( iat ) );
    settings.writeEntry ( m_model_name + at, item );
    settings.writeEntry ( m_break_point + at, sv[0] );
    settings.writeEntry ( m_flat_width + at, sv[1] );
    settings.writeEntry ( m_color_scale + at, sv[2] );
  }
}

void
Inspector::
deleteColorModel ( )
{
  QString item = m_value_combo -> currentText ();
  const string name ( item.latin1() );

  DisplayController * controller = DisplayController::instance ();
  bool yes =  controller -> removeValueTransform ( name );  

  if ( yes ) {
    PlotterBase * plotter = getPlotter ();
    controller -> setValueTransform ( plotter, "Rainbow" );

    QSettings settings;
    settings.insertSearchPath ( QSettings::Windows, s_registry );
    QString model_name_key ( m_model_name );
    QStringList model_list 
      = settings.entryList ( model_name_key );
    QStringList::size_type size = model_list.size ();

    for (QStringList::size_type i = 0; i < size; i++ ) {
      QString at ( model_list [ i ] );
      QString name_key ( model_name_key + at );
      QString name = settings.readEntry ( name_key );
      if ( name == item ) {
        settings.removeEntry ( name_key );
        settings.removeEntry ( m_break_point + at );
        settings.removeEntry ( m_flat_width + at );
        settings.removeEntry ( m_color_scale + at );
        break;
      }
    }
    updateValueCombo ();
  }
}

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::warningTex ()
{
    const QString message ( "HippoDraw was not built with TeX support on "
                            "this platfrom." );
    QMessageBox::information ( this, /* parent */
                               "Input error",
                               message,
                               QMessageBox::Ok,
                               Qt::NoButton,
                               Qt::NoButton );
}

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 ];

    /* The size of drawrect, marginrect, need to be updated
       according to title text format. LaTeX format starts with
       "tex:" (case insensitive).
    */
    bool needMargin = String::ci_find(s, "tex:")==0;  
    if ( needMargin ) {
#ifdef HAVE_TEX_UTILS
    plotter -> setTopMargin ( needMargin?10.0:0.0 );
    plotter -> setNeedUpdate(true);
    plotter -> notifyObservers ();
#else
    warningTex ();
    s.erase ( 0, 4 );

#endif
    }
    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 );

}

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 );
}

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() );

    controller -> setPointRep ( plotter, rep );

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

      int index = m_value_combo -> currentItem ();
      controller -> setValueTransform ( plotter, index );
    }

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

void
Inspector::
axis_button_group_clicked ( int id )
{
// #if QT_VERSION < 0x040000
// #else
//   id -= 3; // The re-inserted ones have wrong id
// #endif
  m_axis = hippodraw::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::
entriesDrag ()
{
  int value = min_entries_slider->value ();
  m_dragging = false;
  setMinEntries(value);

  //  min_entries_slider->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.
    plotter -> setBinWidth ( m_axis, width );
  }

  updateAxisTab();
}

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

  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;

  plotter -> setBinWidth ( m_axis, value, m_dragging );
  updateAxisTab ();
}

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

    /* The size of drawrect, marginrect, need to be updated
       according to title text format. LaTeX format starts with
       "tex:" (case insensitive).
    */
    bool needMargin = String::ci_find(ltext, "tex:")==0;
    if ( needMargin ) {
#ifdef HAVE_TEX_UTILS
    if (m_axis==Axes::X)
      plotter -> setBottomMargin ( needMargin?8.0:0.0 );
    else if (m_axis==Axes::Y)
      plotter -> setLeftMargin ( needMargin?0.0:0.0 );
    else if (m_axis==Axes::Z)
      plotter -> setZMargin ( needMargin?7.0:0.0 );
    plotter -> setNeedUpdate(true);
    plotter -> notifyObservers ();
#else
    warningTex();
    ltext.erase( 0, 4 );
#endif
    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 (r.low(), r.high(), r.pos());

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

      // Exchange axes to make the GUI more understandable.
      if ( m_axis == Axes::Y )
        {
          offset = tp->xOffset();
          offset = tp->moduloAddY( offset, incr );
          tp->setXOffset( offset );
        }
      else if ( m_axis == Axes::X )
        {
          offset = tp->yOffset();
          offset = tp->moduloAddX( offset, incr );
          tp->setYOffset( offset );
        }

      
      axisWidget1 -> setHighText ( QString( "%1" ).arg( offset ) );
      if ( m_dragging ) plotter->setRange ( m_axis, range, true, false );
      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) );

  updateAxisTab ();
}

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


  DisplayController * controller = DisplayController::instance ();
  const DataSource * tuple = controller -> getDataSource ( plotter );
  CutController * cutcontroller = CutController::instance();
  return cutcontroller->getCutList ( plotterlist, tuple );
}

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

  int id = cutRadioId ();
  bool fit_cut = id == 2;

  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;
  int id = cutRadioId ();
  bool fit_cut = id == 2;
  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 )
{
  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 ( cutRadioId () != 2 ) {
    CutController * controller = CutController::instance ();
    controller -> fillCutList ( plotter, cutlist );

    // Clear the combobox and insert the new strings.

    if ( cutlist.empty () ) {
      disableCutControls ( true );
      cutRemovePushButton->setEnabled ( false );
      return;
    }
  }
  else { // fitting cut
    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.

  CutPlotter * cp = getSelectedCut();

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

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

}

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

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

  controller -> addCuts ( cut_list, plotter );

  unsigned int size = cut_list.size ();
  for ( unsigned int i = 0; i < size; i++ ) {
    PlotterBase * pb = cut_list[i];
    CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( pb );
    if ( cut_plotter == plotter ) {
      cutOnCutError ();
    }
  }
}

/* Take the selected cut from cutlistcombobox and remove it from the selected
    plotter on canvas.
*/
void
Inspector::
cutRemovePushButton_clicked()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return ;

  bool is_fit_radio = cutRadioId () == 2;
  if ( is_fit_radio ) {
    DisplayController * controller = DisplayController::instance ();
    int index = controller->activeDataRepIndex ( plotter );
    DataRep * rep = plotter -> getDataRep ( index );
    FunctionController::instance () -> removeTupleCut ( plotter, rep );
  }
  else {
    // Find the selected cutplotter.
    CutPlotter * cp = getSelectedCut();
    CutController::instance() -> removeCut ( cp, 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 )
{
  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 );
}

void Inspector::selCutChanged ( )
{
  CutPlotter * cut_plotter = getSelectedCut ();
  updateCutControlValues ( cut_plotter );

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

  updateCutEnableButton ();
}

CutPlotter *
Inspector::
getSelectedCut ()
{
  if ( cutRadioId() != 2 ) {
    PlotterBase * plotter = getPlotter ();
    if ( plotter == 0 ) return 0;

    m_last_cut_index = m_selCutComboBox->currentItem();

    PlotterBase * pb = m_tuple_cut_plotters [ m_last_cut_index ];
    return dynamic_cast < CutPlotter * > ( pb );
  }
  else { // fitting cut
    PlotterBase * pb = getPlotter ();
    CutPlotter * plotter = dynamic_cast < CutPlotter * > ( pb);
    return plotter;
  }
}

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 QString message ( "Can not apply cut to a function" );
      QMessageBox::information ( this, /* parent */
                                 "Cut application error",
                                 message,
                                 QMessageBox::Ok,
                                 Qt::NoButton,
                                 Qt::NoButton );
    }
    return;
  }

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

  const DataRep * rep = plotter -> getDataRep ( index );
  if ( rep -> hasNTupleBindings () == false ) {
      const QString message ( "Can not apply cut to a static histogram" );
      QMessageBox::information ( this, /* parent */
                                 "Cut application error",
                                 message,
                                 QMessageBox::Ok,
                                 Qt::NoButton,
                                 Qt::NoButton );
      return;
  }

  vector < string > bindings;
  int id = cutRadioId ();
  if ( id != 2 ) {
#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;
    }
    CutController * cutcontroller = CutController::instance();
    PlotterBase * cutplotter = cutcontroller -> addCut ( plotter, bindings );
    CanvasWindow * canvas = WindowController::instance () ->currentCanvas();
    if ( canvas == 0 ) return;

    canvas -> addPlotDisplay ( cutplotter, false );
  }
  else {
    DataRep * datarep = plotter -> getDataRep ( index );
    FunctionController * controller = FunctionController::instance ();
    controller -> setTupleCut ( plotter, datarep );
  }

  // 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 ) {
    int id = cutRadioId ();
    bool is_fit_radio = id == 2;
    selectedCutsRadioButton_toggled (true  );
    allCutsRadioButton_toggled ( true );

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

void
Inspector::
updateFitCutsTab ()
{
}

void
Inspector::
updateDataCutsTab ()
{
  int id = cutRadioId ();

  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() -> getDataSource ( plotter, index );

  if (!tuple) return;
  int index1 = -1;
  int index2 = -1;
  if ( m_CutVariableComboBox1 -> count() > 0 ) {
    index1 = m_CutVariableComboBox1 -> currentItem ();
  }
  if ( m_CutVariableComboBox2 -> count() > 0 ) {
    index2 = m_CutVariableComboBox2 -> currentItem ();
  }
  m_CutVariableComboBox1->clear();
  m_CutVariableComboBox2->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() );
  }
  if ( index1 >= m_CutVariableComboBox1 -> count () ) {
    index1 = 0;
  }
  if ( index2 >= m_CutVariableComboBox2 -> count () ) {
    index2 = 0;
  }

  if ( index1 >= 0 ) {
    m_CutVariableComboBox1 -> setCurrentItem ( index1 );
  }
  if ( index2 >= 0 ) {
    m_CutVariableComboBox2 -> setCurrentItem ( index2 );
  }

  cut_button_group -> setEnabled ( true );
  int id = cutRadioId ();
  if ( id == 1 ) {
    m_CutVariableComboBox2 -> setEnabled( true );
  }
}

int
Inspector::
cutRadioId () const
{
  int id = -1;
  if ( m_cut_data1 -> isChecked () ) id = 0;
  if ( m_cut_data2 -> isChecked () ) id = 1;
  if ( m_cut_fit_radio -> isChecked () ) id = 2;

  return id;
}

void
Inspector::
cut_button_group_clicked ( )
{
  int id = cutRadioId ();

  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::
  setSelectedFitter ( const std::string & name )
{
  FunctionController * controller = FunctionController::instance ();
  const vector < string > & fitters = controller -> getFitterNames ();
  for ( unsigned int i = 0; i < fitters.size(); i++ ) {
    if ( name == fitters[i] )
      {
        m_fitter_names -> setCurrentItem ( i );
        break;
      }
  }
}

void
Inspector::
updateFunctionsTab ()
{
  FunctionController * controller = FunctionController::instance ();
  const vector < string > & names = controller -> getFunctionNames ();
  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 );
  m_IgnoreErrorCheckBox -> setEnabled (yes);
  functionsFitToDataButton -> setEnabled ( yes );
  functionsResetButton -> setEnabled ( yes );
  m_resid->setEnabled ( yes );
  if ( yes == false ) {
    return;
  }

  const DataSource * nt
    = DisplayController::instance()->getDataSource ( plotter, 0 );

  if ( nt && nt -> empty () )
    {
      m_func_new->setDisabled ( true );
      functionsRemoveButton -> setEnabled ( false );
      m_IgnoreErrorCheckBox -> setDisabled (true);
      functionsFitToDataButton -> setEnabled ( false );
      functionsResetButton -> setEnabled ( false );
      return;
    }

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

  if ( current >= 0 ) {
    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;
          m_functionIndexMap.clear();
        
          for ( unsigned i = 0; i < fnames.size(); i++)
            {
              if ( fnames[i].find ( "Linear Sum" ) == string::npos )
                {
                  m_functionIndexMap.push_back ( i );
                }
            }
        }
    }
  }

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

  if ( to_enable )
    {
      Fitter * fitter = f_controller -> getFitter ( plotter );
      string name = "none";
      if ( fitter != 0 ) {
        name = f_controller -> getFitterName ( plotter );
        setSelectedFitter ( name );
      }
    }

  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);

}

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

  FunctionRep * frep = getFunctionRep ( );
  FunctionController * controller = FunctionController::instance ();
  controller -> removeFunction ( plotter, frep );
  if ( plotter->activePlotIndex ( ) != 0 )
    plotter->setActivePlot ( -1, true );
  else
    plotter->setActivePlot ( 0, true );

  // Update the rest.
  updateFunctionsTab();
}

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 ) ) )
    {
      return;
    }

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

  if ( fnames.empty () ) {
    return;
  }

  m_function_lv_map.clear ();
  vector < FunctionRep * > freps;
  controller -> fillTopLevelFunctionReps ( freps, plotter, datarep );
  for ( unsigned int i = 0; i < freps.size (); i++ ) {
    FunctionRep * frep = freps [ i ];
    const string & func_name = frep -> functionName ();

#if QT_VERSION < 0x040000
    QListViewItem * parent
      = new QListViewItem ( m_FunctionParamsListView );
#else
    Q3ListViewItem * parent
      = new Q3ListViewItem ( m_FunctionParamsListView );
#endif
    parent -> setOpen ( true );
    parent -> setText ( Index, QString ( func_name.c_str() ) );
    m_function_lv_map [ parent ] = frep;

  //Ignore errors flag, conected with the ignoreError check box.
    bool ignoreFlag = true;

    Fitter * fitter = frep -> getFitter ();
    if ( fitter != 0 ) {
      //Get the ignore errors flag of the current function.
      ignoreFlag = frep -> getIgnoreErrors ();
    }
    const vector < double > & parms = frep -> parameters ();
    unsigned int start_index = parms.size();
    fillFunctionParameters ( parent, frep, start_index );

    m_FunctionParamsListView -> setAllColumnsShowFocus ( true );
#if QT_VERSION < 0x040000
    QListViewItem * firstItem = parent -> firstChild ();
#else
    Q3ListViewItem * firstItem = parent -> firstChild ();
#endif
    m_IgnoreErrorCheckBox -> setChecked(ignoreFlag);

    if ( firstItem != 0 ) {
      m_FunctionParamsLineEdit -> setText ( firstItem -> text( Value ) );
      m_FunctionParamsListView -> setSelected ( firstItem, true );
      m_FunctionParamsListView -> setCurrentItem ( firstItem );
    
      QString fixedFlag = firstItem -> text( Fixed );
      m_FunctionParamsCheckBox->setChecked((fixedFlag == QString ( "Yes" ) ) ? 
                                           true : false );
    }
  }
}

void
Inspector::
#if QT_VERSION < 0x040000
fillFunctionParameters ( QListViewItem * parent,
                         const FunctionRep * frep,
                         unsigned int & index )
#else
fillFunctionParameters ( Q3ListViewItem * parent,
                         const FunctionRep * frep,
                         unsigned int & index )
#endif
{
  const CompositeFunctionRep * composite
    = dynamic_cast < const CompositeFunctionRep * > ( frep );

  if ( composite != 0 ) {
    const vector < FunctionRep * > & freps 
      = composite -> getFunctionReps ();
    unsigned int size = freps.size();

    //  because children are inserted at the beginning, we must do things
    // backwards
    for ( int i = size -1; i >= 0; i-- ) {
      FunctionRep * rep = freps[i];
      const string & func_name = rep -> functionName ();
#if QT_VERSION < 0x040000
      QListViewItem * child
        = new QListViewItem ( parent );
#else
      Q3ListViewItem * child
        = new Q3ListViewItem ( parent );
#endif
      child -> setOpen ( true );
      child -> setText ( Index, QString ( func_name.c_str() ) );
      m_function_lv_map [ child ] = rep;

      fillFunctionParameters ( child, rep, index );
    }
  }
  else { // not composite
    vector < FunctionParameter > function_parameters;
    frep -> fillFunctionParameters ( function_parameters );

    QString qyes( "Yes" );
    QString qno( "No" );

    // Because items are inserted at the begining, we must do things
    // backwards
    unsigned int size = function_parameters.size ();

    for ( int pindex = size-1; pindex >= 0; pindex-- ) {
      FunctionParameter fp = function_parameters[pindex];
      QString dummy;
#if QT_VERSION < 0x040000
      QCheckListItem * item
        = new QCheckListItem ( parent, dummy,
                               QCheckListItem::CheckBox );
#else
      Q3CheckListItem * item
        = new Q3CheckListItem ( parent, dummy,
                                Q3CheckListItem::CheckBox );
#endif
      item -> setText( Index, QString( "%1" ).arg( index-- ) );

      const string & name = fp.name ();
      QString pname = name.c_str();
      QString fixedFlag ( qno );
      fixedFlag = fp.isFixed () ? qyes : qno;

      item -> setText( Name, QString( "%1" ).arg( pname ) );
      item -> setText( Value, QString( "%1" ).arg( fp.value() ) );
      item -> setText( Error, QString( "%1" ).arg( fp.error() ));
      item -> setText( Fixed, QString( "%1" ).arg( fixedFlag ) );
      item -> setText( Dummy, QString( "%1" ).arg( pindex ) );
    }
  }
}

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;
  }

  FunctionRep * new_rep = 0;
  try {
#if QT_VERSION < 0x040000
    QListViewItem * item = m_FunctionParamsListView -> currentItem ();
#else
    Q3ListViewItem * item = m_FunctionParamsListView -> currentItem ();
#endif
    bool is_selected = m_FunctionParamsListView -> isSelected ( item );
    FunctionRep * frep = 0;
    if ( is_selected ) {
      frep = getFunctionRep ( item );
    }

    new_rep = fc->addFunction ( plotter, fun_name, frep, datarep );
  }
  catch ( std::exception & e ) {
    badFunctionError ( fun_name, e.what() );
  }

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

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

  bool ok = false;
  if ( new_rep != 0 ) {
    ok = fc -> tryFitFunction ( plotter, new_rep ); // try fit
  }
  if ( ! ok ) {
    fitFailedError ();
  }
  // Update other tabs that need it.

  updateFunctionsTab();
}

void
Inspector::
fitterNamesActivated ( int index )
{
  FunctionController * controller = FunctionController::instance ();
  const vector < string > & names = controller -> getFitterNames ();
  const string & def_fitter = names [ index ];
  controller -> setDefaultFitter ( def_fitter );

  PlotterBase * plotter = getPlotter ();
  if ( plotter != 0 ) {
    const DataRep * datarep = plotter -> getTarget ();
    bool yes = controller -> hasFunction ( plotter, datarep );
    if ( yes ) {
      bool ok = controller -> changeFitter ( plotter, datarep,
                                             def_fitter );
      if ( ok == false ) {
        incompatibleFitterError ( def_fitter );
        functionsFitToDataButton -> setEnabled ( false );
      }
      else {
        functionsFitToDataButton -> setEnabled ( true );
      }
    }
  }
}

void
Inspector::
fitFailedError ()
{
  const QString message ( "The Fit failed to converge" );
  QMessageBox::critical ( this, // parent
                          "Fit failed",
                          message,
                          QMessageBox::Ok,
                          Qt::NoButton,
                          Qt::NoButton );
}

FunctionRep *
Inspector::
#if QT_VERSION < 0x040000
getFunctionRep ( QListViewItem * item )
#else
getFunctionRep ( Q3ListViewItem * item )
#endif
{
  FunctionRep * rep = 0;
  if ( item != 0 ) {
    item = getTopParent ( item );
    rep = m_function_lv_map [ item ];
  }
  return rep;
}

FunctionRep *
Inspector::
getFunctionRep ()
{
#if QT_VERSION < 0x040000
  QListViewItem * item = m_FunctionParamsListView -> currentItem();
#else
  Q3ListViewItem * item = m_FunctionParamsListView -> currentItem();
#endif

  return getFunctionRep ( item );
}

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 );

  FunctionRep * fun_rep = getFunctionRep ();

  bool ok = fcnt -> fitFunction ( plotter, fun_rep );
  if ( ! ok ) {
    fitFailedError ();
  }

  // Set the parameters