QtDisplay.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h" // for have_root and have_numarray
#endif

// For truncation warning
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "QtDisplay.h"

#include "ListTuple.h"
#include "PyFunctionRep.h"
#include "PyDataRep.h"
#include "PyDataSource.h"
#include "FunctionWrap.h"

#include "controllers/DisplayController.h"
#include "controllers/FunctionController.h"
#include "pattern/FactoryException.h"
#include "pattern/Observer.h"
#include "plotters/PlotterBase.h"
#include "plotters/PlotterException.h"
#include "projectors/ProjectorBase.h"
#include "datareps/DataRepException.h"
#include "datareps/DataRep.h"
#include "datasrcs/DataSourceController.h"
#include "datasrcs/DataSourceException.h"
#include "datasrcs/NTuple.h"
#include "reps/RepBase.h"
#include "reps/ContourPointRep.h"
#include "reps/BinToColorFactory.h"
#include "reps/BinToColor.h"

#ifdef HAVE_ROOT
#include "root/QtRootNTuple.h"
#include "root/RootNTuple.h"
#endif

#include "qapplication.h"

#include <algorithm>
#include <sstream>
#include <stdexcept>
#include <utility>

using std::string;
using std::vector;
using namespace boost::python;

namespace hippodraw {
namespace Python {

void
export_QtDisplay()
{
  class_< QtDisplay > 
    ( "Display",
      "A wrapper for the HippoDraw PlotterBase C++ class.\n "
      "  See HippoDraw's QtDisplay documentation for more details.",
      init < const std::string & >
      (
#if __GNUC__ < 3
       "Display ( string, Datasource, tuple ) -> Display\n"
       "\n"
       "The main consturctor for a Display."
#else // gcc 2.95.3 crashes on the following...
       "Display ( string ) -> Display\n"
       "Display ( string, DataSource, tuple ) -> Display\n"
       "Display ( string, DataArray, tuple ) - > Display\n"
       "Display ( string, tuple, tuple ) -> Display\n"
       "Display ( string, list, tuple ) -> Display\n"
       "Display ( string, RootNTuple, tuple ) -> Display\n"
       "Display ( string, RootNTuple, tuple, tuple ) -> Display\n"
       "\n"
        "This method is used to create a Display object.\n"
        "The first method is used for creating static version of\n "
        "Histograms, etc., where the string is the type of DataRep.\n"
        "The remaining methods are for dynamic versions.\n"
        "The string argument is the type.   The second argument\n"
        "is the DataSource and the third argument is tuple of\n"
        "string for the binding to the DataSource.\n"
        "For the last method, the fourth argument is a tuple\n"
        "of integers to access a ROOT array variable.\n"
#endif
        ) )
          
    .def ( init < const std::string &,
           const DataSource &,
           const std::vector< std::string > & > () )

    .def ( init < const std::string &,
           const PyDataSource &,
           const std::vector< std::string > & > () )

    .def ( init < const std::string &,
           boost::python::tuple,
           const std::vector< std::string > & > () )

    .def ( init < const std::string &,
            boost::python::list,
           const std::vector< std::string > & > () )

#ifdef HAVE_ROOT
    .def ( init < const std::string &,
            const QtRootNTuple &,
           const std::vector< std::string > & > () )

    .def ( init < const std::string &,
           const QtRootNTuple &,
           const std::vector< std::string > &,
           boost::python::list > () )
#endif

    .def ( "createNTuple", &QtDisplay::createNTuple,
           return_value_policy < manage_new_object > (),
           "createNTuple ( ) -> NTuple\n"
           "\n"
           "Returns a NTuple representation of the Display's contents." )

#ifdef HAVE_NUMARRAY
    .def ( "createDataArray", &QtDisplay::createDataArray,
           return_value_policy < manage_new_object > (),
           "createDataArray ( ) -> DataArray\n"
           "\n"
           "Returns a DataArray representation of the Display's contents\n"
           "(This method available if configured with numarray)" )
#endif

    .def ( "setNumberOfBins", &QtDisplay::setNumberOfBins,
           "setNumberOfBins ( string, value ) -> None\n\n"
           "Sets the number of bins on named axis, e.g. 'x' to the given \n"
           "value." )
          
    .def ( "setBinWidth", 
           ( void (QtDisplay::*) ( const std::string &,
                                   double, 
                                   bool ) )
            &QtDisplay::setBinWidth,
            "Set the bin width, explicitly saving the value or not." )

    .def ( "getBinWidth", 
           ( double (QtDisplay::*) ( const std::string & ) )
            &QtDisplay::getBinWidth,
           "getBinWidth ( string ) -> value\n"
           "\n"
           "Returns the bin width on axis specified as a string,\n"
           "e.g., 'x'." )

    .def ( "setBinWidth", 
           ( void (QtDisplay::*) ( const std::string &,
                                   double ) )
            &QtDisplay::setBinWidth,
           "setBinWidth ( string, value ) -> None\n"
           "\n"
            "Set the bin width to value  on axis specified as a string,\n"
           "e.g., 'x'." )

    .def ( "reset", &QtDisplay::reset,
           "reset () -> None\n"
           "\n"
           "Resets the contents of all bins.   Only applicable to statis\n"
           "static histograms." )

    .def ( "setOffset", &QtDisplay::setOffset,
           "setOffset ( string, value ) -> None\n"
           "\n"
           "Sets the offset of the bins relative to their current width on\n"
           "specified axis." )
          
    .def ( "setRange", 
           ( void (QtDisplay::*) (const std::string &, 
                                  double, double) )
           &QtDisplay::setRange )

    .def ( "setRange", 
           ( void (QtDisplay::*) (const std::string &, 
                                  double, double, bool) )
           &QtDisplay::setRange,
           "setRange ( string, value, value ) -> None\n"
           "setRange ( string, value, value, boolean ) -> None\n"
           "\n"
           "Set the upper and lower bounds for the specified axis.  For the\n"
           "second form, also save them if the boolean argument is true." )


    .def ( "getRange", &QtDisplay::getRange,
           "getRange ( string ) -> tuple\n"
           "\n"
           "Returns the tuple representing the range for the axis specified\n"
           "as a string, e.g., 'x'." )

     .def ( "saveView", &QtDisplay::saveView,
            "saveView ( ) -> int\n"
            "\n"
            "Saves the current set of x and y ranges and "
            "returns the index of the saved view." )

     .def ( "setView", &QtDisplay::setView,
            "setView ( int ) -> None\n"
            "\n"
            "Set the view by its index." )

     .def ( "nextView", &QtDisplay::nextView,
            "nextView ( bool ) -> int\n"
            "\n"
            "Cycle to the next view in the view buffer. "
            "Set the argument to True to cycle forwards, "
            "False to cycle backwards.\n"
            "Returns the index of the new view." )

     .def ( "numViews", &QtDisplay::numViews,
            "numViews ( ) -> int\n"
            "\n"
            "Return the number of stored views." )

     .def ( "deleteView", &QtDisplay::deleteView,
            "deleteView ( int ) -> None\n"
            "\n"
            "Delete a view by index." )

     .def ( "currentView", &QtDisplay::currentView,
            "currentView ( ) -> int\n"
            "\n"
            "Index of the current view." )

    .def ( "setTitle", &QtDisplay::setTitle,
           "setTitle ( string ) -> None\n"
           "\n"
           "Sets the title of the display." )

    .def ( "getTitle", &QtDisplay::getTitle,
            return_value_policy < copy_const_reference > (),
           "getTitle () -> string\n"
           "\n"
           "Returns the current title.   The title will be the title of\n"
           "the DataSource unless it has been explicitly changed." )

    .def ( "setLabel", &QtDisplay::setLabel,
           "setLabel ( string, string ) -> None\n"
           "\n"
           "Sets the label for the axis specified by first argument to value\n"
           "of the second argument." )

    .def ( "getLabel", &QtDisplay::getLabel,
            return_value_policy< copy_const_reference > (),
           "getLabel ( string ) -> string\n"
           "\n"
            "Returns the label of the axis specified as a string,\n"
           "e.g., 'x'." )

    .def ( "getDataRep", &QtDisplay::getDataRep,
           return_value_policy < reference_existing_object > (),
           "getDataRep ( ) -> DataRep\n"
           "\n"
           "Returns a reference to the active DataRep." )

    .def ( "getDataReps", &QtDisplay::getDataReps,
            return_value_policy < copy_const_reference > (),
           "getDataReps ( ) -> list\n"
           "\n"
           "Returns a list of DataRep objects contained by the Display.." )
    
    .def ( "addDataRep", 
           ( void (QtDisplay::*) (PyDataRep *) )
           &QtDisplay::addDataRep,
           "addDataRep ( DataRep ) -> Display\n"
           "addDataREp ( Function ) -> Display\n"
           "addDataRep ( string, DataSource, tuple ) -> Display\n"
           "\n"
           "Adds a DataRep to the display sharing the same Y axis range\n"
           "The first two methods adds existing DataRep or Function to the\n"
           "Display.  The third method creates and adds DataRep to the\n"
           "Display.  Arguments are same as Display consturctor." )

    .def ( "addDataRep", 
           ( void (QtDisplay::*) (const std::string &, 
                                  const DataSource *,
                                  const std::vector <std::string > &) )
           &QtDisplay::addDataRep )

    .def ( "addDataRep", 
           ( void (QtDisplay::*) (PyFunctionRep *) )
           &QtDisplay::addDataRep )

    .def ( "addDataRepStacked", 
           ( void (QtDisplay::*) (const std::string &, 
                                  const DataSource *,
                                  const std::vector <std::string > &) )
           &QtDisplay::addDataRepStacked,
           "addDataRepStacked ( string, DataSource, tuple ) -> Display\n"
           "\n"
           "Creates and adds a DataRep with independant Y axis ranges.\n"
           "The arguments are the same as Display constructor." ) 

#ifndef BOOST_DEFECT
    .def ( "addFunction", 
           ( void (QtDisplay::*) (FunctionBase *) )
           &QtDisplay::addFunction,
           "addFunction ( FunctionBase ) -> None\n"
           "\n"
           "Adds a FunctionBase object to the display by appropriatelly\n"
           "wrapping it with a Function." )
#endif // BOOST_DEFECT

    .def ( "setAutoRanging",
            ( void (QtDisplay::*) (const std::string &,
                                   bool flag ) )
            &QtDisplay::setAutoRanging,
           "setAutoRanging ( string, boolean ) -> None\n"
           "\n"
           "Sets auto-ranging on axis specified as a string, e.g. 'x',n"
           "on or off." )

    .def ( "setLog", &QtDisplay::setLog,
           "setLog ( string, boolean ) -> None\n"
           "\n"
           "Sets the axis specified by the first argument on log scale." )

    .def ( "getLog", &QtDisplay::getLog,
           "getLog ( string ) -> value\n"
           "\n"
           "Returns True if axis specified as a string, e.g. 'x', is being\n"
           "displayed on a logrithmic scale." )

    .def ( "setTransform", &QtDisplay::setTransform,
           "setTransform ( string ) -> None\n"
           "\n"
           "Sets the transform object." )

    .def ( "addValues", &QtDisplay::addValues,
           "addValue ( tuple ) -> None\n"
           "\n"
           "For static histograms, adds a value to the accumulaton.\n"
           "For 1D histogram, the tuple should contain one or two values,\n"
           "the second used as a weight.  For 2D histogram, the tuple should\n"
           "contain two or three elements, the third being the weight.\n"
           "non static Displays do nothing." )

    .def ( "setPointRep", &QtDisplay::setPointRep,
           "setPointRep ( RepBase ) -> None\n"
           "\n"
           "Sets the point representation to be used." )

    .def ( "setContourLevels", &QtDisplay::setContourLevels,
           "setContourLevels ( sequence ) -> None\n"
           "\n"
           "Sets the contour levels if the Display is using contour point\n"
           "representation from the values in the sequence." )

    .def ( "setAspectRatio", &QtDisplay::setAspectRatio,
           "setAspectRatio ( value ) -> None\n"
           "\n"
           "Sets the required aspect ratio of the Display to value, the\n"
           "ratio of the width to the height." )

     .def ( "numberOfEntries", &QtDisplay::numberOfEntries,
            "numberOfEntries ( ) -> value\n"
            "\n"
            "Returns the number of Entris in the Display." )

     .def ( "resize", &QtDisplay::resize,
            "resize () -> None\n"
            "\n"
            "Resizes the Display to its saved values." )

     .def ( "plotterId", &QtDisplay::plotterId,
            "plotterId () -> value\n"
            "\n"
            "Returns a unique identifier for the Display." )

     .def ( "setColorMap", &QtDisplay::setColorMap,
            "setColorMap ( string ) -> None\n"
            "\n"
            "Set the value-to-color map to one named by the argument.")

    .def ( "update", &QtDisplay::update,
           "update () -> None\n"
           "\n"
           "Updates the display." )

    .def ( "addObserver", &QtDisplay::addObserver,
           "addObserver ( Observer ) -> None\n"
           "\n"
           "Adds an Observer to the Display object." )

    .def ( "setAutoTicks", &QtDisplay::setAutoTicks,
           "setAutoTicks ( boolean ) -> None\n"
           "\n"
           "Set the ticks generation to be automatic (the default) or\n"
           "manually." )

    .def ( "setTicks", &QtDisplay::setTicks,
           "setTicks ( string, sequence, sequence ) -> None\n"
           "\n"
           "Sets the tick locations and labels.   The first argument is the\n"
           " axis, the second argument is a sequence containing the\n"
           "locations, and the third argument is a sequence of tick labels." )

    .def ( "unlock", &QtDisplay::unlock,
           "unlock () -> None\n"
           "\n"
           "Unlock the application thread." )

    ;
}

} // namespace Python
} // namespace hippodraw

using namespace hippodraw;

void QtDisplay::createDisplay ( const std::string & type, 
                                const DataSource & nt, 
                                const std::vector < std::string > & bindings )
{
  if ( qApp ) qApp->lock ();
  DisplayController * controller = DisplayController::instance ();
  try {
    m_plotter = controller->createDisplay ( type, nt, bindings );
    if ( qApp ) qApp->unlock ();
  }
  catch ( const FactoryException & e ) {
    if ( qApp ) qApp->unlock ();
    throw e;
  }
  catch ( const DataRepException & e ) {
    if ( qApp ) qApp->unlock ();
    throw e;
  }
  catch ( const DataSourceException & e ) {
    if ( qApp ) qApp->unlock ();
    throw e;
  }
}

QtDisplay::
QtDisplay ( const std::string & type,
            boost::python::tuple seq,
            const std::vector < std::string > & labels )
{
  if ( qApp ) qApp -> lock ();

  object obj = seq.attr ( "__len__" ) ();

  ListTuple * ntuple = new ListTuple ( );

  try {
    unsigned int size = extract < unsigned int > ( obj );

    if ( size > labels.size () ) {
      string what ( "Display: Too few labels" );
      throw DataSourceException ( what );
    }
      
    for ( unsigned int i = 0, j = 0; i < size; i++, j++ ) {
      boost::python::list l = extract < boost::python::list > ( seq[i] );

      while ( labels[j] == "nil" ) {
        j++; // skip such labels
        if ( ! ( j < labels.size () ) ) {
          string what ( "Display: Too few non 'nil' labels" );
          throw DataSourceException ( what );
        }

      }
      ntuple -> addColumn ( labels[j], l );
    }
  }
  catch ( const DataSourceException & e ) {
    delete ntuple;
    if ( qApp ) qApp -> unlock ();
    throw e;
  }

  // Do not call createDisplay() as exceptions wouldn't print nicely
  try { 
    DisplayController * dc = DisplayController::instance ();
    m_plotter = dc -> createDisplay ( type, *ntuple, labels );
  }
  catch ( const FactoryException & e ) {
    delete ntuple;
    if ( qApp ) qApp->unlock ();
    throw e;
  }
  catch ( const DataRepException & e ) {
    delete ntuple;
    if ( qApp ) qApp->unlock ();
    throw e;
  }
  catch ( const DataSourceException & e ) {
    delete ntuple;
    if ( qApp ) qApp->unlock ();
    throw e;
  }

  // No use telling controller about it until we are sure to accept it.
  DataSourceController * dsc = DataSourceController::instance ();
  dsc -> registerNTuple ( ntuple );

  if ( qApp ) qApp -> unlock ();
}

QtDisplay::
QtDisplay ( const std::string & type,
            boost::python::list seq,
            const std::vector < std::string > & labels )
{
  if ( qApp ) qApp -> lock ();

  object obj = seq.attr ( "__len__" ) ();

  ListTuple * ntuple = new ListTuple ( );

  try {
    unsigned int size = extract < unsigned int > ( obj );

    if ( size > labels.size () ) {
      string what ( "Display: Too few labels" );
      throw DataSourceException ( what );
    }
      
    // gcc 2.95.3 needs full scoping
    for ( unsigned int i = 0, j = 0; i < size; i++, j++ ) {
      boost::python::list l = extract < boost::python::list > ( seq[i] );

      while ( labels[j] == "nil" ) {
        j++; // skip such labels
        if ( ! ( j < labels.size () ) ) {
          string what ( "Display: Too few non 'nil' labels" );
          throw DataSourceException ( what );
        }

      }
      ntuple -> addColumn ( labels[j], l );
    }
  }
  catch ( const DataSourceException & e ) {
    delete ntuple;
    if ( qApp ) qApp -> unlock ();
    throw e;
  }

  // Do not call createDisplay() as exceptions wouldn't print nicely
  try { 
    DisplayController * dc = DisplayController::instance ();
    m_plotter = dc -> createDisplay ( type, *ntuple, labels );
  }
  catch ( const FactoryException & e ) {
    delete ntuple;
    if ( qApp ) qApp->unlock ();
    throw e;
  }
  catch ( const DataRepException & e ) {
    delete ntuple;
    if ( qApp ) qApp->unlock ();
    throw e;
  }
  catch ( const DataSourceException & e ) {
    delete ntuple;
    if ( qApp ) qApp->unlock ();
    throw e;
  }

  // No use telling controller about it until we are sure to accept it.
  DataSourceController * dsc = DataSourceController::instance ();
  dsc -> registerNTuple ( ntuple );

  if ( qApp ) qApp -> unlock ();
}

QtDisplay::QtDisplay ()
  : m_plotter ( 0 )
{
}

QtDisplay::
QtDisplay ( const std::string & type )
{
  if ( qApp ) qApp -> lock ();
  DisplayController * controller = DisplayController::instance ();
  try {
    m_plotter = controller -> createDisplay ( type );
    if ( qApp ) qApp -> unlock ();
  }
  catch ( const FactoryException & e ) {
    if ( qApp ) qApp->unlock ();
    throw e;
  }
  catch ( const DataRepException & e ) {
    if ( qApp ) qApp->unlock ();
    throw e;
  }
}

QtDisplay::QtDisplay( const std::string & type,
                      const DataSource & nt,
                      const std::vector< std::string > & bindings )
{
   createDisplay ( type, nt, bindings );
}

QtDisplay::QtDisplay( const std::string & type,
                      const PyDataSource & nt,
                      const std::vector< std::string > & bindings )
{
   createDisplay ( type, nt.dataSource(), bindings );
}

#ifdef HAVE_ROOT
QtDisplay::
QtDisplay ( const std::string & type,
            const QtRootNTuple & nt,
            const std::vector < std::string > & bindings )
{
  nt.expandIfNeeded ( bindings );
  createDisplay ( type, nt, bindings );
}

QtDisplay::
QtDisplay ( const std::string & type,
            const QtRootNTuple & nt,
            const std::vector < std::string > & variables,
            boost::python::list indices )
{
  object obj = indices.attr ( "__len__" ) ();
  unsigned int size = extract < unsigned int > ( obj );

  if ( size != variables.size() ) {
    const string what ( "Display: bindings and indices not the same size." );
    throw DataSourceException ( what );
  }

  vector < vector < int > > vec ( size );
  for ( unsigned int i = 0; i < size; i++ ) {
    boost::python::list l = extract < boost::python::list > ( indices[i] );
    object o = l.attr ( "__len__" ) ();
    unsigned int len = extract < unsigned int > ( o );
    for ( unsigned int j = 0; j < len; j++ ) {
      unsigned int k = extract < unsigned int > ( l[j] );
      vec[i].push_back ( k );
    }
  }

  vector < string > bindings ( size );

  for ( unsigned int i = 0; i < size; i++ ) {
    const string & label = variables [ i ];
    const vector < int > & indexes = vec [ i ];
    const string name = nt.createBinding ( label, indexes );
    bindings [ i ] = name;
  }
  nt.expandIfNeeded ( bindings );

  createDisplay ( type, nt, bindings );
}

#endif // have_root

QtDisplay::QtDisplay( PlotterBase * plotter) : m_plotter(plotter) {}

QtDisplay::~QtDisplay () 
{ 
  //   delete m_plotter; 
}

PlotterBase * QtDisplay::display()
{
  return m_plotter;
}

void QtDisplay::addDataRep ( const std::string & type, 
                             const DataSource * ntuple,
                             const std::vector < std::string > & bindings )
{
  qApp->lock();

  DisplayController * controller = DisplayController::instance ();
  controller->addDataRep ( m_plotter, type, ntuple, bindings );

  qApp->unlock();
}

void
QtDisplay::
addDataRepStacked ( const std::string & type, 
                  const DataSource * ntuple,
                  const std::vector < std::string > & bindings )
{
  qApp->lock();

  DisplayController * controller = DisplayController::instance ();
  controller->addDataRepStacked ( m_plotter, type, ntuple, bindings );

  qApp->unlock();
}

void QtDisplay::addDataRep ( PyDataRep * pyRep )
{
   qApp->lock();

   DisplayController * controller = DisplayController::instance ();
   controller->addDataRep ( m_plotter, pyRep->getDataRep() );

   qApp->unlock();
}

void QtDisplay::addDataRep ( PyFunctionRep * pyFuncRep )
{
   qApp->lock();

   DisplayController * controller = DisplayController::instance ();
   
   controller->addDataRep ( m_plotter, pyFuncRep->getRep() );

   qApp->unlock();
}

#ifndef BOOST_DEFECT
void QtDisplay::addFunction ( FunctionBase * function ) {
   FunctionController * funcController = FunctionController::instance();
   DataRep * dataRep = m_plotter->getDataRep( 0 );

// The following datarep will be deleted by the CompositePlotter.
   FunctionRep * funcRep = 
      funcController->createFunctionRep(function, dataRep);

   qApp->lock();
   DisplayController * controller = DisplayController::instance();
   dataRep = reinterpret_cast<DataRep *>(funcRep);
   controller->addDataRep(m_plotter, dataRep);
   qApp->unlock();
}
#endif // BOOST_DEFECT

void QtDisplay::setRange ( const std::string & axis, double low, double high,
                           bool save)
{
  if ( qApp ) qApp->lock ();

  if (save) {
     if (axis == "x" || axis == "X") 
        m_ranges["x"] = std::make_pair(low, high);
     if (axis == "y" || axis == "Y") 
        m_ranges["y"] = std::make_pair(low, high);
  }
     
  m_plotter->setRange ( axis, low, high );

  if ( qApp ) qApp->unlock();
}

void QtDisplay::setRange ( const std::string & axis, double low, double high )
{
   setRange( axis, low, high, false );
}

std::vector<double> QtDisplay::getRange( const std::string & axis )
{
   Axes::Type type = Axes::convert ( axis );
   const Range & axisRange = m_plotter->getRange( type, true );
   std::vector<double> myRange;
   myRange.push_back(axisRange.low());
   myRange.push_back(axisRange.high());
   return myRange;
}

int QtDisplay::saveView ()
{
   std::vector<double> range_values;
   std::vector<double> range = getRange("x");
   range_values.push_back(range[0]);
   range_values.push_back(range[1]);
   m_ranges["x"] = std::make_pair(range[0], range[1]);

   range = getRange("y");
   range_values.push_back(range[0]);
   range_values.push_back(range[1]);
   m_ranges["y"] = std::make_pair(range[0], range[1]);

   return m_plotter->saveView(range_values);
}

void QtDisplay::setView ( int index )
{
  if ( qApp ) qApp->lock ();
  try {
     m_plotter->setView( index );
  } catch (...) {
     if ( qApp ) qApp->unlock();
     throw;
  }
  if ( qApp ) qApp->unlock();
}

int QtDisplay::nextView( bool stepForward ) {
   int index(-1);
   if ( qApp ) qApp->lock ();
   try {
      index = m_plotter->nextView(stepForward);
   } catch (...) {
      if ( qApp ) qApp->unlock();
      throw;
   }
   if ( qApp ) qApp->unlock();
   return index;
}

int QtDisplay::numViews () {
   return m_plotter->numViews();
}

void QtDisplay::deleteView (int index) {
   if ( qApp ) qApp->lock ();
   try {
      m_plotter->deleteView(index);
   } catch (...) {
      if ( qApp ) qApp->unlock();
      throw;
   }
   if ( qApp ) qApp->unlock();
}

int QtDisplay::currentView () {
   return m_plotter->currentView();
}

void QtDisplay::setTitle ( const std::string & title )
{
  if ( qApp ) qApp->lock ();
  m_plotter->setTitle ( title );
  if ( qApp ) qApp->unlock();
}

const std::string & QtDisplay::getTitle() const {
   return m_plotter->getTitle();
}

void
QtDisplay::
setPointRep ( RepBase * rep )
{
  if ( qApp ) qApp->lock ();
  try {
     m_plotter->setRepresentation ( rep );
  } catch ( const std::runtime_error & e ) {
    if ( qApp ) qApp->unlock ();
    throw e;
  }
  if ( qApp ) qApp->unlock();
}

void
QtDisplay::
setContourLevels ( const std::vector<double> &levels ) 
{
   if (qApp ) qApp->lock ();
   RepBase * rep = m_plotter->representation();
   
   if ( rep->name() == std::string("Contour") ) {
      DataRep * datarep 
         = m_plotter->getDataRep ( m_plotter->activePlotIndex() );

      dynamic_cast<ContourPointRep *>(rep)
         ->setContourValues( const_cast<std::vector<double>&>(levels), 
                             datarep->getProjector() );

      datarep->notifyObservers();

   } else {
      // do nothing
   }
   if (qApp ) qApp->unlock ();
}

void QtDisplay::setLabel ( const std::string & axis,
                           const std::string & label )
{
  if ( qApp ) qApp->lock ();
  Axes::Type at = Axes::convert ( axis );
  m_plotter->setLabel ( at, label );
  if ( qApp ) qApp->unlock();
}

const std::string & QtDisplay::getLabel ( const std::string & axis ) const {
   Axes::Type at = Axes::convert ( axis );
   return m_plotter -> getLabel ( at );
}

void
QtDisplay::
setNumberOfBins ( const std::string & axis, unsigned int number )
{
  m_plotter->setNumberOfBins ( axis, number );
}

void 
QtDisplay::
reset()
{
  qApp -> lock ();
  m_plotter -> reset ();
  qApp -> unlock ();
}

void QtDisplay::setBinWidth ( const std::string & axis, double width,
                              bool save )
{
  if ( qApp ) qApp->lock ();

  if (save) {
     if (axis == "x" || axis == "X") 
        m_binWidths["x"] = width;
     if (axis == "y" || axis == "Y") 
        m_binWidths["y"] = width;
  }     

  m_plotter->setBinWidth ( axis, width );

  if ( qApp ) qApp->unlock ();
}

double
QtDisplay::
getBinWidth ( const std::string & axis ) const
{
  return m_plotter->getBinWidth ( axis);
}

void QtDisplay::setBinWidth ( const std::string & axis, double width ) {
   setBinWidth( axis, width, false );
}

void QtDisplay::setOffset ( const std::string & axis, double offset )
{
  DisplayController * controller = DisplayController::instance ();
  Axes::Type type = Axes::convert ( axis );

  controller->setOffset ( m_plotter, type, offset );
}

void QtDisplay::setTransform ( const std::string & name )
{
  qApp->lock();

  DisplayController * controller = DisplayController::instance ();
  try {
     controller->setTransform ( m_plotter, name );
     qApp->unlock ();
  } catch (PlotterException & eObj) {
     qApp->unlock ();
     throw eObj;
  } catch (FactoryException & eObj) {
     qApp->unlock ();
     throw eObj;
  }
}

void QtDisplay::unlock() {
   qApp->unlock();
}

void QtDisplay::setLog ( const std::string & axis, int flag )
{
  if ( qApp ) qApp->lock ();
  Axes::Type type = Axes::convert ( axis );
  DisplayController * controller = DisplayController::instance ();
  bool yes = flag != 0;

  controller->setLog ( m_plotter, type, yes );
  if ( qApp ) qApp->unlock();
}

int QtDisplay::getLog ( const std::string & axis )
{
  DisplayController * controller = DisplayController::instance ();
  if ( controller->getLog ( m_plotter, axis) ) {
     return 1;
  } else {
     return 0;
  }
}

void QtDisplay::setAutoRanging ( const std::string & axis, bool flag )
{
  if ( qApp ) qApp->lock ();
  Axes::Type type = Axes::convert ( axis );
  m_plotter->setAutoRanging ( type, flag );
  if ( qApp ) qApp->unlock ();
}

PyDataRep * QtDisplay::getDataRep ()
{
  int index = m_plotter->activePlotIndex();
  if ( index < 0 ) index = 0;
  DataRep * rep = m_plotter->getDataRep ( index );
  PyDataRep * pyrep = new PyDataRep ( rep );

  return pyrep;
}

const std::vector<PyDataRep *> &QtDisplay::getDataReps () const
{
   m_pyDataReps.clear();
   int nReps = m_plotter->getNumDataReps();
   for (int i = 0; i < nReps; i++) {
      m_pyDataReps.push_back( new PyDataRep ( m_plotter->getDataRep( i ) ) );
   }
   return m_pyDataReps;
}

void
QtDisplay::
setAspectRatio ( double ratio )
{
  m_plotter->setAspectRatio ( ratio );
}

void
QtDisplay::
addValues ( const std::vector < double > & v )
{
  if ( qApp ) qApp -> lock ();
  m_plotter -> addValues ( v );
  if ( qApp ) qApp -> unlock ();
}

NTuple *
QtDisplay::
createNTuple () const
{
  // Need to lock else could create NTuple not yet displayed
  if (qApp) qApp -> lock ();
  FunctionController * controller = FunctionController::instance();
  NTuple * ntuple = controller -> createNTuple ( m_plotter );
  if(qApp) qApp -> unlock ();

  return ntuple;
}

double
QtDisplay::
numberOfEntries() const
{
   ProjectorBase * projector = m_plotter->activeProjector();
   return projector->getNumberOfEntries();
}

void
QtDisplay::
resize() 
{
   if ( qApp ) qApp->lock ();

   if (m_binWidths.count("x")) {
      m_plotter->setBinWidth("x", m_binWidths["x"]);
   } else {
// set and unset log-scale to get decent bin sizes
      DisplayController * controller = DisplayController::instance();
      if ( controller->getLog( m_plotter, "x" ) ) {
         setLog( "x", 0 );
         setLog( "x", 1 );
      } else { 
         setLog( "x", 1 );
         setLog( "x", 0 );
      }
   }

   if (m_binWidths.count("y")) {
      m_plotter->setBinWidth("y", m_binWidths["y"]);
   } else {
// set and unset log-scale to get decent bin sizes
      DisplayController * controller = DisplayController::instance();
      if ( controller->getLog( m_plotter, "y" ) ) {
         setLog( "y", 0 );
         setLog( "y", 1 );
      } else { 
         setLog( "y", 1 );
         setLog( "y", 0 );
      }
   }

   if (m_ranges.count("x")) {
      m_plotter->setRange("x", m_ranges["x"].first, m_ranges["x"].second);
   } else {
      m_plotter->setAutoRanging("x", true);
   }

   if (m_ranges.count("y")) {
      m_plotter->setRange("y", m_ranges["y"].first, m_ranges["y"].second);
   } else {
      m_plotter->setAutoRanging("y", true);
   }

   if ( qApp ) qApp->unlock ();
}

int QtDisplay::plotterId() const
{
   return m_plotter->plotterId();
}

void QtDisplay::
setColorMap ( const std::string & name ) {
   if ( qApp ) qApp->lock ();
   BinToColorFactory * factory = BinToColorFactory::instance();
   const vector< std::string > & names = factory -> names();
   if ( std::find(names.begin(), names.end(), name) != names.end() ) {
      BinToColor * rep = factory -> create ( name );
      m_plotter -> setValueRep( rep );
      if ( qApp ) qApp->unlock ();
   } else {
      if ( qApp ) qApp->unlock ();
      std::ostringstream message;
      message << "QtDisplay::setColorMap:\n"
              << "BinToColor rep '" << name << "' does not exist.\n"
              << "Valid rep names are \n\n";
      for (unsigned int i = 0; i < names.size() ; i++) {
         message << "'" << names[i] << "'\n";
      }
      throw std::runtime_error(message.str());
   }
}

void
QtDisplay::
update ()
{
  if ( qApp ) qApp->lock ();

  m_plotter -> update ();

  if ( qApp ) qApp->unlock ();
}

void
QtDisplay::
addObserver ( Observer * observer )
{
  m_plotter -> addObserver ( observer );
}

void
QtDisplay::
setTicks ( const std::string & axis,
           const std::vector < double > & values,
           const std::vector < std::string > & labels )
{
  if ( qApp ) qApp -> lock ();
  m_plotter -> setTicks ( axis, values, labels );
  if ( qApp ) qApp -> unlock ();
}

void
QtDisplay::
setAutoTicks ( const std::string & axis, bool yes )
{
  if ( qApp ) qApp -> lock ();
  m_plotter -> setAutoTicks ( axis, yes );
  if ( qApp ) qApp -> unlock ();
}

#ifdef HAVE_NUMARRAY

PyDataSource *
QtDisplay::
createDataArray () const
{
  // Need to lock else could create NTuple not yet displayed
  if (qApp) qApp -> lock ();

  FunctionController * controller = FunctionController::instance();
  NTuple * ntuple = controller -> createNTuple ( m_plotter );
  PyDataSource * ds = new PyDataSource ( "NTuple", ntuple );

  if(qApp) qApp -> unlock ();

  return ds;
}
#endif

---