PyCanvas.cxx

Go to the documentation of this file.

// for dll interface warning
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "PyCanvas.h"

#include "QtCut.h"

#include "controllers/DisplayController.h"
#include "controllers/FunctionController.h"
#include "datasrcs/DataSourceException.h"
#include "pattern/FactoryException.h"
#include "plotters/Cut1DPlotter.h"

// with Python 2.3, include before Qt headers to avoid conflict with
// symbol `slots'
#include <boost/python.hpp>

#include "qt/QtView.h"
#include "qt/CanvasWindow.h"

#include <qapplication.h>

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

namespace hippodraw {
namespace Python {

void 
export_Canvas()
{
        class_ < PyCanvas >
          ( "Canvas",
            "The HippoDraw canvas.\n"
            "This class provides an interface to the canvas.\n"
            "One can take various actions that are also\n"
            "available from menu items in the canvas window.",
            no_init )

          .def ( "show", &PyCanvas::show,
                 "Displays the canvas window on the screen." )

          .def ( "close", &PyCanvas::close,
                 "Closes the window." )

           .def ( "addDisplay", &PyCanvas::addDisplay,
                  "Adds a display to the canvas.\n"
                  "Arguments:\n"
                  "\t a display object" )

           .def ( "saveAs", &PyCanvas::saveAs,
                  "Save the canvas as a XML file.\n"
                  "Argument:\n"
                  "\t A string specifying the file name." )

           .def ( "printTo", &PyCanvas::print,
                  "Prints the canvas to PostScript file\n"
                  "Argument:\n"
                  "\t a string specifying the file name" )

           .def ( "getDisplay", &PyCanvas::getDisplay,
                  return_value_policy < reference_existing_object > (),
                  "Returns the selected Display object.\n"
                  "Arguments:\n"
                  "\t none\n"
                  "Returns:\n"
                  "\t The selected Display object or None" )

           .def ( "getDisplays", &PyCanvas::getDisplays,
                  return_value_policy < copy_const_reference > (),
                  "Returns a tuple of all Display objects on the canvas.\n"
                  "Arguments:\n"
                  "\t none" )

           .def ( "getCut", &PyCanvas::getCut,
                  return_value_policy < reference_existing_object > (),
                  "Returns the currently selected Cut object.\n"
                  "Aguments:\n"
                  "\t none\n"
                  "Returns:\n"
                  "\t A Cut object or none if selected Display is not a Cut." )

           .def ( "selectAllDisplays", &PyCanvas::selectAllDisplays,
                  "Sets all displays to selected state or not.\n"
                  "Arugment:\n"
                  "\t True or False" )

           .def ( "selectDisplay", &PyCanvas::selectDisplay,
                  "Sets a display to selected state.\n"
                  "Arugment:\n"
                  "\t a display object" )

           .def ( "saveAsImage", &PyCanvas::saveAsImage,
                  "Save a display as an image file.\n"
                  "The suffix of the file name controls the image type.\n"
                  "Arguments:\n"
                  "\t a display object\n"
                  "\t a string specifying the file name" )

           .def ( "saveSelectedImages", &PyCanvas::saveSelectedImages,
                  "Save the selected displays as an image file.\n"
                  "The suffix of the file name controls the image type.\n"
                  "Arguments:\n"
                  "\t a string specifying the file name" )

           .def ( "removeDisplay", &PyCanvas::removeDisplay,
                  "Removes the display from the canvas\n"
                  "Argument: display object" )

           .def ( "addText", &PyCanvas::addText,
                  "Adds text to display.\n"
                  "Arguments:\n"
                  "\t display object\n"
                  "\t text string"  )

           .def ( "addTextAt", &PyCanvas::addTextAt,
                  "Adds text to a display at specified position\n"
                  "Position is fraction of width and height\n"
                  "Arguments:\n"
                  "\t display object\n"
                  "\t text string\n"
                  "\t x position\n"
                  "\t y position" )

          .def ( "addTextRep", &PyCanvas::addTextRep,
                 "adds textual data representation to display\n"
                 "Arguments:\n"
                 "\t Display object\n"
                 "\t representation type (string)" )

           .def ( "mouseData", &PyCanvas::mouseData,
                  return_value_policy < copy_const_reference > (),
                  "Returns a list of picked data\n"
                  "Arguments:\n"
                  "\t none" )

          .def ( "setPlotMatrix", &PyCanvas::setPlotMatrix,
                 "Sets the number of columns and "
                 "rows of plots for each page.\n"
                 "Arguments:\n"
                 "\t columns\n"
                 "\t rows" )

          .def ( "getTextRepTypes", &PyCanvas::getTextRepTypes,
                 return_value_policy < copy_const_reference > (),
                 "Returns the types of textual data representations"
                 " available\n"
                 "Arguments:\n"
                 "\t none" )
          .def ( "clear", &PyCanvas::clear,
                 "Removes all items from the canvas" )

           ;
}

} // namesapce Python
} // namesapce hippodraw

PyCanvas::PyCanvas ( CanvasWindow * window ) 
{
  m_canvas = window;
  m_app = qApp;
}

PyCanvas::PyCanvas ( )
{
  m_app = qApp;
  m_app->lock();
  m_canvas = new CanvasWindow ();
  m_app->unlock();
}

void
PyCanvas::
show ()
{
  m_app -> lock ();
  m_canvas -> show ();
  m_app -> unlock ();
}

void
PyCanvas::
close ()
{
  m_app -> lock ();
  m_canvas -> closeNoPrompt ();
  m_app -> unlock ();
}

void PyCanvas::addDisplay ( QtDisplay * display_wrap )
{
#ifndef _MSC_VER
  m_app->lock ();
#endif

  PlotterBase * plotter = display_wrap->display();
  m_canvas->addPlotDisplay ( plotter );
  
#ifndef _MSC_VER
  m_app->unlock ();
#endif
}

void PyCanvas::saveAs ( const std::string & filename )
{
  m_app->lock ();
  m_canvas->saveAs ( filename );
  m_app->unlock ();
}

QtDisplay * PyCanvas::getDisplay ()
{
  m_app -> lock ();
  QtDisplay * display = 0;
   PlotterBase * plotter = m_canvas->selectedPlotter();
   if (plotter != 0) {
      display = new QtDisplay( m_canvas->selectedPlotter() );
   }
   m_app -> unlock ();

   return display;
}

const std::vector<QtDisplay *> & PyCanvas::getDisplays() const {

   m_app->lock();    // Locking the app may not be necessary.
   m_displays.clear();

// Replicate some of the logic in PlotTable::initialize() to create
// a vector of QtDisplay pointers.
 
   const std::vector< const ViewBase * > & views = m_canvas->views();
   std::vector< const ViewBase * > :: const_iterator viewIt = views.begin();
   while ( viewIt != views.end() ) {
      const ViewBase * view = *viewIt++;
      PlotterBase * plotter = view->getPlotter();
      m_displays.push_back( new QtDisplay(plotter) );
   }
   m_app->unlock();
   return m_displays;
}

QtCut * 
PyCanvas::
getCut ()
{
  QtCut * qtcut = 0;
  PlotterBase * plotter = m_canvas->selectedPlotter();

  if ( plotter != 0 ) {
     CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( plotter );

     if ( cut_plotter != 0 ) {
       qtcut = new QtCut ( cut_plotter );
     }
  }

  return qtcut;
}

void PyCanvas::selectAllDisplays ( bool flag )
{
   m_app->lock();
   m_canvas -> setAllSelected ( flag );
   m_app->unlock();
}

void PyCanvas::selectDisplay ( QtDisplay * display ) {
   m_app->lock();
   QtView * selectedView = findSelectedView ( display );
   if ( selectedView ) {
      m_canvas->setSelected( selectedView );
   }
   m_app->unlock();
}

void
PyCanvas::
print ( const std::string & filename )
{
  m_app -> lock ();
  m_canvas -> print ( filename );
  m_app -> unlock ();
}

void PyCanvas::saveAsImage( QtDisplay * display, const std::string &filename )
{
   m_app->lock();
// Ensure that a suffix is provided...
   std::string::size_type i = filename.find_last_of( '.' );
   if ( i == std::string::npos ) {
      const std::string 
         what ( "PyCanvas::saveAsImage: filename suffix missing." );
      m_app->unlock();
      throw DataSourceException( what );
   }

   QtView * selectedView = findSelectedView( display );
   if ( selectedView ) {
      std::string file = filename;
      PlotterBase * plotter = selectedView->getPlotter();
      m_canvas->savePlotAsImageImmediate ( plotter, file );
   }
   m_app->unlock();
}

void PyCanvas::saveSelectedImages( const std::string &filename )
{
   m_app->lock();
// Ensure that a suffix is provided...
   std::string::size_type i = filename.find_last_of( '.' );
   if ( i == std::string::npos ) {
      const std::string 
         what ( "PyCanvas::saveSelectedImages: filename suffix missing." );
      m_app->unlock();
      throw DataSourceException( what );
   }
   m_canvas->fileSaveSelectedImages ( filename );
   m_app->unlock();
}

QtView * PyCanvas::findSelectedView ( QtDisplay * display )
{
   PlotterBase * myPlotter = display->display();

   const std::vector< const ViewBase * > & views = m_canvas->views();
   std::vector< const ViewBase * > :: const_iterator viewIt = views.begin();
   while ( viewIt != views.end() ) {
      const ViewBase * view = *viewIt++;
      if ( myPlotter == view->getPlotter() ) {
         return m_canvas->getViewFor( myPlotter );
      }
   }
   return 0;
}   

void PyCanvas::removeDisplay ( QtDisplay * display )
{
   PlotterBase * plotter = display->display();
   m_canvas->removeDisplay ( plotter );
}

void
PyCanvas::
addTextRep ( QtDisplay * display, const std::string & type )
{
  m_app -> lock ();

  try {
    PlotterBase * plotter = display -> display ();
    if ( type == "Function Parameters" ||
         type == "Chi-squared" ) {
      FunctionController * controller = FunctionController::instance ();
      if ( controller -> hasFunction ( plotter, 0 ) ) {
        m_canvas -> addFuncDisplay ( plotter, type );
      }
    }
    else {
      plotter -> setActivePlot ( 0, false );
      const std::string null ("");
      m_canvas -> addTextDisplay ( plotter, type, null );
      plotter -> setActivePlot ( -1, true );
    }

  }
  catch ( const FactoryException & e ) {
    m_app -> unlock ();
    throw e;
  }

  m_app -> unlock ();
}

const std::vector < std::string > &
PyCanvas::getTextRepTypes () const
{
  DisplayController * controller = DisplayController:: instance ();

  return controller -> getTextTypes ();
}

void PyCanvas::addText( QtDisplay * display, 
                        const std::string &text )
{
   m_app->lock();

   PlotterBase * plotter = display->display();

// Only one datarep can be active in order to add a "Text From Box"
// textrep.
   plotter->setActivePlot(0, false);

   m_canvas->addTextDisplay( plotter, "Text From Box", text );

// Reset all plotters active.
   plotter->setActivePlot(-1, true);

   m_app->unlock();
}

void PyCanvas::addTextAt ( QtDisplay * display, const std::string &text,
                           double xrel, double yrel )
{
   m_app->lock();

   PlotterBase * plotter = display->display();

// Only one datarep can be active in order to add a "Text From Box"
// textrep.
   plotter->setActivePlot(0, false);
   m_canvas->addTextDisplayAt ( plotter, "Text From Box", 
                                text, xrel, yrel );

// Reset all plotters active.
   plotter->setActivePlot(-1, true);

   m_app->unlock();
}

const std::vector<double> & PyCanvas::mouseData() 
{
   return m_canvas->mouseEventData();
}

void
PyCanvas::
setPlotMatrix ( unsigned int columns, unsigned int rows )
{
  m_app -> lock ();
  m_canvas -> setPlotMatrix ( columns, rows );
  m_app -> unlock ();
}

/* examples/run_examples.py fails unless lock/unlock is remove under
   windows.
*/
void
PyCanvas::
clear ()
{
#ifndef _MSC_VER
  m_app -> lock ();
#endif

  m_canvas -> clear ();

#ifndef _MSC_VER
  m_app -> unlock ();
#endif
}

---