Changeset 20403

Show
Ignore:
Timestamp:
06/30/07 09:25:23 (1 year ago)
Author:
patrick
Message:

Updated for Gadgeteer 1.3.9. Bumped version to 1.3.1.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • PyJuggler/trunk/ChangeLog

    r19942 r20403  
    11DATE        AUTHOR      CHANGE 
    22----------- ----------- ------------------------------------------------------- 
     3Jun-30-2007 patrick     Updated for Gadgeteer 1.3.9. 
     4                        NEW VERSION: 1.3.1 
    35Apr-11-2007 patrick     Updated for Gadgeteer 1.1.24. 
    46                        NEW VERSION: 1.1.14 

  • PyJuggler/trunk/configure.ac

    r19942 r20403  
    33# accompanying file COPYING.txt or http://www.gnu.org/copyleft/lesser.txt) 
    44 
    5 AC_INIT([PyJuggler], [1.1], [vrjuggler-devel@lists.sourceforge.net]) 
     5AC_INIT([PyJuggler], [1.3], [vrjuggler-devel@lists.sourceforge.net]) 
    66AC_PREREQ([2.53]) 
    7 AC_COPYRIGHT([PyJuggler is (C) Copyright 2002-2005 by Patrick Hartling]) 
     7AC_COPYRIGHT([PyJuggler is (C) Copyright 2002-2007 by Patrick Hartling]) 
    88AC_REVISION([$Revision$]) 
    99AC_CONFIG_SRCDIR([src/gadgeteer-wrappers.h]) 
    …… 
    414414              [AC_MSG_ERROR([*** JCCL is required for PyJuggler ***])]) 
    415415SNX_PATH([0.5.0], , [AC_MSG_ERROR([*** Sonix is required for PyJuggler ***])]) 
    416 GADGETEER_PATH([1.1.24], , 
     416GADGETEER_PATH([1.3.9], , 
    417417               [AC_MSG_ERROR([*** Gadgeteer is required for PyJuggler ***])]) 
    418418VRJUGGLER_PATH([2.1.21], , 

  • PyJuggler/trunk/dist/__init__.py

    r19942 r20403  
    66__all__     = ["vrj", "cluster", "gadget", "snx", "jccl", "vpr"] 
    77__build__   = 1 
    8 __version__ = '1.1.14.%d' % __build__ 
     8__version__ = '1.3.1.%d' % __build__ 
    99__date__    = string.join(string.split('$Date$')[1:3], ' ') 
    1010__author__  = 'Patrick Hartling <patrick@infiscape.com>' 

  • PyJuggler/trunk/src/gadget/_Analog.cpp

    r19730 r20403  
    111111      return gadget::Analog::config(p0); 
    112112   } 
    113  
    114    std::string getInputTypeName() 
    115    { 
    116       try 
    117       { 
    118          if ( override getInputTypeName = 
    119                  this->get_override("getInputTypeName") ) 
    120          { 
    121             return getInputTypeName(); 
    122          } 
    123          return gadget::Analog::getInputTypeName(); 
    124       } 
    125       catch (error_already_set) 
    126       { 
    127          PyErr_Print(); 
    128       } 
    129  
    130       return std::string("UNKONWN"); 
    131    } 
    132  
    133    std::string default_getInputTypeName() 
    134    { 
    135       return gadget::Analog::getInputTypeName(); 
    136    } 
    137113}; 
    138114 
    …… 
    143119void _Export_Analog() 
    144120{ 
    145    class_<pyj::gadget_Analog_Wrapper, boost::noncopyable>("Analog", 
     121   class_<pyj::gadget_Analog_Wrapper, gadget::AnalogPtr, boost::noncopyable>( 
     122       "Analog", 
    146123       "gadget.Analog is the abstract base class from which devices\n" 
    147124       "returning analog data must derive.  This is in addition to\n" 
    …… 
    153130       "gadget.Position and gadget.Digital." 
    154131       , 
    155        init<>() 
    156       ) 
     132       no_init 
     133      ) 
     134      .def("create", &gadget::Analog::create) 
    157135      .def("writeObject", &gadget::Analog::writeObject, 
    158136           &pyj::gadget_Analog_Wrapper::default_writeObject, 
    …… 
    175153           "           'analog_device'." 
    176154      ) 
    177       .def("getInputTypeName", &gadget::Analog::getInputTypeName, 
    178            &pyj::gadget_Analog_Wrapper::default_getInputTypeName) 
     155      .def("getInputTypeName", &gadget::Analog::getInputTypeName) 
    179156      .def("getAnalogData", &gadget::Analog::getAnalogData, 
    180157           (args("devNum") = 0), 
    …… 
    213190           "Returns the current stable sample buffers for this device." 
    214191      ) 
     192      .staticmethod("create") 
     193      .staticmethod("getInputTypeName") 
    215194   ; 
    216195 

  • PyJuggler/trunk/src/gadget/_AnalogInterface.cpp

    r19730 r20403  
    4949      ) 
    5050      .def("getProxy", &gadgetWrapper::AnalogInterface::getProxy, 
    51            return_internal_reference<1>(), 
    5251           "getProxy() -> gadget.AnalogProxy object\n" 
    5352           "Returns the underlying proxy to which we are connected." 

  • PyJuggler/trunk/src/gadget/_AnalogProxy.cpp

    r19730 r20403  
    108108   } 
    109109 
    110    void set(const std::string& p0, gadget::Analog* p1) 
     110   void set(const std::string& p0, gadget::AnalogPtr p1) 
    111111   { 
    112112      try 
    …… 
    114114         if ( override set = this->get_override("set") ) 
    115115         { 
    116             set(boost::ref(p0), ptr(p1)); 
     116            set(boost::ref(p0), p1); 
    117117         } 
    118118         else 
    …… 
    127127   } 
    128128 
    129    void default_set(const std::string& p0, gadget::Analog* p1) 
     129   void default_set(const std::string& p0, gadget::AnalogPtr p1) 
    130130   { 
    131131      gadget::AnalogProxy::set(p0, p1); 
    …… 
    208208void _Export_AnalogProxy() 
    209209{ 
    210    class_<pyj::gadget_AnalogProxy_Wrapper>("AnalogProxy", 
     210   class_<pyj::gadget_AnalogProxy_Wrapper, gadget::AnalogProxyPtr>( 
     211       "AnalogProxy", 
    211212       "A proxy class to analog devices used by the Input Manager.\n\n" 
    212213       "An analog proxy always points to an analog device and a unit\n" 
    …… 
    215216       "only return a single sub-device's amount of data (one float)." 
    216217       , 
    217        init<>() 
    218       ) 
    219       .def(init<const gadget::AnalogProxy&>()) 
     218       no_init 
     219      ) 
     220      .def("create", &gadget::AnalogProxy::create) 
    220221      .def("updateData", &gadget::AnalogProxy::updateData, 
    221222           &pyj::gadget_AnalogProxy_Wrapper::default_updateData, 
    …… 
    279280      ) 
    280281      .def("getAnalogPtr", &gadget::AnalogProxy::getAnalogPtr, 
    281            return_internal_reference<1>(), 
    282282           "getAnalogPtr() -> gadget.Analog object\n" 
    283283      ) 
    …… 
    306306           "newState -- The new state of stupefication." 
    307307      ) 
     308      .staticmethod("create") 
    308309      .staticmethod("getElementType") 
    309310   ; 

  • PyJuggler/trunk/src/gadget/_Command.cpp

    r19730 r20403  
    5454   { 
    5555      return gadget::Command::config(p0); 
    56    } 
    57  
    58    std::string getInputTypeName() 
    59    { 
    60       try 
    61       { 
    62          if ( override getInputTypeName = 
    63                  this->get_override("getInputTypeName") ) 
    64          { 
    65              return getInputTypeName(); 
    66          } 
    67          return gadget::Command::getInputTypeName(); 
    68       } 
    69       catch (error_already_set) 
    70       { 
    71          PyErr_Print(); 
    72       } 
    73  
    74       return std::string("UNKONWN"); 
    75    } 
    76  
    77    std::string default_getInputTypeName() 
    78    { 
    79       return gadget::Command::getInputTypeName(); 
    8056   } 
    8157 
    …… 
    143119void _Export_Command() 
    144120{ 
    145    class_<pyj::gadget_Command_Wrapper, boost::noncopyable>("Command", 
     121   class_<pyj::gadget_Command_Wrapper, gadget::CommandPtr, boost::noncopyable>( 
     122       "Command", 
    146123       "gadget.Command is the abstract base class for devices that\n" 
    147124       "translate spoken commands into integer-identified commands.\n" 
    …… 
    154131       "gadget.Position and gadget.Analog." 
    155132       , 
    156        init<>() 
     133       no_init 
    157134      ) 
     135      .def("create", &gadget::Command::create) 
    158136      .def("config", &gadget::Command::config, 
    159137           &pyj::gadget_Command_Wrapper::default_config, 
    …… 
    165143           "           'command_device'." 
    166144      ) 
    167       .def("getInputTypeName", &gadget::Command::getInputTypeName, 
    168            &pyj::gadget_Command_Wrapper::default_getInputTypeName 
     145      .def("getInputTypeName", &gadget::Command::getInputTypeName 
    169146      ) 
    170147      .def("writeObject", &gadget::Command::writeObject, 
    …… 
    210187           "Returns the current stable sample buffers for this device." 
    211188      ) 
     189      .staticmethod("create") 
    212190   ; 
    213191} 

  • PyJuggler/trunk/src/gadget/_CommandInterface.cpp

    r19730 r20403  
    5353      ) 
    5454      .def("getProxy", &gadgetWrapper::CommandInterface::getProxy, 
    55            return_internal_reference<1>(), 
    5655           "getProxy() -> gadget.DigitalProxy object\n" 
    5756           "Returns the underlying proxy to which we are connected." 

  • PyJuggler/trunk/src/gadget/_CommandProxy.cpp

    r19730 r20403  
    108108   } 
    109109 
    110    void set(const std::string& p0, gadget::Command* p1) 
     110   void set(const std::string& p0, gadget::CommandPtr p1) 
    111111   { 
    112112      try 
    …… 
    114114         if ( override set = this->get_override("set") ) 
    115115         { 
    116             set(boost::ref(p0), ptr(p1)); 
     116            set(boost::ref(p0), p1); 
    117117         } 
    118118         else 
    …… 
    127127   } 
    128128 
    129    void default_set(const std::string& p0, gadget::Command* p1) 
     129   void default_set(const std::string& p0, gadget::CommandPtr p1) 
    130130   { 
    131131      gadget::CommandProxy::set(p0, p1); 
    …… 
    208208void _Export_CommandProxy() 
    209209{ 
    210    class_<pyj::gadget_CommandProxy_Wrapper>("CommandProxy", 
     210   class_<pyj::gadget_CommandProxy_Wrapper, gadget::CommandProxyPtr>( 
     211       "CommandProxy", 
    211212       "A proxy class to command-oriented devices used by the Input\n" 
    212213       "Manager.\n\n" 
    …… 
    217218       "int)." 
    218219       , 
    219        init<>() 
    220       ) 
    221       .def(init<const gadget::CommandProxy&>()) 
     220       no_init 
     221      ) 
     222      .def("create", &gadget::CommandProxy::create) 
    222223      .def("updateData", &gadget::CommandProxy::updateData, 
    223224           &pyj::gadget_CommandProxy_Wrapper::default_updateData, 
    …… 
    284285      ) 
    285286      .def("getCommandPtr", &gadget::CommandProxy::getCommandPtr, 
    286            return_internal_reference<1>(), 
    287287           "getCommandPtr() -> gadget.Command object\n" 
    288288      ) 
    …… 
    311311           "newState -- The new state of stupefication." 
    312312      ) 
     313      .staticmethod("create") 
    313314      .staticmethod("getElementType") 
    314315   ; 

  • PyJuggler/trunk/src/gadget/_Digital.cpp

    r19730 r20403  
    5454   { 
    5555      return gadget::Digital::config(p0); 
    56    } 
    57  
    58    std::string getInputTypeName() 
    59    { 
    60       try 
    61       { 
    62          if ( override getInputTypeName = 
    63                  this->get_override("getInputTypeName") ) 
    64          { 
    65             return getInputTypeName(); 
    66          } 
    67          return gadget::Digital::getInputTypeName(); 
    68       } 
    69       catch (error_already_set) 
    70       { 
    71          PyErr_Print(); 
    72       } 
    73  
    74       return std::string("UNKONWN"); 
    75    } 
    76  
    77    std::string default_getInputTypeName() 
    78    { 
    79       return gadget::Digital::getInputTypeName(); 
    8056   } 
    8157 
    …… 
    144120{ 
    145121   scope* gadget_Digital_scope = new scope( 
    146    class_<pyj::gadget_Digital_Wrapper, boost::noncopyable>("Digital", 
     122   class_<pyj::gadget_Digital_Wrapper, gadget::DigitalPtr, boost::noncopyable>( 
     123       "Digital", 
    147124       "gadget.Digital is the abstract base class from which devices\n" 
    148125       "returning digital data must derive.  This is in addition to\n" 
    …… 
    154131       "by gadget.Position and gadget.Analog." 
    155132       , 
    156        init<>() 
    157       ) 
     133       no_init 
     134      ) 
     135      .def("create", &gadget::Digital::create) 
    158136      .def("config", &gadget::Digital::config, 
    159137           &pyj::gadget_Digital_Wrapper::default_config, 
    …… 
    165143           "           'digital_device'." 
    166144      ) 
    167       .def("getInputTypeName", &gadget::Digital::getInputTypeName, 
    168            &pyj::gadget_Digital_Wrapper::default_getInputTypeName 
     145      .def("getInputTypeName", &gadget::Digital::getInputTypeName 
    169146      ) 
    170147      .def("writeObject", &gadget::Digital::writeObject, 
    …… 
    210187           "Returns the current stable sample buffers for this device." 
    211188      ) 
     189      .staticmethod("create") 
     190      .staticmethod("getInputTypeName") 
    212191   ); 
    213192 

  • PyJuggler/trunk/src/gadget/_DigitalInterface.cpp

    r19730 r20403  
    4949      ) 
    5050      .def("getProxy", &gadgetWrapper::DigitalInterface::getProxy, 
    51            return_internal_reference<1>(), 
    5251           "getProxy() -> gadget.DigitalProxy object\n" 
    5352           "Returns the underlying proxy to which we are connected." 

  • PyJuggler/trunk/src/gadget/_DigitalProxy.cpp

    r19730 r20403  
    114114   } 
    115115 
    116    void set(const std::string& p0, gadget::Digital* p1) 
     116   void set(const std::string& p0, gadget::DigitalPtr p1) 
    117117   { 
    118118      try 
    …… 
    120120         if ( override set = this->get_override("set") ) 
    121121         { 
    122             set(boost::ref(p0), ptr(p1)); 
     122            set(boost::ref(p0), p1); 
    123123         } 
    124124         else 
    …… 
    133133   } 
    134134 
    135    void default_set(const std::string& p0, gadget::Digital* p1) 
     135   void default_set(const std::string& p0, gadget::DigitalPtr p1) 
    136136   { 
    137137      gadget::DigitalProxy::set(p0, p1); 
    …… 
    220220void _Export_DigitalProxy() 
    221221{ 
    222    class_<pyj::gadget_DigitalProxy_Wrapper>("DigitalProxy", 
     222   class_<pyj::gadget_DigitalProxy_Wrapper, gadget::DigitalProxyPtr>( 
     223       "DigitalProxy", 
    223224       "A proxy class to digital devices used by the Input Manager.\n\n" 
    224225       "A digital proxy always points to a digital device and a unit\n" 
    …… 
    227228       "only return a single sub-device's amount of data (one int)." 
    228229       , 
    229        init<>() 
    230       ) 
    231       .def(init<const gadget::DigitalProxy&>()) 
     230       no_init 
     231      ) 
     232      .def("create", &gadget::DigitalProxy::create) 
    232233      .def("updateData", &gadget::DigitalProxy::updateData, 
    233234           &pyj::gadget_DigitalProxy_Wrapper::default_updateData, 
    …… 
    294295      ) 
    295296      .def("getDigitalPtr", &gadget::DigitalProxy::getDigitalPtr, 
    296            return_internal_reference<1>(), 
    297297           "getDigitalPtr() -> gadget.Digital object\n" 
    298298      ) 
    …… 
    321321           "newState -- The new state of stupefication." 
    322322      ) 
     323      .staticmethod("create") 
    323324      .staticmethod("getElementType") 
    324325   ; 

  • PyJuggler/trunk/src/gadget/_InputManager.cpp

    r19730 r20403  
    218218      ) 
    219219      .def("getDevice", &gadget::InputManager::getDevice, 
    220            return_internal_reference<1>(), 
    221220           "getDevice(deviceName) -> gadget.Input object\n" 
    222221           "Returns a gadget.Input object to the named device.\n" 
    …… 
    262261      ) 
    263262      .def("removeDevice", 
    264            (bool (gadget::InputManager::*)(const gadget::Input*)) &gadget::InputManager::removeDevice) 
     263           (bool (gadget::InputManager::*)(const gadget::InputPtr)) &gadget::InputManager::removeDevice) 
    265264      .def("addProxy", &gadget::InputManager::addProxy, 
    266265           "addProxy(proxy) -> Boolean\n" 
    …… 
    273272      ) 
    274273      .def("getProxy", &gadget::InputManager::getProxy, 
    275            return_internal_reference<1>(), 
    276274           "getProxy(proxyName) -> gadget.Proxy object\n" 
    277275           "Gets a proxy having the given name (or alias).\n" 

  • PyJuggler/trunk/src/gadget/_KeyboardMouse.cpp

    r19730 r20403  
    2424   , wrapper<gadget::KeyboardMouse> 
    2525{ 
    26    gadget_KeyboardMouse_Wrapper(const gadget::KeyboardMouse& p0) 
    27       : gadget::KeyboardMouse(p0) 
    28    { 
    29       /* Do nothing. */ ; 
    30    } 
    31  
    3226   gadget_KeyboardMouse_Wrapper() 
    3327      : gadget::KeyboardMouse() 
    …… 
    3933   { 
    4034      /* Do nothing. */ ; 
    41    } 
    42  
    43    std::string getInputTypeName() 
    44    { 
    45       try 
    46       { 
    47          if ( override getInputTypeName = 
    48                  this->get_override("getInputTypeName") ) 
    49          { 
    50             return getInputTypeName(); 
    51          } 
    52          return gadget::KeyboardMouse::getInputTypeName(); 
    53       } 
    54       catch (error_already_set) 
    55       { 
    56          PyErr_Print(); 
    57       } 
    58  
    59       return std::string("UNKNOWN"); 
    60    } 
    61  
    62    std::string default_getInputTypeName() 
    63    { 
    64       return gadget::KeyboardMouse::getInputTypeName(); 
    6535   } 
    6636 
    …… 
    152122void _Export_KeyboardMouse() 
    153123{ 
    154    class_<pyj::gadget_KeyboardMouse_Wrapper, boost::noncopyable> 
     124   class_<pyj::gadget_KeyboardMouse_Wrapper, gadget::KeyboardMousePtr, boost::noncopyable> 
    155125      ("KeyboardMouse", 
    156126       "gadget.KeyboardMouse is an abstract class for interfacing with\n" 
    …… 
    163133       "frame." 
    164134       , 
    165        init<>() 
    166       ) 
    167       .def(init<const gadget::KeyboardMouse&>()) 
    168       .def("getInputTypeName", &gadget::KeyboardMouse::getInputTypeName, 
    169            &pyj::gadget_KeyboardMouse_Wrapper::default_getInputTypeName) 
     135       no_init 
     136      ) 
     137      .def("create", &gadget::KeyboardMouse::create) 
     138      .def("getInputTypeName", &gadget::KeyboardMouse::getInputTypeName 
     139      ) 
    170140      .def("writeObject", &gadget::KeyboardMouse::writeObject, 
    171141           &pyj::gadget_KeyboardMouse_Wrapper::default_writeObject, 
    …… 
    241211           "event -- The gadget.Event object that is the new event." 
    242212      ) 
     213      .staticmethod("create") 
     214      .staticmethod("getInputTypeName") 
    243215   ; 
    244216 

  • PyJuggler/trunk/src/gadget/_KeyboardMouseInterface.cpp

    r19730 r20403  
    5151      ) 
    5252      .def("getProxy", &gadgetWrapper::KeyboardMouseInterface::getProxy, 
    53            return_internal_reference<1>(), 
    5453           "getProxy() -> gadget.KeyboardMouseProxy object\n" 
    5554           "Returns the underlying proxy to which we are connected." 

  • PyJuggler/trunk/src/gadget/_KeyboardMouseProxy.cpp

    r19730 r20403  
    8484   } 
    8585 
    86    void set(const std::string& p0, gadget::KeyboardMouse* p1) 
     86   void set(const std::string& p0, gadget::KeyboardMousePtr p1) 
    8787   { 
    8888      try 
    …… 
    9090         if ( override set = this->get_override("set") ) 
    9191         { 
    92             set(boost::ref(p0), ptr(p1)); 
     92            set(boost::ref(p0), p1); 
    9393         } 
    9494         else 
    …… 
    103103   } 
    104104 
    105    void default_set(const std::string& p0, gadget::KeyboardMouse* p1) 
     105   void default_set(const std::string& p0, gadget::KeyboardMousePtr p1) 
    106106   { 
    107107      gadget::TypedProxy<gadget::KeyboardMouse>::set(p0, p1); 
    …… 
    208208void _Export_KeyboardMouseProxy() 
    209209{ 
    210    class_<pyj::gadget_KeyboardMouseProxy_Wrapper>("KeyboardMouseProxy", 
     210   class_<pyj::gadget_KeyboardMouseProxy_Wrapper, gadget::KeyboardMouseProxyPtr>( 
     211       "KeyboardMouseProxy", 
    211212       "A proxy class to keyboard/mouse devices used by the Input Manager.\n\n" 
    212213       "A keyboard/mouse proxy always points to a keyboard/mouse device\n" 
    …… 
    216217       "amount of data (an event queue and individual keys)." 
    217218       , 
    218        init<>() 
    219       ) 
    220       .def(init<const gadget::KeyboardMouseProxy&>()) 
     219       no_init 
     220      ) 
     221      .def("create", &gadget::KeyboardMouseProxy::create) 
    221222      .def("getTimeStamp", &gadget::KeyboardMouseProxy::getTimeStamp, 
    222223           &pyj::gadget_KeyboardMouseProxy_Wrapper::default_getTimeStamp, 
    …… 
    278279      .def("getKeyboardMousePtr", 
    279280           &gadget::KeyboardMouseProxy::getKeyboardMousePtr, 
    280            return_internal_reference<1>(), 
    281281           "getKeyboardMousePtr() -> gadget.KeyboardMouse object\n" 
    282282           "Returns the gadget.KeyboardMouse object held by this proxy." 
    …… 
    332332           "newState -- The new state of stupefication." 
    333333      ) 
     334      .staticmethod("create") 
    334335      .staticmethod("getElementType") 
    335336   ; 

  • PyJuggler/trunk/src/gadget/_Position.cpp

    r19730 r20403  
    5454   { 
    5555      return gadget::Position::config(p0); 
    56    } 
    57  
    58    std::string getInputTypeName() 
    59    { 
    60       try 
    61       { 
    62          if ( override getInputTypeName = this->get_override("getInputTypeName") ) 
    63          { 
    64             return getInputTypeName(); 
    65          } 
    66          return gadget::Position::getInputTypeName(); 
    67       } 
    68       catch (error_already_set) 
    69       { 
    70          PyErr_Print(); 
    71       } 
    72  
    73       return std::string("UNKNOWN"); 
    74    } 
    75  
    76    std::string default_getInputTypeName() 
    77    { 
    78       return gadget::Position::getInputTypeName(); 
    7956   } 
    8057 
    …… 
    142119void _Export_Position() 
    143120{ 
    144    class_<pyj::gadget_Position_Wrapper, boost::noncopyable>("Position", 
     121   class_<pyj::gadget_Position_Wrapper, gadget::PositionPtr, boost::noncopyable>( 
     122       "Position", 
    145123       "gadget.Position is the abstract base class from which devices\n" 
    146124       "returning positional (translation and/or rotation) data must\n" 
    …… 
    153131       "made by gadget.Analog and gadget.Digital." 
    154132       , 
    155        init<>() 
    156       ) 
     133       no_init 
     134      ) 
     135      .def("create", &gadget::Position::create) 
    157136      .def("config", &gadget::Position::config, 
    158137           &pyj::gadget_Position_Wrapper::default_config, 
    …… 
    164143           "           'positional_device'." 
    165144      ) 
    166       .def("getInputTypeName", &gadget::Position::getInputTypeName, 
    167            &pyj::gadget_Position_Wrapper::default_getInputTypeName 
     145      .def("getInputTypeName", &gadget::Position::getInputTypeName 
    168146      ) 
    169147      .def("writeObject", &gadget::Position::writeObject, 
    …… 
    212190           "Returns the current stable sample buffers for this device." 
    213191      ) 
     192      .staticmethod("create") 
     193      .staticmethod("getInputTypeName") 
    214194   ; 
    215195 

  • PyJuggler/trunk/src/gadget/_PositionInterface.cpp

    r19730 r20403  
    4949      ) 
    5050      .def("getProxy", &gadgetWrapper::PositionInterface::getProxy, 
    51            return_internal_reference<1>(), 
    5251           "getProxy() -> gadget.PositionProxy object\n" 
    5352           "Returns the underlying proxy to which we are connected." 

  • PyJuggler/trunk/src/gadget/_PositionProxy.cpp

    r19730 r20403  
    108108   } 
    109109 
    110    void set(const std::string& p0, gadget::Position* p1) 
     110   void set(const std::string& p0, gadget::PositionPtr p1) 
    111111   { 
    112112      try 
    …… 
    114114         if ( override set = this->get_override("set") ) 
    115115         { 
    116             set(boost::ref(p0), ptr(p1)); 
     116            set(boost::ref(p0), p1); 
    117117         } 
    118118         else 
    …… 
    127127   } 
    128128 
    129    void default_set(const std::string& p0, gadget::Position* p1) 
     129   void default_set(const std::string& p0, gadget::PositionPtr p1) 
    130130   { 
    131131      gadget::PositionProxy::set(p0, p1); 
    …… 
    208208void _Export_PositionProxy() 
    209209{ 
    210    class_<pyj::gadget_PositionProxy_Wrapper>("PositionProxy", 
     210   class_<pyj::gadget_PositionProxy_Wrapper, gadget::PositionProxyPtr>( 
     211       "PositionProxy", 
    211212       "A proxy class to positional devices used by the Input Manager.\n\n" 
    212213       "A position proxy always points to a positional device and a unit\n" 
    …… 
    215216       "only return a single sub-device's amount of data (one int)." 
    216217       , 
    217        init<>() 
    218       ) 
    219       .def(init<const gadget::PositionProxy&>()) 
     218       no_init 
     219      ) 
     220      .def("create", &gadget::PositionProxy::create) 
    220221      .def("updateData", &gadget::PositionProxy::updateData, 
    221222           &pyj::gadget_PositionProxy_Wrapper::default_updateData, 
    …… 
    298299      ) 
    299300      .def("getPositionPtr", &gadget::PositionProxy::getPositionPtr, 
    300            return_internal_reference<1>(), 
    301301           "getPositionPtr() -> gadget.Position object\n" 
    302302           "Returns the gadget.Position object held by this proxy." 
    …… 
    321321           "newState -- The new state of stupefication." 
    322322      ) 
     323      .staticmethod("create") 
    323324      .staticmethod("getElementType") 
    324325   ; 

  • PyJuggler/trunk/src/gadget/_String.cpp

    r19730 r20403  
    5454   { 
    5555      return gadget::String::config(p0); 
    56    } 
    57  
    58    std::string getInputTypeName() 
    59    { 
    60       try 
    61       { 
    62          if ( override getInputTypeName = 
    63                  this->get_override("getInputTypeName") ) 
    64          { 
    65             return getInputTypeName(); 
    66          } 
    67          return gadget::String::getInputTypeName(); 
    68       } 
    69       catch (error_already_set) 
    70       { 
    71          PyErr_Print(); 
    72       } 
    73  
    74       return std::string("UNKONWN"); 
    75    } 
    76  
    77    std::string default_getInputTypeName() 
    78    { 
    79       return gadget::String::getInputTypeName(); 
    8056   } 
    8157 
    …… 
    143119void _Export_String() 
    144120{ 
    145    class_<pyj::gadget_String_Wrapper, boost::noncopyable>("String", 
     121   class_<pyj::gadget_String_Wrapper, gadget::StringPtr, boost::noncopyable>( 
     122       "String", 
    146123       "gadget.String is the abstract base class for devices that return\n" 
    147124       "strinsg.  Drivers for all such devices must derive from this class.\n" 
    …… 
    153130       "additions made by gadget.Position and gadget.Analog." 
    154131       , 
    155        init<>() 
     132       no_init 
    156133      ) 
     134      .def("create", &gadget::String::create) 
    157135      .def("config", &gadget::String::config, 
    158136           &pyj::gadget_String_Wrapper::default_config, 
    …… 
    164142           "           'string_device'." 
    165143      ) 
    166       .def("getInputTypeName", &gadget::String::getInputTypeName, 
    167            &pyj::gadget_String_Wrapper::default_getInputTypeName 
     144      .def("getInputTypeName", &gadget::String::getInputTypeName 
    168145      ) 
    169146      .def("writeObject", &gadget::String::writeObject, 
    …… 
    209186           "Returns the current stable sample buffers for this device." 
    210187      ) 
     188      .staticmethod("create") 
     189      .staticmethod("getInputTypeName") 
    211190   ; 
    212191 

  • PyJuggler/trunk/src/gadget/_StringInterface.cpp

    r19730 r20403  
    4949      ) 
    5050      .def("getProxy", &gadgetWrapper::StringInterface::getProxy, 
    51            return_internal_reference<1>(), 
    5251           "getProxy() -> gadget.StringProxy object\n" 
    5352           "Returns the underlying proxy to which we are connected." 

  • PyJuggler/trunk/src/gadget/_StringProxy.cpp

    r19730 r20403  
    108108   } 
    109109 
    110    void set(const std::string& p0, gadget::String* p1) 
     110   void set(const std::string& p0, gadget::StringPtr p1) 
    111111   { 
    112112      try 
    …… 
    114114         if ( override set = this->get_override("set") ) 
    115115         { 
    116             set(boost::ref(p0), ptr(p1)); 
     116            set(boost::ref(p0), p1); 
    117117         } 
    118118         else 
    …… 
    127127   } 
    128128 
    129    void default_set(const std::string& p0, gadget::String* p1) 
     129   void default_set(const std::string& p0, gadget::StringPtr p1) 
    130130   { 
    131131      gadget::StringProxy::set(p0, p1); 
    …… 
    208208void _Export_StringProxy() 
    209209{ 
    210    class_<pyj::gadget_StringProxy_Wrapper>("StringProxy", 
     210   class_<pyj::gadget_StringProxy_Wrapper, gadget::StringProxyPtr>( 
     211       "StringProxy", 
    211212       "A proxy class to string devices used by the Input Manager.\n\n" 
    212213       "A string proxy always points to a string device and a unit number\n" 
    …… 
    215216       "single sub-device's amount of data (one string)." 
    216217       , 
    217        init<>() 
    218       ) 
    219       .def(init<const gadget::StringProxy&>()) 
     218       no_init 
     219      ) 
     220      .def("create", &gadget::Stri