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 <stdexcept>

#include <cmath>
#include <cassert>


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

using namespace hippodraw;


void
Inspector::
stringTokenize ( std::string input, const std::string & delimiters,
                 std::vector<std::string> & tokens, bool clear )
{
      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, index, 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 = getTopFunctionRep ( 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
getTopFunctionRep ( QListViewItem * item )
#else
getTopFunctionRep ( Q3ListViewItem * item )
#endif
{
  FunctionRep * rep = 0;
  if ( item != 0 ) {
    item = getTopParent ( item );
    rep = m_function_lv_map [ item ];
  }
  return rep;
}

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

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

  return getTopFunctionRep ( item );
}

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

  if ( item -> childCount() == 0 ) { // parameter item
    item = item -> parent ();
  }

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

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

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

  setParameters ( index, plotter );
}

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

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

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

  if ( enable == false ) return;

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

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

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

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

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

  yes = index < 0;

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

  statsStripValue ( m_stats_number );
  statsStripValue ( m_stats_underflow );
  statsStripValue ( m_stats_overflow );
  statsStripValue ( m_stats_avg_x );
  statsStripValue ( m_stats_avg_y );

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

    int underflow = dcontroller -> getUnderflow ( plotter, index );
    text = m_stats_underflow -> text ();
    if ( underflow == -1 ) str = "meaningless";
    else str.setNum ( underflow );
    text += " ";
    text += str;
    m_stats_underflow -> setText ( text );

    int overflow = dcontroller -> getOverflow ( plotter, index );
    text = m_stats_overflow -> text ();
    if ( overflow == -1 ) str = "meaningless";
    else str.setNum ( overflow );
    text += " ";
    text += str;
    m_stats_overflow -> setText ( text );

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

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

}

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

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

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

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

  string nullstring ("");

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

  else if ( m_stats_underflow->isChecked() )
    {
      const string s ("Underflow");
      canvas->addTextDisplay ( plotter, s, nullstring );
    }
  
  else if ( m_stats_overflow->isChecked() )
    {
      const string s ("Overflow");
      canvas->addTextDisplay ( plotter, s, nullstring );
    }

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

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

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

    }

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

    }

  else if ( m_stats_text->isChecked() )
  {

      QString qtext = m_statsTextField->text();
      const string t = qtext.latin1();
    bool needMargin = String::ci_find(t, "tex:")==0;  
    if ( needMargin ) {
#ifdef HAVE_TEX_UTILS
#else
        qtext.remove (0, 4);
        warningTex ();
#endif
    }
    string text (qtext.latin1());
    const string s ("Text From Box");
    canvas->addTextDisplay ( plotter, s, text );
  }
}

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

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

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

  canvas -> addPlotDisplay ( res_plotter, true );
}

void Inspector::
fillCheckedFunctionRepItems ( )
{
  m_func_parm_checked.clear ();

#if QT_VERSION < 0x040000
  QListViewItemIterator it ( m_FunctionParamsListView );
#else
  Q3ListViewItemIterator it ( m_FunctionParamsListView );
#endif
  while ( it.current () ) {
#if QT_VERSION < 0x040000
    QListViewItem * item = it.current ();
    QCheckListItem * check_item = dynamic_cast < QCheckListItem * > ( item );
#else
    Q3ListViewItem * item = it.current ();
    Q3CheckListItem * check_item = dynamic_cast < Q3CheckListItem * > ( item );
#endif
    if ( check_item != 0 ) {
      bool yes = check_item -> isOn ();
      if ( yes ) {
        m_func_parm_checked.push_back ( item );
      }
    }
    ++it;
  }
}

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

  FunctionController * fcontroller = FunctionController::instance ();

  fillCheckedFunctionRepItems ();
  if ( m_func_parm_checked.size () != 2 ) {
    const QString
      message ( "Two and only two function parameters should be\n"
                "checked to create error contour display.\n" );
      QMessageBox::critical( this, // parent
                             "Invalid parameter pair selection", // caption
                             message,
                             QMessageBox::Ok,
                             Qt::NoButton,
                             Qt::NoButton );
      return;
    }

#if QT_VERSION < 0x040000
  QListViewItem * first = m_func_parm_checked[0];
  QListViewItem * second = m_func_parm_checked[1];
#else
  Q3ListViewItem * first = m_func_parm_checked[0];
  Q3ListViewItem * second = m_func_parm_checked[1];
#endif
  if ( getTopParent ( first ) != getTopParent ( second ) ) {
    const QString message = 
      "Both checked function parameters must\n"
      "have same parent function.";
    QMessageBox::critical( this, // parent
                           "Invalid parameter pair selection", // caption
                           message,
                           QMessageBox::Ok,
                           Qt::NoButton,
                           Qt::NoButton );
    return;
  }
  QString text = first -> text ( Index );
  bool ok = true;
  int index = text.toInt ( & ok ) - 1;
  fcontroller -> setEllpsoidParamIndex ( Axes::X , index );

  text = second -> text ( Index );
  ok = true;
  index = text.toInt ( & ok ) -1 ;
  fcontroller -> setEllpsoidParamIndex ( Axes::Y , index );

  // Create / refresh the error plot
  const QString xlabel = first -> text ( Name );
  const QString ylabel = second -> text ( Name );
  QString stat = m_PushButtonNewErrorPlot -> text();
#if QT_VERSION < 0x040000
  QListViewItem * parent = getTopParent ( first );
#else
  Q3ListViewItem * parent = getTopParent ( first );
#endif
  FunctionRep * frep = m_function_lv_map [ parent ];
  if( stat == QString( "Change Error Plot" ) )
    {
      fcontroller -> refreshEllipsoidDisplay ( plotter, frep );
      plotter -> setLabel( Axes::X, xlabel.latin1() );
      plotter -> setLabel( Axes::Y, ylabel.latin1() );
    }
  else // "New Error Plot"
    {
      PlotterBase * err_plotter =
        fcontroller -> createNewEllipsoidDisplay ( plotter, frep );
      assert( err_plotter != 0);

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

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

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

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

  return "nil";
}

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

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

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

void
Inspector::
updateReverseBox ()
{
  bool yes = ( m_plotter_list.empty () == false ) 
    && ( m_axis == Axes::X );
  m_reverse -> setEnabled ( yes );

  if ( yes ) {
    PlotterBase * plotter = m_plotter_list.front ();
    bool reversed = plotter -> isReverse ();
    m_reverse -> setChecked ( reversed );
  }
}

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

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

  if ( yes ) return;

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

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

  if ( plotter -> hasAxis ( m_axis ) == false ) setZRadioButton ( false );
  bool enabled =  plotter -> hasAxis ( Axes::Z );
  setZRadioButton ( enabled );

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

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

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

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

  if (getMinEntries()==-1) {
    m_combine_checkbox->setEnabled( false );
    min_entries_text->setEnabled ( false );
    min_entries_slider->setEnabled ( false );
  }

  else {
    m_combine_checkbox->setEnabled( true );

    if ( m_combine_checkbox->isChecked() )
      { 
        min_entries_text->setEnabled ( true );
        min_entries_slider->setEnabled ( true );
        unsigned int min = getMinEntries();
        min_entries_text->setText( QString ("%1").arg(min) );
        min_entries_slider->setValue (50);
      }
    else
      {
        min_entries_text->setEnabled ( false );
        min_entries_slider->setEnabled ( false );
        unsigned int min = getMinEntries();
        min_entries_text->setText( QString ("%1").arg(min) );
        min_entries_slider->setValue ( 50 );
      }
  }




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

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

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

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

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

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

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

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


  axisWidget1->setAllDisabled ( false );

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

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

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

  axisWidget1->processZoomPanCheckBoxClicked ( r, r );

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

  m_contourBox->setEnabled ( yes );
}


#if QT_VERSION < 0x040000
void Inspector::functionParamsListViewCurrentChanged ()
#else
void Inspector::functionParamsListViewCurrentChanged ()
#endif
{
#if QT_VERSION < 0x040000
  QListViewItem * item = m_FunctionParamsListView -> currentItem ();
#else
  Q3ListViewItem * item = m_FunctionParamsListView -> currentItem ();
#endif
  bool is_selected = m_FunctionParamsListView -> isSelected ( item );
  bool is_parm = item -> childCount () == 0;
  bool enable = is_selected && is_parm;

  m_FunctionParamsCheckBox -> setEnabled ( enable );
  m_FunctionParamsLineEdit -> setEnabled ( enable );
  m_FunctionParamsSlider -> setEnabled ( enable );

  if ( enable ) {
    QString fixedFlag = item -> text( Fixed );
    QString qyes( "Yes" );
    m_FunctionParamsCheckBox ->
      setChecked(( fixedFlag == qyes ) ? true : false );
    m_FunctionParamsLineEdit -> setText ( item -> text( Value ) );
  }

  enable = is_selected && (! is_parm);
  functionsRemoveButton -> setEnabled ( enable );

}
#if QT_VERSION < 0x040000
QListViewItem *
Inspector::
getTopParent ( QListViewItem * item ) 
{
  QListViewItem * parent = item;
  while ( true ) {
    QListViewItem * t = parent -> parent ();
    if ( t == 0 ) break;
    parent = t;
  }
#else
Q3ListViewItem *
Inspector::
getTopParent ( Q3ListViewItem * item ) 
{
  Q3ListViewItem * parent = item;
  while ( true ) {
    Q3ListViewItem * t = parent -> parent ();
    if ( t == 0 ) break;
    parent = t;
  }
#endif
  return  parent;
}

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

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

  fcontroller -> saveParameters ( plotter );

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

  FunctionRep * frep = getTopFunctionRep ( item );

  vector < int > fixed = frep -> getFixedFlags ();

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

  // Set the new fixed flag for the function
  bool flag = m_FunctionParamsCheckBox -> isChecked();

  fixed[ paramindex ] = flag == true ? 1 : 0;
  frep -> setFixedFlags( fixed );

  if ( item -> childCount () == 0 ) {
    QString qyes ( "Yes" );
    QString qno ( "No" );
    QString fixedFlag = ( flag == true ) ? qyes : qno;
    item -> setText ( Fixed, fixedFlag );
  }

}


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

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

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

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

  QString pidx = item -> text( Index );
  int paramindex = pidx.toUInt() -1;   // the index of the parameter

  FunctionRep * frep = getTopFunctionRep ( item );
  vector < double >  parameters = frep-> parameters();

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

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


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

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

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

  FunctionRep * frep = getTopFunctionRep ( );

  if ( frep != 0 ) {
    m_oldParameters = frep -> parameters ();
  }
}


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

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

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

  if( !item ) return;

  QString pidx = item -> text( Index );
  int paramindex = pidx.toUInt() - 1;   // the index of the parameter

  vector < double > newParameters = m_oldParameters;

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

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

  FunctionRep * frep   = getTopFunctionRep ( item );
  frep -> setParameters( newParameters ); // will set projector dirty

  item -> setText( Value, QString ( "%1" ).arg ( newParameters[ paramindex ]));
  m_FunctionParamsLineEdit ->
    setText ( QString ( "%1" ).arg ( newParameters[ paramindex ] ) );
}

void
Inspector::
functionParamsSliderSliderReleased()
{
  m_FunctionParamsSlider -> setValue(50);
}

void 
Inspector::
invalidOperationError ( const string & message )
{
  QMessageBox::critical ( this,  // parent )
                            "Operation error", // caption
                            message.c_str(), // message
                            QMessageBox::Ok,
                            Qt::NoButton,
                            Qt::NoButton );
}

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

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

  while ( first != m_plotter_list.end () ) {
    PlotterBase * plotter = *first++;
    try {
      DisplayController::instance()-> setLog ( plotter, m_axis, log );
      plotter -> setAutoRanging ( m_axis, auto_scale );
    }
    catch ( const runtime_error & e ) {
      invalidOperationError ( e.what () );
    }
  }

  updateAxisTab ();
}

void Inspector::reverse_clicked()
{
  bool reverse = m_reverse -> isChecked();

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

  while ( first != m_plotter_list.end () ) {
    PlotterBase * plotter = *first++;
    plotter -> setReverse ( reverse );
  }

  updateAxisTab ();
}

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

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

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

  updateAxisTab();
}

void Inspector::cutHighSlider_sliderMoved ( int value )
{
  if ( m_is_updating == false ) {
    int index = m_selCutComboBox -> currentItem ();
    Range currentRange = m_tuple_cuts [ index] -> getRange ();
    int id = cutRadioId ();
    bool fit_cut = id == 2;

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

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

    bool fit_cut = cutRadioId () == 2;

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

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

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

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

  int index = m_selCutComboBox -> currentItem ();
  int id = cutRadioId ();
  bool fit_cut = id ==2;

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

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

  axisWidget2 -> processZoomPanCheckBoxClicked ( currentRange, fullRange ) ;
}


void Inspector::cutInvertPushButton_clicked()
{
  int id = cutRadioId ();
  bool fit_cut = id == 2;

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

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

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

void
Inspector::
colorSelect_2_clicked()
{
  int id = cutRadioId ();
  bool fit_cut = id == 2;
  if ( fit_cut ) {
  }
  else {
    PlotterBase * cplotter = getSelectedCut();
    CutPlotter * cp = dynamic_cast < CutPlotter * > ( cplotter );

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

    color = QColorDialog::getColor ( color );

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

void
Inspector::
contourSlider_valueChanged ( int val )
{

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

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

  if ( !contourRep ) return;

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

  datarep->notifyObservers();

}

void
Inspector::
contourTextBox_returnPressed()
{

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

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

  if ( !contourRep ) return;

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

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

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

  datarep->notifyObservers();

}

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

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

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

  if ( !contourRep ) return;

  if ( contourRadioButton1->isChecked() ) {

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

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

    contourSlider_valueChanged ( num );

  }

  else {

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

    contourLevelsTextBox_returnPressed();

  }

}

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

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

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

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

  if ( !contourRep ) return;

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

  vector < double > values;

// Get a std::string from the QString.
#if QT_VERSION < 0x040000
  std::string contourLevels(qstr2.ascii());
#else
  std::string contourLevels(qstr2.toAscii());
#endif
   
// Break string into components; convert and validate each value.
  std::vector<std::string> tokens;
  stringTokenize(contourLevels, " \t,", tokens);
  for (size_t i = 0; i < tokens.size(); i++) {
     QString strval(tokens.at(i).c_str() );
     bool ok(true);
     double value(strval.toDouble(&ok));
     if (!ok) {
        contourError();
        return;
     }
     values.push_back(value);
  }
  
// Sort and remove duplicates.
  std::stable_sort(values.begin(), values.end());
  vector<double>::iterator leftover = 
     std::unique(values.begin(), values.end());
  values.erase(leftover, values.end());

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

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

  QFont labelFont;
  bool ok;

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

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

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

      /* The size of drawrect, marginrect, need to be updated
         according to new font.
      */
      xyplotter -> setNeedUpdate(true);
      xyplotter -> notifyObservers ();
    }
}

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

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

  QFont titleFont;
  bool ok;

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

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

      /* The size of drawrect, marginrect, need to be updated
         according to new font.
      */
      xyplotter -> setNeedUpdate(true);
      xyplotter -> notifyObservers ();
    }
}


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

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

  FunctionRep * frep = getTopFunctionRep ();
  Fitter * fitter = frep -> getFitter ();

  // Set the new ignoreError flag for the function
  bool flag = m_IgnoreErrorCheckBox -> isChecked();
  if ( fitter != 0 ) {
    frep -> setIgnoreError ( flag );
  }
}

void
Inspector::
updateTransformTab()
{

  // Disable the tab if no plotter selected.
  PlotterBase * plotter = getPlotter ();
  bool yes = plotter == 0;
  if ( yes == false ) {
    TextPlotter * tp = dynamic_cast < TextPlotter * > ( plotter );
    yes |= tp != 0;
  }
  if ( yes ) {
    transform_button_group -> setEnabled ( false );
    rotateGroupBox -> setEnabled ( false );
    return;
  }
  else {
    transform_button_group -> setEnabled ( true );
  }
 
  bool hasZ = plotter -> hasAxis ( Axes::Z );
  m_hammer -> setEnabled ( hasZ );
  m_lambert -> setEnabled ( hasZ );
  m_Car -> setEnabled ( hasZ );
  m_Mer -> setEnabled ( hasZ );
  m_Gls -> setEnabled ( hasZ );
  m_Arc -> setEnabled ( hasZ );
  m_Tan -> setEnabled ( hasZ );
  m_Sin -> setEnabled ( hasZ );
  m_Stg -> setEnabled ( hasZ );
  m_Air -> setEnabled ( hasZ );

  
  DisplayController *d_controller = DisplayController::instance();

  bool xlog = d_controller -> getLog ( plotter, Axes::X );
  bool ylog = d_controller -> getLog ( plotter, Axes::Y );


  if ( ( !xlog ) && ( !ylog ) ){
      
      BinaryTransform *t =
        dynamic_cast<  BinaryTransform* > ( plotter->getTransform() );
   
      if (( t -> name () == "HammerAito" ) || ( t->name() == "HammerAito2")){
         m_hammer -> setChecked ( true );
      }
 
      else if (( t -> name() == "Lambert" ) || ( t->name() == "Lambert2")) {
         m_lambert -> setChecked ( true );
      }

      else if (( t -> name() == "Cartesian" ) || ( t->name() == "Cartesian2")){
         m_Car -> setChecked ( true );
      }

      else if (( t -> name() == "Mercator" ) || ( t->name() == "Mecator2")){
         m_Mer -> setChecked ( true );
      }

      else if (( t -> name() == "GlobalSinusoidal" ) || ( t->name() == "GlobalSinusoidal2")) {
         m_Gls -> setChecked ( true );
      }

      else if (( t -> name() == "ARC" ) || (t->name()=="ARC2")){
         m_Arc -> setChecked ( true );
      }

      else if (( t -> name() == "TAN" ) || (t->name()=="TAN2")){
         m_Tan -> setChecked ( true );
      }

      else if (( t -> name() == "SIN" ) || (t->name()=="SIN2")){
         m_Sin -> setChecked ( true );
      }

      else if (( t -> name() == "STG" ) || (t->name()=="STG2")){
         m_Stg -> setChecked ( true );
      }

      else if (( t -> name() == "AIR" ) || (t->name()=="AIR2")){
         m_Air -> setChecked ( true );
      }

      else  m_linear->setChecked ( true );

      // Enable rotation if periodic transform.
      // Then set the rotation offset.
      if  (t->isPeriodic()) {

        rotateGroupBox -> setEnabled ( true );
        
        PeriodicBinaryTransform *tp =
          dynamic_cast< PeriodicBinaryTransform* > ( t );

        int xoffset = (int) tp->xOffset();
        int yoffset = (int) tp->yOffset();

        setRotate ( yoffset, xoffset);
      }
      else {
        setRotate ( 0, 0 );
        rotateGroupBox -> setEnabled ( false );
      }
  }
 
  else if ( ( !xlog ) && ( ylog ) ){
    m_logy -> setChecked ( true );
  }

  else if ( ( xlog ) && ( !ylog ) ){
    m_logx -> setChecked ( true );
  }

  else if ( ( xlog ) && ( ylog ) ){
    m_logxy -> setChecked ( true );
  }
}
    

void
Inspector::
invalidPeriodicTransform ()
{
  QString message (
                   "A transform of this type can not be used because\n"
                   "this application was not compiled with WCSLIB support." );

  QMessageBox::information ( this, // parent
                             "Invalid transform", // caption
                             message, // .c_str(),
                             QMessageBox::Ok,
                             Qt::NoButton,
                             Qt::NoButton );
}

int
Inspector::
transformId () const
{
  int id = -1;
  for ( unsigned int i = 0; i < m_transform_buttons.size (); i++ ) {
    if ( m_transform_buttons[i] -> isChecked () ) {
      id = i;
      break;
    }
  }
  return id;
}

void
Inspector::
transform_button_group_clicked (  )
{

  int id = transformId ();

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

  // Reset rotation offset when do another transform
  setRotate ( 0, 0 );

#ifndef HAVE_WCSLIB
  if ( id > 3 ) {
    invalidPeriodicTransform ();
    return;
  }
#endif

  DisplayController *d_controller = DisplayController::instance();
  int max_x = validPeriodicTransformRange();
  bool valid2 = false;
  try {
    switch ( id ) {
    case 0:
      d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
      d_controller -> setTransform ( plotter, "Linear Linear" );
      rotateGroupBox -> setEnabled ( false );
      break;

    case 1:
      d_controller -> setTransformAxis ( plotter, "Linear", "Log" );
      d_controller -> setTransform ( plotter, "Linear Log");
      rotateGroupBox -> setEnabled ( false );
      break;

    case 2:
      d_controller -> setTransformAxis ( plotter, "Log", "Linear" );
      d_controller -> setTransform ( plotter, "Log Linear" );
      rotateGroupBox -> setEnabled ( false );
      break;

    case 3:   
      d_controller -> setTransformAxis ( plotter, "Log", "Log" );
      d_controller -> setTransform ( plotter, "Log Log" );
      rotateGroupBox -> setEnabled ( false );
      break;

    case 4:   
      if ( max_x == 180 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "HammerAito" );
        rotateGroupBox -> setEnabled ( true );
      }
      else if ( max_x == 360 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "HammerAito2" );
        rotateGroupBox -> setEnabled ( true );
      }
      else {
        QString message (
                         "The range of current plotter is not valid for.\n"
                         "HammerAito transform.\n\n"
                         "A valid range should be within: \n"
                         "X axis [-180, 180] or [0, 360]\n" 
                         "Y axis [ -90,  90]\n" );
        QMessageBox::information ( this, // parent
                                   "Invalid range", // caption
                                   message, // .c_str(),
                                   QMessageBox::Ok,
                                   Qt::NoButton,
                                   Qt::NoButton );
      }
      break;

    case 5:
      if ( max_x == 180 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "Lambert" );
        rotateGroupBox -> setEnabled ( true );
      }
      else if ( max_x == 360 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "Lambert2" );
        rotateGroupBox -> setEnabled ( true );
      }
      else {
        QString message (
                         "The range of current plotter is not valid for.\n"
                         "Lambert transform.\n\n"
                         "A valid range should be within: \n"
                         "X axis [-180, 180] or [0, 360]\n" 
                         "Y axis [ -90,  90]\n" );
        QMessageBox::information ( this, // parent
                                   "Invalid range", // caption
                                   message, // .c_str(),
                                   QMessageBox::Ok,
                                   Qt::NoButton,
                                   Qt::NoButton );
      }
      break;

    case 6:
      if ( max_x==180 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "Cartesian" );
        rotateGroupBox -> setEnabled ( true );
      }
      else if ( max_x==360 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "Cartesian2" );
        rotateGroupBox -> setEnabled ( true );
      }
      else {
        QString message (
                         "The range of current plotter is not valid for.\n"
                         "Cartesian transform.\n\n"
                         "A valid range should be within: \n"
                         "X axis [-180, 180]\n" 
                         "Y axis [ -90,  90]\n" );
        QMessageBox::information ( this, // parent
                                   "Invalid range", // caption
                                   message, // .c_str(),
                                   QMessageBox::Ok,
                                   Qt::NoButton,
                                   Qt::NoButton );
      }
      break;

    case 7:
      if ( max_x == 180 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "Mercator" );
        rotateGroupBox -> setEnabled ( true );
      }
      else if ( max_x == 360 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "Mercator2" );
        rotateGroupBox -> setEnabled ( true );
      }
      else {
        QString message (
                         "The range of current plotter is not valid for.\n"
                         "Mercator transform.\n\n"
                         "A valid range should be within: \n"
                         "X axis [-180, 180] or [0, 360]\n" 
                         "Y axis [ -90,  90]\n" );
        QMessageBox::information ( this, // parent
                                   "Invalid range", // caption
                                   message, // .c_str(),
                                   QMessageBox::Ok,
                                   Qt::NoButton,
                                   Qt::NoButton );
      }
      break;

    case 8:
      if ( max_x == 180 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "GlobalSinusoidal" );
        rotateGroupBox -> setEnabled ( true );
      }
      else if ( max_x == 360 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "GlobalSinusoidal2" );
        rotateGroupBox -> setEnabled ( true );
      }
      else {
        QString message (
                         "The range of current plotter is not valid for.\n"
                         "GlobalSinusoidal transform.\n\n"
                         "A valid range should be within: \n"
                         "X axis [-180, 180] or [0, 360]\n" 
                         "Y axis [ -90,  90]\n" );
        QMessageBox::information ( this, // parent
                                   "Invalid range", // caption
                                   message, // .c_str(),
                                   QMessageBox::Ok,
                                   Qt::NoButton,
                                   Qt::NoButton );
      }
      break;

    case 9:
      if ( max_x == 180 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "ARC" );
        rotateGroupBox -> setEnabled ( true );
      }
      else if ( max_x == 360 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "ARC" );
        rotateGroupBox -> setEnabled ( true );
      }
      else {
        QString message (
                         "The range of current plotter is not valid for.\n"
                         "ARC transform.\n\n"
                         "A valid range should be within: \n"
                         "X axis [-180, 180] or [0, 360]\n" 
                         "Y axis [ -90,  90]\n" );
        QMessageBox::information ( this, // parent
                                   "Invalid range", // caption
                                   message, // .c_str(),
                                   QMessageBox::Ok,
                                   Qt::NoButton,
                                   Qt::NoButton );
      }
      break;

    case 10:
      valid2 = validPeriodicTransformRange( 0 );
      if ( max_x == 180 && valid2 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "TAN" );
        rotateGroupBox -> setEnabled ( true );
      }
      else if ( max_x == 360 && valid2 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "TAN2" );
        rotateGroupBox -> setEnabled ( true );
      }
      else {
        QString message (
                         "The range of current plotter is not valid for.\n"
                         "TAN transform.\n\n"
                         "A valid range should be within: \n"
                         "X axis [-180, 180] or [0, 360]\n" 
                         "Y axis ( 0,  90]\n" );
        QMessageBox::information ( this, // parent
                                   "Invalid range", // caption
                                   message, // .c_str(),
                                   QMessageBox::Ok,
                                   Qt::NoButton,
                                   Qt::NoButton );
      }
      break;

    case 11:
      valid2 = validPeriodicTransformRange( 0 );
      if ( max_x==180 && valid2 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "SIN" );
        rotateGroupBox -> setEnabled ( true );
      }
      if ( max_x==360 && valid2 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "SIN2" );
        rotateGroupBox -> setEnabled ( true );
      }
      else {
        QString message (
                         "The range of current plotter is not valid for.\n"
                         "SIN transform.\n\n"
                         "A valid range should be within: \n"
                         "X axis [-180, 180] or [0, 360]\n" 
                         "Y axis ( 0,  90]\n" );
        QMessageBox::information ( this, // parent
                                   "Invalid range", // caption
                                   message, // .c_str(),
                                   QMessageBox::Ok,
                                   Qt::NoButton,
                                   Qt::NoButton );
      }
      break;

    case 12:
      valid2 = true; //validPeriodicTransformRange( -90 );
      if ( max_x==180 && valid2 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "STG" );
        rotateGroupBox -> setEnabled ( true );
      }
      if ( max_x==360 && valid2 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "STG2" );
        rotateGroupBox -> setEnabled ( true );
      }
      else {
        QString message (
                         "The range of current plotter is not valid for.\n"
                         "STG transform.\n\n"
                         "A valid range should be within: \n"
                         "X axis [-180, 180] or [0, 360]\n" 
                         "Y axis ( -90,  90]\n" );
        QMessageBox::information ( this, // parent
                                   "Invalid range", // caption
                                   message, // .c_str(),
                                   QMessageBox::Ok,
                                   Qt::NoButton,
                                   Qt::NoButton );
      }
      break;

    case 13:
      valid2 = validPeriodicTransformRange( -90 );
      if ( max_x==180 && valid2 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "AIR" );
        rotateGroupBox -> setEnabled ( true );
      }
      if ( max_x==360 && valid2 ) {
        d_controller -> setTransformAxis ( plotter, "Linear", "Linear" );
        d_controller -> setTransform ( plotter, "AIR2" );
        rotateGroupBox -> setEnabled ( true );
      }
      else {
        QString message (
                         "The range of current plotter is not valid for.\n"
                         "AIR transform.\n\n"
                         "A valid range should be within: \n"
                         "X axis [-180, 180] or [0, 360]\n" 
                         "Y axis ( -90,  90]\n" );
        QMessageBox::information ( this, // parent
                                   "Invalid range", // caption
                                   message, // .c_str(),
                                   QMessageBox::Ok,
                                   Qt::NoButton,
                                   Qt::NoButton );
      }
      break;

    }
  }
  catch ( const std::runtime_error & e ) {
    invalidOperationError ( e.what() );
  }
}



int
Inspector::
validPeriodicTransformRange()
{
  PlotterBase * plotter = getPlotter ();
  
  const Range & rx = plotter -> getDataRange ( Axes::X  );
  const Range & ry = plotter -> getDataRange ( Axes::Y  );

  if ( ( rx.low() > -181 ) && ( rx.high() < 181 ) &&
       ( ry.low() > -91 ) && ( ry.high() < 91 )) {
    return 180;
  }
  
  if ( ( rx.low() > -1 ) && ( rx.high() < 361 ) &&
       ( ry.low() > -91 ) && ( ry.high() < 91 )) {
    return 360;
  }
  
  else return 0;
}


bool
Inspector::
validPeriodicTransformRange( int miny )
{
  PlotterBase * plotter = getPlotter ();
  
  const Range & rx = plotter -> getRange ( Axes::X, false  );
  const Range & ry = plotter -> getRange ( Axes::Y, false  );

  if ( ( rx.low() < -180 ) || ( rx.high() > 180 ) ||
       ( ry.low() <=  miny ) || ( ry.high() > 90  ) ) {
    return false;
  }

  else {
    return true;
  }
}



void
Inspector::
rotateX( int offset )
{
  if (!m_rotate_enable) return;

  if (offset>180) offset = offset-360 ;
  if (offset< -180) offset = offset+360;

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

  plotter->setAutoRanging ( Axes::X, false );


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

          
      PeriodicBinaryTransform *tp =
        dynamic_cast< PeriodicBinaryTransform* > ( t );

      const Range & r = plotter->getRange ( Axes::X, true );
      Range range (r.low(), r.high(), r.pos());
      
      // Actually rotating X axes
      tp->setYOffset( offset );

      plotter->setRange ( Axes::X, range, true, false );
      m_x_offset_text->setText ( QString("%1").arg(offset)) ;

}


void
Inspector::
rotateY( int offset )
{
  if (!m_rotate_enable) return;

  if (offset>180) offset = offset-360 ;
  if (offset< -180) offset = offset+360;

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

  plotter->setAutoRanging ( Axes::Y, false );


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

          
      PeriodicBinaryTransform *tp =
        dynamic_cast< PeriodicBinaryTransform* > ( t );

      const Range & r = plotter->getRange ( Axes::Y, true );
      Range range (r.low(), r.high(), r.pos());
      
      // Rotate Y;
      tp->setXOffset( offset );

      plotter->setRange ( Axes::Y, range, true, false );
      m_y_offset_text->setText ( QString("%1").arg(offset)) ;

}

void 
Inspector::
setRotate( int x, int y )
{
  m_rotate_enable = false;
  m_x_offset -> setValue ( x );
  m_x_offset_text -> setText ( QString("%1").arg(x) );
  m_y_offset -> setValue ( y );
  m_y_offset_text -> setText ( QString("%1").arg(y) );
  m_rotate_enable = true;
}

void
Inspector::
resetRotate()
{
  rotateX(0);
  rotateY(0);
  setRotate(0, 0);
}

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

  plotter->setShowGrid ( m_grid -> isChecked() );
}

void
Inspector::
m_boxedge_clicked()
{
  PlotterBase * plotter = getPlotter();
  if ( !plotter ) return;
  plotter->setBoxEdge( m_boxedge->isChecked() );
}


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

  if (m_combine_checkbox->isChecked()) {
    plotter->setMinEntries(m_min_entries);
  }
  else plotter->setMinEntries(0);

  updateAxisTab();
}

void
Inspector::
setMinEntries( int increment )
{ 
  int minEntries = m_min_entries + increment - 50;
  if ( minEntries < 0 ) minEntries = 0;

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

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

  plotter->setMinEntries(minEntries);
  min_entries_text->setText(QString("%1").arg(minEntries));

  if (m_dragging == false ) {
    m_min_entries = minEntries;
    min_entries_slider->setValue(50);
  }
}

int
Inspector::
getMinEntries()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return -1;
  
  return plotter->getMinEntries ();
}

void
Inspector::
setMinEntriesText()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  
  int min = min_entries_text->text().toInt();
  plotter->setMinEntries(min);
  updateAxisTab();
}


void
Inspector::
setXRotateText()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  
  int offset = m_x_offset_text->text().toInt();


  if (!m_rotate_enable) return;

  if (offset>180) offset = offset-360 ;
  if (offset< -180) offset = offset+360;

  plotter->setAutoRanging ( Axes::X, false );
  
  BinaryTransform *t =
    dynamic_cast<  BinaryTransform* > ( plotter->getTransform() );
  
          
  PeriodicBinaryTransform *tp =
    dynamic_cast< PeriodicBinaryTransform* > ( t );
  
  const Range & r = plotter->getRange ( Axes::X, true );
  Range range (r.low(), r.high(), r.pos());
  
  // Actually rotating X axes
  tp->setYOffset( offset );
  
  plotter->setRange ( Axes::X, range, true, false );
  m_x_offset->setValue(offset);
  m_x_offset_text->setText ( QString("%1").arg(offset)) ;

  updateAxisTab();
}

void
Inspector::
setYRotateText()
{
  PlotterBase * plotter = getPlotter ();
  if ( !plotter ) return;
  
  int offset = m_y_offset_text->text().toInt();


  if (!m_rotate_enable) return;

  if (offset>180) offset = offset-360 ;
  if (offset< -180) offset = offset+360;

  plotter->setAutoRanging ( Axes::Y, false );
  
  BinaryTransform *t =
    dynamic_cast<  BinaryTransform* > ( plotter->getTransform() );
  
          
  PeriodicBinaryTransform *tp =
    dynamic_cast< PeriodicBinaryTransform* > ( t );
  
  const Range & r = plotter->getRange ( Axes::Y, true );
  Range range (r.low(), r.high(), r.pos());
  
  // Actually rotating Y axes
  tp->setXOffset( offset );
  
  plotter->setRange ( Axes::Y, range, true, false );
  m_y_offset->setValue(offset);
  m_y_offset_text->setText ( QString("%1").arg(offset)) ;

  updateAxisTab();
}

void
Inspector::
diffDataRep()
{
  PlotterBase * plotter = getPlotter ();

  if ( !plotter ) return;

  int num_rep = plotter -> getNumDataReps();

  // If number of datarep is not equal to 2
  // in the plot, show warning message and do nothing.
  if ( num_rep != 2 )
    {
      const QString message=
        "You must have two DataReps in this view.";

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

  
  FunctionRep * func_rep = getTopFunctionRep ();
  DisplayController * controller = DisplayController::instance ();
  PlotterBase * res_plotter 
    //= controller -> createResidualsDisplay ( plotter, func_rep );
    = controller -> createDifferenceDisplay ( plotter );
  const Range & range = plotter -> getRange ( Axes::X, false );
  res_plotter -> setRange ( Axes::X, range, false );

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

  canvas -> addPlotDisplay ( res_plotter, true );
}