home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / lib / site-packages / cgkit / slots.py < prev    next >
Encoding:
Python Source  |  2007-01-11  |  8.3 KB  |  266 lines
  1. # ***** BEGIN LICENSE BLOCK *****
  2. # Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3. #
  4. # The contents of this file are subject to the Mozilla Public License Version
  5. # 1.1 (the "License"); you may not use this file except in compliance with
  6. # the License. You may obtain a copy of the License at
  7. # http://www.mozilla.org/MPL/
  8. #
  9. # Software distributed under the License is distributed on an "AS IS" basis,
  10. # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11. # for the specific language governing rights and limitations under the
  12. # License.
  13. #
  14. # The Original Code is the Python Computer Graphics Kit.
  15. #
  16. # The Initial Developer of the Original Code is Matthias Baas.
  17. # Portions created by the Initial Developer are Copyright (C) 2004
  18. # the Initial Developer. All Rights Reserved.
  19. #
  20. # Contributor(s):
  21. #
  22. # Alternatively, the contents of this file may be used under the terms of
  23. # either the GNU General Public License Version 2 or later (the "GPL"), or
  24. # the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  25. # in which case the provisions of the GPL or the LGPL are applicable instead
  26. # of those above. If you wish to allow use of your version of this file only
  27. # under the terms of either the GPL or the LGPL, and not to allow others to
  28. # use your version of this file under the terms of the MPL, indicate your
  29. # decision by deleting the provisions above and replace them with the notice
  30. # and other provisions required by the GPL or the LGPL. If you do not delete
  31. # the provisions above, a recipient may use your version of this file under
  32. # the terms of any one of the MPL, the GPL or the LGPL.
  33. #
  34. # ***** END LICENSE BLOCK *****
  35. # $Id: slots.py,v 1.7 2005/08/28 19:55:40 mbaas Exp $
  36.  
  37. ## \file slots.py
  38. ## Contains the standard slot classes.
  39.  
  40. #from _core import ISlot, DoubleSlot, IntSlot, BoolSlot, PySlot
  41. #from _core import Vec3Slot, Vec4Slot, Mat3Slot, Mat4Slot
  42. from cgtypes import vec3, vec4, mat3, mat4, quat
  43. import _core
  44. from _core import Dependent, UserSizeConstraint, LinearSizeConstraint
  45. from _core import ISlot, IArraySlot
  46.  
  47. # Factory functions for the individual slots:
  48.  
  49. def DoubleSlot(value=0.0, flags=0):
  50.     return _core.DoubleSlot(value, flags)
  51.  
  52. def IntSlot(value=0, flags=0):
  53.     return _core.IntSlot(value, flags)
  54.  
  55. def BoolSlot(value=False, flags=0):
  56.     return _core.BoolSlot(value, flags)
  57.  
  58. def StrSlot(value="", flags=0):
  59.     return _core.StrSlot(value, flags)
  60.  
  61. def PySlot(value=None, flags=0):
  62.     return _core.PySlot(value, flags)
  63.  
  64. def Vec3Slot(value=vec3(), flags=0):
  65.     return _core.Vec3Slot(value, flags)
  66.  
  67. def Vec4Slot(value=vec4(), flags=0):
  68.     return _core.Vec4Slot(value, flags)
  69.  
  70. def Mat3Slot(value=mat3(), flags=0):
  71.     return _core.Mat3Slot(value, flags)
  72.  
  73. def Mat4Slot(value=mat4(), flags=0):
  74.     return _core.Mat4Slot(value, flags)
  75.  
  76. def QuatSlot(value=quat(), flags=0):
  77.     return _core.QuatSlot(value, flags)
  78.  
  79.  
  80.  
  81. def DoubleArraySlot(multiplicity=1, constraint=None):
  82.     return _core.DoubleArraySlot(multiplicity, constraint)
  83.  
  84. def IntArraySlot(multiplicity=1, constraint=None):
  85.     return _core.IntArraySlot(multiplicity, constraint)
  86.  
  87. def BoolArraySlot(multiplicity=1, constraint=None):
  88.     return _core.BoolArraySlot(multiplicity, constraint)
  89.  
  90. def StrArraySlot(multiplicity=1, constraint=None):
  91.     return _core.StrArraySlot(multiplicity, constraint)
  92.  
  93. def Vec3ArraySlot(multiplicity=1, constraint=None):
  94.     return _core.Vec3ArraySlot(multiplicity, constraint)
  95.  
  96. def Vec4ArraySlot(multiplicity=1, constraint=None):
  97.     return _core.Vec4ArraySlot(multiplicity, constraint)
  98.  
  99. #def Mat3ArraySlot(multiplicity=1, constraint=None):
  100. #    return _core.Mat3ArraySlot(multiplicity, constraint)
  101.  
  102. def Mat4ArraySlot(multiplicity=1, constraint=None):
  103.     return _core.Mat4ArraySlot(multiplicity, constraint)
  104.  
  105. #def QuatArraySlot(multiplicity=1, constraint=None):
  106. #    return _core.QuatArraySlot(multiplicity, constraint)
  107.  
  108.  
  109. # Test
  110.  
  111. class ProceduralDoubleSlot(_core.DoubleSlot):
  112.     def __init__(self, proc):
  113.         _core.DoubleSlot.__init__(self, 0.0, 2) # 2 = NO_INPUT_CONNECTIONS
  114.         self._proc = proc
  115.  
  116.     def computeValue(self):
  117.         self._value = self._proc()
  118.  
  119. class ProceduralIntSlot(_core.IntSlot):
  120.     def __init__(self, proc):
  121.         _core.IntSlot.__init__(self, 0, 2) # 2 = NO_INPUT_CONNECTIONS
  122.         self._proc = proc
  123.  
  124.     def computeValue(self):
  125.         self._value = self._proc()
  126.  
  127. class ProceduralVec3Slot(_core.Vec3Slot):
  128.     def __init__(self, proc):
  129.         _core.Vec3Slot.__init__(self, vec3(), 2) # 2 = NO_INPUT_CONNECTIONS
  130.         self._proc = proc
  131.  
  132.     def computeValue(self):
  133.         self._value = self._proc()
  134.  
  135. class ProceduralVec4Slot(_core.Vec4Slot):
  136.     def __init__(self, proc):
  137.         _core.Vec4Slot.__init__(self, vec4(), 2) # 2 = NO_INPUT_CONNECTIONS
  138.         self._proc = proc
  139.  
  140.     def computeValue(self):
  141.         self._value = self._proc()
  142.  
  143. class ProceduralMat3Slot(_core.Mat3Slot):
  144.     def __init__(self, proc):
  145.         _core.Mat3Slot.__init__(self, mat3(1), 2) # 2 = NO_INPUT_CONNECTIONS
  146.         self._proc = proc
  147.  
  148.     def computeValue(self):
  149.         self._value = self._proc()
  150.  
  151. class ProceduralMat4Slot(_core.Mat4Slot):
  152.     def __init__(self, proc):
  153.         _core.Mat4Slot.__init__(self, mat4(1), 2) # 2 = NO_INPUT_CONNECTIONS
  154.         self._proc = proc
  155.  
  156.     def computeValue(self):
  157.         self._value = self._proc()
  158.  
  159. class ProceduralQuatSlot(_core.QuatSlot):
  160.     def __init__(self, proc):
  161.         _core.QuatSlot.__init__(self, quat(), 2) # 2 = NO_INPUT_CONNECTIONS
  162.         self._proc = proc
  163.  
  164.     def computeValue(self):
  165.         self._value = self._proc()
  166.  
  167.  
  168. # NotificationForwarder
  169. class NotificationForwarder(_core.Dependent):
  170.     """Forwards slot notifications.
  171.  
  172.     This class has the same functionality than the C++ class with the
  173.     same name. However, it's not wrapping the C++ class but is pure
  174.     Python.
  175.     """
  176.     def __init__(self, onvalchanged, onresize=None):
  177.         """Constructor.
  178.  
  179.         If the forwarder is used with an array slot, the onvalchanged
  180.         callback must take two arguments start and end. If it's used with
  181.         a normal slot, then it does not take any arguments.
  182.  
  183.         \param onvalchanged A callable object that gets called whenever the value changes
  184.         \param onresize A callable object that gets called whenever the size of an array slot changes
  185.         """
  186.         _core.Dependent.__init__(self)
  187. #        self.callable = callable
  188.         self.onvalchanged = onvalchanged
  189.         self.onresize = onresize
  190.         
  191.     def onValueChanged(self, start=None, end=None):
  192.         # Does the call come from a normal slot?
  193.         if start==None:
  194.             self.onvalchanged()
  195.         # or an array slot?
  196.         else:
  197.             self.onvalchanged(start, end)
  198.  
  199.     def onResize(self, size):
  200.         if self.onresize!=None:
  201.             self.onresize(size)
  202.  
  203.  
  204. # slotPropertyCode
  205. def slotPropertyCode(name, slotname=None):
  206.     """Create the code to add a slot property to a class.
  207.  
  208.     This is a helper function that creates the code string which
  209.     adds a get() method, a set() method and a property to access
  210.     the value of a slot. The resulting string can then be executed
  211.     inside a class definition via an exec statement. The slot itself
  212.     must be present as a variable in the class.
  213.  
  214.     The returned string looks like this:
  215.     
  216.     \code
  217.     # Property: <name>
  218.     def _get<Name>(self):
  219.         return self.<slotname>.getValue()
  220.  
  221.     def _set<Name>(self, val):
  222.         self.<slotname>.setValue(val)
  223.  
  224.     <name> = property(_get<Name>, _set<Name>, None, "<name>")
  225.     \endcode
  226.  
  227.     In a %component class (or whatever class) the property is created
  228.     as shown in the following example:
  229.  
  230.     \code
  231.     class Sphere:
  232.         
  233.         exec slotPropertyCode("radius")
  234.  
  235.         def __init__(self, ...):
  236.             self.radius_slot = ...
  237.     \endcode
  238.  
  239.     If no slot name is given then the name is assumed to be '<name>_slot'.
  240.     
  241.     \param name (\c str) Name of the new attribute (property)
  242.     \param slotname (\c str) Name of the corresponding slot
  243.     """
  244.     capname = name.capitalize()
  245.     getmethname = "_get%s"%(capname)
  246.     setmethname = "_set%s"%(capname)
  247.     if slotname==None:
  248.         slotname = "%s_slot"%name
  249.  
  250.     s="""# Property: %s
  251. def %s(self):
  252.     return self.%s.getValue()
  253.  
  254. def %s(self, val):
  255.     if isinstance(val, _core.Component):
  256.         val.output_slot.connect(self.%s)
  257.     else:
  258.         self.%s.setValue(val)
  259.  
  260. %s = property(%s, %s, None, "%s")
  261. """%(name,
  262.      getmethname,slotname,
  263.      setmethname,slotname,slotname,
  264.      name,getmethname,setmethname,capname)
  265.     return s
  266.