PyApp.cxx

Go to the documentation of this file.

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

#include "PyApp.h" 

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

#include "HdThread.h" 
#include "PyCanvas.h" 

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

using namespace boost::python;

namespace hippodraw {
namespace Python {

void 
export_HDApp()
{
        class_ < PyApp > ( "HDApp",
                           "The HippoDraw application class.\n" )

          .def ( init < int >
                 ( "HDApp () -> HDApp\n"
                   "HDApp ( value ) -> HDApp\n"
                   "\n"
                   "Using the constructor with no arguments creates\n"
                   "a HippodDraw application that runs in a separate\n"
                   "thread.\n" 
                   "Using the constructor with one argument creates\n"
                   "a HippoDraw application in same thread. Use\n"
                   "app.exec_loop() to start it." ) )

          .def ( "instance", &PyApp::instance,
                 return_value_policy < reference_existing_object > (),
                 "instance () -> HDApp\n"
                 "\n"
                 "Returns a singleton instance of the HippoDraw \n"
                 "application object" )

          .staticmethod ( "instance" )

          .def ( "canvas", &PyApp::currentCanvas, 
                 return_value_policy < reference_existing_object > (),
                 "canvas () -> Canvas\n"
                 "\n"
                 "Returns the current canvas window." )

          .def ( "exec_loop", &PyApp::exec,
                 "exec_loop () -> value\n"
                 "\n"
                 "Starts the application object.  Returns the value returned\n"
                 "by the application object upon exiting." )

          .def ( "quit", &PyApp::quit,
                 "quit () -> None\n"
                 "\n"
                 "Closes all Canvas windows and Terminates the application." )

          .def ( "openDocument", &PyApp::openDocument,
                 "openDocument ( string ) -> None\n"
                 "\n"
                 "Opens new canvas window from saved document file." )

          .def ( "lock", &PyApp::lock,
                 "lock () -> None\n"
                 "\n"
                 "Lock the Qt library Mutex.   Will no return no other\n"
                 "thread has the lock." )

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

          ;
}

} // namesapce Python
} // namesapce hippodraw

PyApp * PyApp::s_instance = 0;

PyApp::PyApp ( )
{
  HdThread * m_thread = new HdThread ( );
  m_thread->start ();

  // Wait for application to initialize itself.  It is not sufficient
  // to wait just for the thread to run as it may cause segmentation
  // fault when we try to use the appliclication.
  while ( QtApp::startingUp () == true  ) {
    m_thread->wait ( 100 ); // wait for thread to run
  }
  m_app = QtApp::instance ();

#ifdef _MSC_VER
  // The folowing works under Windows, but under Linux leads to
  // occasional X Windows async errors
  while ( m_app->currentCanvas () == 0 ) {
    m_thread->wait ( 100 ); // wait for thread to create first window
  }
#else
  // The following seems to work better for Linux but not at all for
  // Windows ...
  while ( m_app->hasPendingEvents () == true ) {
    m_thread->wait ( 100 );
  }
#endif
  s_instance = this;
}

PyApp::PyApp ( int i )
{
  static int argc = 1;
  static char * argv[1];
  argv[0] = "HippoDraw";

  m_app = new QtApp ( argc, argv );
}

PyApp::~PyApp ( )
{
  //  m_app->closeAllWindows();
}

PyApp * PyApp::instance ()
{
  if ( s_instance == 0 ) {
    s_instance = new PyApp ();
  }

  return s_instance;
}

int PyApp::exec ()
{
  return m_app->exec();
}

void
PyApp::
quit ()
{
  m_app -> closeAllWindows ();
}

PyCanvas * PyApp::currentCanvas ()
{
  m_app->lock();
  CanvasWindow * canvas = m_app->currentCanvas();
  assert ( canvas );

  PyCanvas * pycanvas = new PyCanvas ( canvas );
  m_app->unlock ();
  return pycanvas;
}

void PyApp::openDocument ( const std::string & filename )
{
  m_app->lock (); // definitely need it else documents.py crashes

  CanvasWindow * window = new CanvasWindow ();
  window -> initFromFile ( filename );

  m_app->unlock ();
}

void PyApp::lock ()
{
  m_app->lock ();
}
void PyApp::unlock ()
{
  m_app->unlock ();
}

---