PythonTypes.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __PYTHONTYPES_H__
#define __PYTHONTYPES_H__
 
// If the following comment is read through the generated documentation then
// ignore this comment section.
// The following is doxygen comment in order to generate a page explaining the
// connection between python and H3DAPI. The % sign is a doxygen feature and
// can be ignored when reading the documentation directly in this header file.
 
 
#include <H3DUtil/Exception.h>
#include <H3D/X3DTypes.h>
#include <H3D/X3DFieldConversion.h>
#include <H3D/Node.h>
#include <H3D/H3DApi.h>
 
 
#ifdef HAVE_PYTHON
 
#include <H3D/Python3Compatibility.h>
#include <H3D/PyTypeWrapper.h>
 
 
namespace H3D {
 
  class PyNodePtr {
  public:
    PyNodePtr() : refCountNode ( true ), ptr( NULL ) {
      assert( H3DUtil::ThreadBase::inMainThread() );
      python_node_ptrs.insert( this );
    }
 
    ~PyNodePtr() {
      assert( H3DUtil::ThreadBase::inMainThread() );
      python_node_ptrs.erase( this );
    }
 
    inline void setRefCountNode ( bool _refCountNode ) {
      refCountNode= _refCountNode;
    }
 
    inline void setNodePtr( Node *_ptr ) {
      if( ptr ) {
        python_node_ptrs.erase( this );
      }
      
      if( refCountNode && ptr ) ptr->unref();
      ptr = _ptr;
      if( refCountNode && ptr ) ptr->ref();
 
      if (ptr && refCountNode) {
         python_node_ptrs.insert( this );
      }
    }
    inline Node *nodePtr() {
      return ptr;
    }
    static H3DAPI_API std::set<PyNodePtr *> python_node_ptrs;
 
  protected:
    bool refCountNode;
    Node *ptr;
  };
 
  // Python C declarations for PyNode type
 
  extern H3DAPI_API PyTypeObject PyNode_Type;
  inline string PyNode_Name() { return "Node"; }   
 
  PyObject H3DAPI_API *PyNode_FromNode( Node *v, bool _refCountNode= true );
 
  Node H3DAPI_API *PyNode_AsNode( PyObject *o );
 
  inline bool PyNode_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyNode_Type ) || o == Py_None;
  }
 
  struct PyNode : public PyType, PyNodePtr {
    
    static void installType( PyObject* H3D_module );
    
    static PyObject* create(); 
    
    static void dealloc( PyNode *self );
 
    static int init(PyNode *self, PyObject *args, PyObject *kwds);
 
    static PyObject* repr( PyNode *myself, PyObject *args);
 
    static int compare( PyObject *veca, PyObject *vecb );
 
#if PY_MAJOR_VERSION >= 3
    static PyObject* richCompare( PyObject *lhs, PyObject *rhs, int operation );
#endif
    
    static PyObject* getField( PyObject *myself, char* arg );
 
    static PyObject* getAttr( PyObject *myself, char* arg );
 
    static PyObject* getFieldList( PyObject *myself, PyObject *args );
 
    static PyObject* getName( PyObject *myself, PyObject *args );
 
    static PyObject* getTypeName( PyObject *myself, PyObject *args );
 
    static PyObject* setName( PyObject *self, PyObject *args );
 
    static PyObject* getSingleField( PyObject *self, PyObject *args );
 
    static PyObject* addField( PyObject *self, PyObject *args );
 
    static PyObject* removeField( PyObject *self, PyObject *args);
 
    static PyObject* clearFields( PyObject* self, PyObject *args );
 
    static PyObject* clone ( PyObject* self, PyObject *args );
 
    static PyObject* closestPoint ( PyObject* self, PyObject *args );
 
    static PyObject* lineIntersect ( PyObject* self, PyObject *args );
  };
 
  // Python C declarations for PyVec2f type
 
  extern H3DAPI_API PyTypeObject PyVec2f_Type;
  inline string PyVec2f_Name() { return "Vec2f"; }   
 
  PyObject *PyVec2f_FromVec2f( const Vec2f &v);
 
  Vec2f H3DAPI_API PyVec2f_AsVec2f( PyObject *o );
 
  inline bool PyVec2f_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec2f_Type);
  }
 
  struct PyVec2f : 
        public PyVecTypeWrapper< Vec2f, 
    &PyVec2f_Type,
    PyVec2f_Name,
    PyVec2f_Check,
    PyVec2f_AsVec2f, 
    PyVec2f_FromVec2f >{
    
    static int init(PyVec2f *self, PyObject *args, PyObject *kwds);
 
    static PyObject* length( PyObject *self, PyObject *args );
    
    static PyObject* lengthSqr( PyObject *self, PyObject *args );
 
    static PyObject* normalize( PyObject *self, PyObject *args );
    
    static PyObject* normalizeSafe( PyObject *self, PyObject *args );
 
    static PyObject* dotProduct( PyObject *self, PyObject *args );
 
  };
  
  // Python C declarations for PyVec2d type
 
  extern H3DAPI_API PyTypeObject PyVec2d_Type;
  inline string PyVec2d_Name() { return "Vec2d"; }   
 
  PyObject *PyVec2d_FromVec2d( const Vec2d &v);
 
  Vec2d H3DAPI_API PyVec2d_AsVec2d( PyObject *o );
 
  inline bool PyVec2d_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec2d_Type);
  }
 
  namespace PythonInternals {
    inline bool PyVec2d2f_Check( PyObject *o) {
      return PyObject_TypeCheck(o,&PyVec2d_Type) ||
        PyObject_TypeCheck( o, &PyVec2f_Type );
    }
    
    Vec2d PyVec2d2f_AsVec2d( PyObject *o );
  }
  
 
  // In the PyVec2d operators a PyVec2f can be used instead of a PyVec2d so we 
  // used the specially defined PyVec2d2f operators for this type.
  struct PyVec2d : 
        public PyVecTypeWrapper< Vec2d, 
    &PyVec2d_Type,
    PyVec2d_Name,
    PythonInternals::PyVec2d2f_Check,
    PythonInternals::PyVec2d2f_AsVec2d, 
    PyVec2d_FromVec2d >{
    
    static int init(PyVec2d *self, PyObject *args, PyObject *kwds);
 
    static PyObject* length( PyObject *self, PyObject *args );
    
    static PyObject* lengthSqr( PyObject *self, PyObject *args );
 
    static PyObject* normalize( PyObject *self, PyObject *args );
    
    static PyObject* normalizeSafe( PyObject *self, PyObject *args );
 
    static PyObject* dotProduct( PyObject *self, PyObject *args );
  };
  
  // Python C declarations for PyVec3f type
 
  extern H3DAPI_API PyTypeObject PyVec3f_Type;
 
  inline string PyVec3f_Name() { return "Vec3f"; }   
 
  PyObject *PyVec3f_FromVec3f( const Vec3f &v);
 
  Vec3f H3DAPI_API PyVec3f_AsVec3f( PyObject *o );
 
  inline bool PyVec3f_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec3f_Type);
  }
 
  struct PyVec3f : 
    public PyVecTypeWrapper< Vec3f, 
    &PyVec3f_Type,
    PyVec3f_Name,
    PyVec3f_Check,
    PyVec3f_AsVec3f, 
    PyVec3f_FromVec3f > {
 
    static int init(PyVec3f *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mod( PyObject *veca, PyObject *vecb );
    
    static PyObject* length( PyObject *self, PyObject *args );
    
    static PyObject* lengthSqr( PyObject *self, PyObject *args );
 
    static PyObject* normalize( PyObject *self, PyObject *args );
    
    static PyObject* normalizeSafe( PyObject *self, PyObject *args );
 
    static PyObject* dotProduct( PyObject *self, PyObject *args );
 
    static PyObject* crossProduct( PyObject *self, PyObject *args );
 
  };
  
  // Python C declarations for PyVec3d type
 
  extern H3DAPI_API PyTypeObject PyVec3d_Type;
 
  inline string PyVec3d_Name() { return "Vec3d"; }   
 
  PyObject *PyVec3d_FromVec3d( const Vec3d &v);
 
  Vec3d H3DAPI_API PyVec3d_AsVec3d( PyObject *o );
 
  inline bool PyVec3d_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec3d_Type);
  }
 
  namespace PythonInternals {
    inline bool PyVec3d3f_Check( PyObject *o) {
      return PyObject_TypeCheck(o,&PyVec3d_Type) ||
        PyObject_TypeCheck( o, &PyVec3f_Type );
    }
    
    Vec3d PyVec3d3f_AsVec3d( PyObject *o );
  }
 
 
  // In the PyVec3d operators a PyVec3f can be used instead of a PyVec3d so we 
  // used the specially defined PyVec3d3f operators for this type.
  struct PyVec3d : public PyVecTypeWrapper< Vec3d, 
                   &PyVec3d_Type,
                   PyVec3d_Name,
                   PythonInternals::PyVec3d3f_Check,
                   PythonInternals::PyVec3d3f_AsVec3d, 
                   PyVec3d_FromVec3d > {
    static int init(PyVec3d *self, PyObject *args, PyObject *kwds);
    static PyObject* mod( PyObject *veca, PyObject *vecb );
    static PyObject* length( PyObject *self, PyObject *args );
    static PyObject* lengthSqr( PyObject *self, PyObject *args );
    static PyObject* normalize( PyObject *self, PyObject *args );
    static PyObject* normalizeSafe( PyObject *self, PyObject *args );
    static PyObject* dotProduct( PyObject *self, PyObject *args );
 
    static PyObject* crossProduct( PyObject *self, PyObject *args );
  };
  
  // Python C declarations for PyVec4f type
 
  extern H3DAPI_API PyTypeObject PyVec4f_Type;
 
  inline string PyVec4f_Name() { return "Vec4f"; }   
 
  PyObject *PyVec4f_FromVec4f( const Vec4f &v);
 
  Vec4f H3DAPI_API PyVec4f_AsVec4f( PyObject *o );
 
  inline bool PyVec4f_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec4f_Type);
  }
 
  struct PyVec4f : public PyVecTypeWrapper< Vec4f, 
                   &PyVec4f_Type,
                   PyVec4f_Name,
                   PyVec4f_Check,
                   PyVec4f_AsVec4f, 
                   PyVec4f_FromVec4f > {
    
    static int init(PyVec4f *self, PyObject *args, PyObject *kwds);
  };
  
  
  // Python C declarations for PyVec4d type
 
  extern H3DAPI_API PyTypeObject PyVec4d_Type;
 
  inline string PyVec4d_Name() { return "Vec4d"; }   
 
  PyObject *PyVec4d_FromVec4d( const Vec4d &v);
 
  Vec4d H3DAPI_API PyVec4d_AsVec4d( PyObject *o );
 
  inline bool PyVec4d_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec4d_Type);
  }
 
  namespace PythonInternals {
    inline bool PyVec4d4f_Check( PyObject *o) {
      return PyObject_TypeCheck(o,&PyVec4d_Type) ||
        PyObject_TypeCheck( o, &PyVec4f_Type );
    }
    
    Vec4d PyVec4d4f_AsVec4d( PyObject *o );
  }
 
  struct PyVec4d : public PyVecTypeWrapper< Vec4d, 
                   &PyVec4d_Type,
                   PyVec4d_Name,
                   PythonInternals::PyVec4d4f_Check,
                   PythonInternals::PyVec4d4f_AsVec4d, 
                   PyVec4d_FromVec4d > {
    
    static int init(PyVec4d *self, PyObject *args, PyObject *kwds);
  };
 
  // Python C declarations for PyRotation type
 
  extern H3DAPI_API PyTypeObject PyRotation_Type;
 
  inline string PyRotation_Name() { return "Rotation"; }   
 
  PyObject *PyRotation_FromRotation( const Rotation &v);
 
  Rotation H3DAPI_API PyRotation_AsRotation( PyObject *o );
 
  inline bool PyRotation_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyRotation_Type);
  }
 
  struct PyRotation : public PyNumberTypeWrapper< Rotation, 
                   &PyRotation_Type,
                   PyRotation_Name,
                   PyRotation_Check,
                   PyRotation_AsRotation, 
                   PyRotation_FromRotation > {
  
    static int init(PyRotation *self, PyObject *args, PyObject *kwds);
 
    static PyObject *toEulerAngles( PyObject *self, PyObject *args );
 
    static PyObject *slerp( PyObject *self, PyObject *args );
 
    static PyObject* mul( PyObject *rota, PyObject *rotb );
  };
  
  // Python C declarations for PyQuaternion type
  
  extern H3DAPI_API PyTypeObject PyQuaternion_Type;
 
  inline string PyQuaternion_Name() { return "Quaternion"; }   
 
  PyObject *PyQuaternion_FromQuaternion( const Quaternion &v);
 
  Quaternion H3DAPI_API PyQuaternion_AsQuaternion( PyObject *o );
 
  inline bool PyQuaternion_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyQuaternion_Type);
  }
 
  struct PyQuaternion : public PyNumberTypeWrapper< Quaternion, 
                   &PyQuaternion_Type,
                   PyQuaternion_Name,
                   PyQuaternion_Check,
                   PyQuaternion_AsQuaternion, 
                   PyQuaternion_FromQuaternion > {
 
    static int init(PyQuaternion *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mul( PyObject *rota, PyObject *rotb );
 
    static PyObject *toEulerAngles( PyObject *self, PyObject *args );
 
    static PyObject *norm( PyObject *self, PyObject *args );
 
    static PyObject* normalize( PyObject *self, PyObject *args );
 
    static PyObject* conjugate( PyObject *self, PyObject *args );
 
    static PyObject* inverse( PyObject *self, PyObject *args ); 
 
    static PyObject* slerp( PyObject *self, PyObject *args ); 
 
    static PyObject* dotProduct( PyObject *self, PyObject *args ); 
  };
 
  // Python C declarations for PyMatrix3f type
 
  extern H3DAPI_API PyTypeObject PyMatrix3f_Type;
 
  inline string PyMatrix3f_Name() { return "Matrix3f"; }   
 
  PyObject *PyMatrix3f_FromMatrix3f( const Matrix3f &v);
 
  Matrix3f H3DAPI_API PyMatrix3f_AsMatrix3f( PyObject *o );
 
  inline bool PyMatrix3f_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyMatrix3f_Type);
  }
  struct PyMatrix3f : public PyNumberTypeWrapper< Matrix3f, 
                      &PyMatrix3f_Type,
                      PyMatrix3f_Name,
                      PyMatrix3f_Check,
                      PyMatrix3f_AsMatrix3f, 
                      PyMatrix3f_FromMatrix3f > {
    
    static int init(PyMatrix3f *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mul( PyObject *rota, PyObject *rotb );
    
    static PyObject* setToIdentity( PyObject *self, PyObject *args );
 
    static PyObject* inverse( PyObject *self, PyObject *args );
 
    static PyObject* transpose( PyObject *self, PyObject *args );
 
    static PyObject* toEulerAngles( PyObject *self, PyObject *args );
 
    static PyObject* getScalePart( PyObject *self, PyObject *args );
 
    static PyObject* getRow( PyObject *self, PyObject *args );
 
    static PyObject* getColumn( PyObject *self, PyObject *args );
 
    static PyObject* getElement( PyObject *self, PyObject *args );
 
    static PyObject* setElement( PyObject *self, PyObject *args );
  };
    
  // Python C declarations for PyMatrix4f type
 
  extern H3DAPI_API PyTypeObject PyMatrix4f_Type;
 
  inline string PyMatrix4f_Name() { return "Matrix4f"; }   
 
  PyObject *PyMatrix4f_FromMatrix4f( const Matrix4f &v);
 
  Matrix4f H3DAPI_API PyMatrix4f_AsMatrix4f( PyObject *o );
 
  inline bool PyMatrix4f_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyMatrix4f_Type);
  }
  struct PyMatrix4f : public PyNumberTypeWrapper< Matrix4f, 
                      &PyMatrix4f_Type,
                      PyMatrix4f_Name,
                      PyMatrix4f_Check,
                      PyMatrix4f_AsMatrix4f, 
                      PyMatrix4f_FromMatrix4f > {
    
    
    static int init(PyMatrix4f *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mul( PyObject *rota, PyObject *rotb );
    
    static PyObject* setToIdentity( PyObject *self, PyObject *args );
 
    static PyObject* transformInverse( PyObject *self, PyObject *args );
 
    static PyObject* inverse( PyObject *self, PyObject *args );
 
    static PyObject* transpose( PyObject *self, PyObject *args );
 
    static PyObject* getRow( PyObject *self, PyObject *args );
 
    static PyObject* getColumn( PyObject *self, PyObject *args );
 
    static PyObject* getScaleRotationPart( PyObject *self, PyObject *args );
 
    static PyObject* getRotationPart( PyObject *self, PyObject *args );
 
    static PyObject* getScalePart( PyObject *self, PyObject *args );
    
    static PyObject* getTranslationPart( PyObject *self, PyObject *args );
 
    static PyObject* getElement( PyObject *self, PyObject *args );
 
    static PyObject* setElement( PyObject *self, PyObject *args );
  };
 
 
  // Python C declarations for PyMatrix3d type
 
  extern H3DAPI_API PyTypeObject PyMatrix3d_Type;
 
  inline string PyMatrix3d_Name() { return "Matrix3d"; }   
 
  PyObject *PyMatrix3d_FromMatrix3d( const Matrix3d &v);
 
  Matrix3d H3DAPI_API PyMatrix3d_AsMatrix3d( PyObject *o );
 
  inline bool PyMatrix3d_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyMatrix3d_Type);
  }
 
  namespace PythonInternals {
    inline bool PyMatrix3d3f_Check( PyObject *o) {
      return PyObject_TypeCheck(o,&PyMatrix3d_Type) ||
        PyObject_TypeCheck( o, &PyMatrix3f_Type );
    }
    
    Matrix3d PyMatrix3d3f_AsMatrix3d( PyObject *o );
  }
 
  struct PyMatrix3d : public PyNumberTypeWrapper< Matrix3d, 
                      &PyMatrix3d_Type,
                      PyMatrix3d_Name,
                      PythonInternals::PyMatrix3d3f_Check,
                      PythonInternals::PyMatrix3d3f_AsMatrix3d, 
                      PyMatrix3d_FromMatrix3d > {
    
    static int init(PyMatrix3d *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mul( PyObject *rota, PyObject *rotb );
    
    static PyObject* setToIdentity( PyObject *self, PyObject *args );
 
    static PyObject* inverse( PyObject *self, PyObject *args );
 
    static PyObject* transpose( PyObject *self, PyObject *args );
 
    static PyObject* toEulerAngles( PyObject *self, PyObject *args );
 
    static PyObject* getScalePart( PyObject *self, PyObject *args );
 
    static PyObject* getRow( PyObject *self, PyObject *args );
 
    static PyObject* getColumn( PyObject *self, PyObject *args );
 
    static PyObject* getElement( PyObject *self, PyObject *args );
 
    static PyObject* setElement( PyObject *self, PyObject *args );
  };
    
  // Python C declarations for PyMatrix4d type
 
  extern H3DAPI_API PyTypeObject PyMatrix4d_Type;
 
  inline string PyMatrix4d_Name() { return "Matrix4d"; }   
 
  PyObject *PyMatrix4d_FromMatrix4d( const Matrix4d &v);
 
  Matrix4d H3DAPI_API PyMatrix4d_AsMatrix4d( PyObject *o );
 
  inline bool PyMatrix4d_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyMatrix4d_Type);
  }
 
  namespace PythonInternals {
    inline bool PyMatrix4d4f_Check( PyObject *o) {
      return PyObject_TypeCheck(o,&PyMatrix4d_Type) ||
        PyObject_TypeCheck( o, &PyMatrix4f_Type );
    }
    
    Matrix4d PyMatrix4d4f_AsMatrix4d( PyObject *o );
  }
 
  struct PyMatrix4d : public PyNumberTypeWrapper< Matrix4d, 
                      &PyMatrix4d_Type,
                      PyMatrix4d_Name,
                      PythonInternals::PyMatrix4d4f_Check,
                      PythonInternals::PyMatrix4d4f_AsMatrix4d, 
                      PyMatrix4d_FromMatrix4d > {
    
    
    static int init(PyMatrix4d *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mul( PyObject *rota, PyObject *rotb );
    
    static PyObject* setToIdentity( PyObject *self, PyObject *args );
 
    static PyObject* transformInverse( PyObject *self, PyObject *args );
 
    static PyObject* inverse( PyObject *self, PyObject *args );
 
    static PyObject* transpose( PyObject *self, PyObject *args );
 
    static PyObject* getRow( PyObject *self, PyObject *args );
 
    static PyObject* getColumn( PyObject *self, PyObject *args );
 
    static PyObject* getScaleRotationPart( PyObject *self, PyObject *args );
 
    static PyObject* getRotationPart( PyObject *self, PyObject *args );
 
    static PyObject* getScalePart( PyObject *self, PyObject *args );
 
    static PyObject* getTranslationPart( PyObject *self, PyObject *args );
 
    static PyObject* getElement( PyObject *self, PyObject *args );
 
    static PyObject* setElement( PyObject *self, PyObject *args );
  };
    
  // Python C declarations for PyRGB type
  
  extern H3DAPI_API PyTypeObject PyRGB_Type;
 
  inline string PyRGB_Name() { return "RGB"; }   
 
  PyObject *PyRGB_FromRGB( const RGB &v);
 
  RGB H3DAPI_API PyRGB_AsRGB( PyObject *o );
 
  inline bool PyRGB_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyRGB_Type);
  }
 
  struct PyRGB : public PyTypeWrapper< RGB, 
                 &PyRGB_Type,
                 PyRGB_Name,
                 PyRGB_Check,
                 PyRGB_AsRGB, 
                 PyRGB_FromRGB > {
    
    static int init(PyRGB *self, PyObject *args, PyObject *kwds);
  };
 
  // Python C declarations for PyRGBA type
  
  extern H3DAPI_API PyTypeObject PyRGBA_Type;
 
  inline string PyRGBA_Name() { return "RGBA"; }   
 
  PyObject *PyRGBA_FromRGBA( const RGBA &v);
 
  RGBA H3DAPI_API PyRGBA_AsRGBA( PyObject *o );
 
  inline bool PyRGBA_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyRGBA_Type);
  }
 
  struct PyRGBA : public PyTypeWrapper< RGBA, 
                 &PyRGBA_Type,
                 PyRGBA_Name,
                 PyRGBA_Check,
                 PyRGBA_AsRGBA, 
                 PyRGBA_FromRGBA > {
    
    static int init(PyRGBA *self, PyObject *args, PyObject *kwds);
  };
 
  // Python C declarations for PyConsole type(interface to Console)
  extern H3DAPI_API PyTypeObject PyConsole_Type;
 
  struct PyConsole: public PyType {
    PyConsole() : log_level( LogLevel::Info ) {}
 
    static void installType( PyObject* H3D_module ) {
      if (PyType_Ready( &PyConsole_Type ) < 0 )
        return; // THROW ERROR!?
      
      Py_INCREF( &PyConsole_Type );
      PyModule_AddObject( H3D_module, 
                          "H3DConsole", 
                          (PyObject *)&PyConsole_Type );
    }
  
    static int init(PyConsole *self, PyObject *args, PyObject *kwds);
   
    static void dealloc( PyObject *self ) {
      self->ob_type->tp_free( self );
    }
 
    static PyObject* write( PyObject *self, PyObject *to_write );
    static PyObject* flush( PyObject *self, PyObject *args );
    static PyObject* writeAtLevel( PyObject *self, PyObject *args );
 
    int log_level;
 
  };
 
  inline string PyConsole_Name() { return "Console"; }   
 
  inline bool PyConsole_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyConsole_Type);
  }
  
    
}
  
#endif
#endif