added id_attributes.py, this containes ID doc strings, all datablocks that have use...
authorCampbell Barton <ideasman42@gmail.com>
Tue, 27 Feb 2007 10:23:24 +0000 (10:23 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 27 Feb 2007 10:23:24 +0000 (10:23 +0000)
24 files changed:
source/blender/python/api2_2x/doc/API_intro.py
source/blender/python/api2_2x/doc/Armature.py
source/blender/python/api2_2x/doc/Camera.py
source/blender/python/api2_2x/doc/Constraint.py
source/blender/python/api2_2x/doc/Curve.py
source/blender/python/api2_2x/doc/Font.py
source/blender/python/api2_2x/doc/Group.py
source/blender/python/api2_2x/doc/Image.py
source/blender/python/api2_2x/doc/Ipo.py
source/blender/python/api2_2x/doc/Key.py
source/blender/python/api2_2x/doc/Lamp.py
source/blender/python/api2_2x/doc/Lattice.py
source/blender/python/api2_2x/doc/Material.py
source/blender/python/api2_2x/doc/Mesh.py
source/blender/python/api2_2x/doc/Metaball.py
source/blender/python/api2_2x/doc/NLA.py
source/blender/python/api2_2x/doc/Object.py
source/blender/python/api2_2x/doc/Scene.py
source/blender/python/api2_2x/doc/Sound.py
source/blender/python/api2_2x/doc/Text.py
source/blender/python/api2_2x/doc/Text3d.py
source/blender/python/api2_2x/doc/Texture.py
source/blender/python/api2_2x/doc/World.py
source/blender/python/api2_2x/id_attributes.py [new file with mode: 0644]

index 8290173a11f08f7c0685959491b6b808ccf0c95c..ccdc36d41c020e7a2ff11ed541b7e0d58b9e041d 100644 (file)
 The Blender Python API Reference
 ================================
 
- An asterisk (*) means the module has been updated.
-
- for a full list of changes since 2.42 see U{http://mediawiki.blender.org/index.php/Release_Notes/Notes243/Python_API}
-
- Top Module:
- -----------
-
-  - L{Blender}
-
- Submodules:
- -----------
-  - L{Armature} (*)
-     - L{NLA}
-     - L{Action<NLA.Action>}
-  - L{BezTriple} (*)
-  - L{BGL}
-  - L{Camera} (*)
-  - L{Curve} (*)
-  - L{Draw} (*)
-  - L{Effect}
-  - L{Geometry} (*)
-  - L{Group} (*)
-  - L{Image} (*)
-  - L{Ipo} (*)
-    - L{IpoCurve} (*)
-  - L{Key} (*)
-  - L{Lamp}
-  - L{Lattice} (*)
-  - L{Library} (*)
-  - L{Material} (*)
-  - L{Mathutils} (*)
-  - L{Mesh} (*)
-    - L{MeshPrimitives} (*)
-  - L{Metaball} (*)
-  - L{NMesh} (*)
-  - L{Noise}
-  - L{Object} (*)
-     - L{Modifier} (*)
-     - L{Pose} (*)
-     - L{Constraint} (*)
-     - L{ActionStrips<NLA>} (*)
-  - L{Registry}
-  - L{Scene} (*)
-     - L{Radio}
-     - L{Render} (*)
-  - L{Sound} (*)
-  - L{Text}
-  - L{Text3d}
-     - L{Font}
-  - L{Texture} (*)
-  - L{TimeLine}
-  - L{Types}
-  - L{Window}
-     - L{Theme} (*)
-  - L{World}
-  - L{sys<Sys>}
-
- Additional information:
- -----------------------
-
-  - L{Special features<API_related>}:
-    - scripts: registering in menus, documenting, configuring (new);
-    - command line examples (new);
-    - script links (*), space handler script links, Group module (new).
      An asterisk (*) means the module has been updated.
+
      for a full list of changes since 2.42 see U{http://mediawiki.blender.org/index.php/Release_Notes/Notes243/Python_API}
+
      Top Module:
      -----------
+
+               - L{Blender}
+
      Submodules:
      -----------
+               - L{Armature} (*)
+                       - L{NLA}
+                       - L{Action<NLA.Action>}
+               - L{BezTriple} (*)
+               - L{BGL}
+               - L{Camera} (*)
+               - L{Curve} (*)
+               - L{Draw} (*)
+               - L{Effect}
+               - L{Geometry} (*)
+               - L{Group} (*)
+               - L{Image} (*)
+               - L{Ipo} (*)
+                 - L{IpoCurve} (*)
+               - L{Key} (*)
+               - L{Lamp}
+               - L{Lattice} (*)
+               - L{Library} (*)
+               - L{Material} (*)
+               - L{Mathutils} (*)
+               - L{Mesh} (*)
+                 - L{MeshPrimitives} (*)
+               - L{Metaball} (*)
+               - L{NMesh} (*)
+               - L{Noise}
+               - L{Object} (*)
+                       - L{Modifier} (*)
+                       - L{Pose} (*)
+                       - L{Constraint} (*)
+                       - L{ActionStrips<NLA>} (*)
+               - L{Registry}
+               - L{Scene} (*)
+                       - L{Radio}
+                       - L{Render} (*)
+               - L{Sound} (*)
+               - L{Text}
+               - L{Text3d}
+                       - L{Font}
+               - L{Texture} (*)
+               - L{TimeLine}
+               - L{Types}
+               - L{Window}
+                       - L{Theme} (*)
+               - L{World}
+               - L{sys<Sys>}
+
      Additional information:
      -----------------------
+
+               - L{Special features<API_related>}:
+               - scripts: registering in menus, documenting, configuring (new);
+               - command line examples (new);
+               - script links (*), space handler script links, Group module (new).
 
 Introduction:
 =============
 
- This reference documents the Blender Python API, a growing collection of
- Python modules (libraries) that give access to part of the program's internal
- data and functions.
- Through scripting Blender can be extended in real-time via
- U{Python <www.python.org>}, an impressive high level, multi-paradigm, open
- source language.  Newcomers are recommended to start with the tutorial that
- comes with it.
-
- This opens many interesting possibilities, ranging from automating repetitive
- tasks to adding new functionality to the program: procedural models,
- importers and exporters, even complex applications and so on.  Blender itself
- comes with some scripts, but many others can be found in the Scripts & Plugins
- sections and forum posts at the Blender-related sites listed below.
      This reference documents the Blender Python API, a growing collection of
      Python modules (libraries) that give access to part of the program's internal
      data and functions.
+       
      Through scripting Blender can be extended in real-time via
      U{Python <www.python.org>}, an impressive high level, multi-paradigm, open
      source language.  Newcomers are recommended to start with the tutorial that
      comes with it.
+
      This opens many interesting possibilities, ranging from automating repetitive
      tasks to adding new functionality to the program: procedural models,
      importers and exporters, even complex applications and so on.  Blender itself
      comes with some scripts, but many others can be found in the Scripts & Plugins
      sections and forum posts at the Blender-related sites listed below.
 
 Scripting and Blender:
 ======================
 
 These are the basic ways to execute scripts in Blender:
 
- 1. They can be loaded or typed as text files in the Text Editor window, then
- executed with ALT+P.
- 2. Via command line: C{blender -P <scriptname>} will start Blender and execute
- the given script.  <scriptname> can be a filename in the user's file system or
- the name of a text saved in a .blend Blender file:
- 'blender myfile.blend -P textname'.
- 3. Via command line in I{background mode}: use the '-b' flag (the order is
- important): C{blender -b <blendfile> -P <scriptname>}.  <blendfile> can be any
- .blend file, including the default .B.blend that is in Blender's home directory
- L{Blender.Get}('homedir'). In this mode no window will be opened and the
- program will leave as soon as the script finishes execution.
- 4. Properly registered scripts can be selected directly from the program's
- menus.
- 5. Scriptlinks: these are also loaded or typed in the Text Editor window and
- can be linked to objects, materials or scenes using the Scriptlink buttons
- tab.  Script links get executed automatically when their events (ONLOAD,
- REDRAW, FRAMECHANGED) are triggered.  Normal scripts can create (L{Text}) and
- link other scripts to objects and events, see L{Object.Object.addScriptLink},
- for example.
- 6. A script can call another script (that will run in its own context, with
- its own global dictionary) with the L{Blender.Run} module function.
      1. They can be loaded or typed as text files in the Text Editor window, then
      executed with ALT+P.
      2. Via command line: C{blender -P <scriptname>} will start Blender and execute
      the given script.  <scriptname> can be a filename in the user's file system or
      the name of a text saved in a .blend Blender file:
      'blender myfile.blend -P textname'.
      3. Via command line in I{background mode}: use the '-b' flag (the order is
      important): C{blender -b <blendfile> -P <scriptname>}.  <blendfile> can be any
      .blend file, including the default .B.blend that is in Blender's home directory
      L{Blender.Get}('homedir'). In this mode no window will be opened and the
      program will leave as soon as the script finishes execution.
      4. Properly registered scripts can be selected directly from the program's
      menus.
      5. Scriptlinks: these are also loaded or typed in the Text Editor window and
      can be linked to objects, materials or scenes using the Scriptlink buttons
      tab.  Script links get executed automatically when their events (ONLOAD,
      REDRAW, FRAMECHANGED) are triggered.  Normal scripts can create (L{Text}) and
      link other scripts to objects and events, see L{Object.Object.addScriptLink},
      for example.
      6. A script can call another script (that will run in its own context, with
      its own global dictionary) with the L{Blender.Run} module function.
 
 
 Interaction with users:
 -----------------------
 
- Scripts can:
-  - simply run and exit;
-  - pop messages, menus and small number and text input boxes;
-  - draw graphical user interfaces (GUIs) with OpenGL calls and native
-    program buttons, which stay there accepting user input like any other
-    Blender window until the user closes them;
-  - attach themselves to a space's event or drawing code (aka space handlers,
-    L{check here<API_related>});
-  - make changes to the 3D View (set visible layer(s), view point, etc);
-  - grab the main input event queue and process (or pass to Blender) selected
-    keyboard, mouse, redraw events -- not considered good practice, but still
-    available for private use;
-  - tell Blender to execute other scripts (see L{Blender.Run}());
-  - use external Python libraries, if available.
-
- You can read the documentation for the L{Window}, L{Draw} and L{BGL} modules
- for more information and also check the Python site for external modules that
- might be useful to you.  Note though that any imported module will become a
- requirement of your script, since Blender itself does not bundle external
- modules.
      Scripts can:
+               - simply run and exit;
+               - pop messages, menus and small number and text input boxes;
+               - draw graphical user interfaces (GUIs) with OpenGL calls and native
+                       program buttons, which stay there accepting user input like any other
+                       Blender window until the user closes them;
+               - attach themselves to a space's event or drawing code (aka space handlers,
+                       L{check here<API_related>});
+               - make changes to the 3D View (set visible layer(s), view point, etc);
+               - grab the main input event queue and process (or pass to Blender) selected
+                       keyboard, mouse, redraw events -- not considered good practice, but still
+                       available for private use;
+               - tell Blender to execute other scripts (see L{Blender.Run}());
+               - use external Python libraries, if available.
+
      You can read the documentation for the L{Window}, L{Draw} and L{BGL} modules
      for more information and also check the Python site for external modules that
      might be useful to you.  Note though that any imported module will become a
      requirement of your script, since Blender itself does not bundle external
      modules.
 
 Command line mode:
 ------------------
 
- Python was embedded in Blender, so to access BPython modules you need to
- run scripts from the program itself: you can't import the Blender module
- into an external Python interpreter.
      Python was embedded in Blender, so to access BPython modules you need to
      run scripts from the program itself: you can't import the Blender module
      into an external Python interpreter.
 
- On the other hand, for many tasks it's possible to control Blender via
- some automated process using scripts.  Interested readers should learn about
- features like "OnLoad" script links, the "-b <blendfile>" (background mode)
- and "-P <script>" (run script) command line options and API calls like
- L{Blender.Save}, L{Blender.Load}, L{Blender.Quit} and the L{Library} and
- L{Render} modules. 
      On the other hand, for many tasks it's possible to control Blender via
      some automated process using scripts.  Interested readers should learn about
      features like "OnLoad" script links, the "-b <blendfile>" (background mode)
      and "-P <script>" (run script) command line options and API calls like
      L{Blender.Save}, L{Blender.Load}, L{Blender.Quit} and the L{Library} and
      L{Render} modules. 
 
- Note that command line scripts are run before Blender initializes its windows
- (and in '-b' mode no window will be initialized), so many functions that get
- or set window related attributes (like most in L{Window}) don't work here.  If
- you need those, use an ONLOAD script link (see L{Scene.Scene.addScriptLink})
- instead -- it's also possible to use a command line script to write or set an
- ONLOAD script link.  Check the L{Blender.mode} module var to know if Blender
- is being executed in "background" or "interactive" mode.
      Note that command line scripts are run before Blender initializes its windows
      (and in '-b' mode no window will be initialized), so many functions that get
      or set window related attributes (like most in L{Window}) don't work here.  If
      you need those, use an ONLOAD script link (see L{Scene.Scene.addScriptLink})
      instead -- it's also possible to use a command line script to write or set an
      ONLOAD script link.  Check the L{Blender.mode} module var to know if Blender
      is being executed in "background" or "interactive" mode.
 
- L{Click here for command line and background mode examples<API_related>}.
      L{Click here for command line and background mode examples<API_related>}.
 
 
 Demo mode:
 ----------
 
- Blender has a demo mode, where once started it can work without user
- intervention, "showing itself off".  Demos can render stills and animations,
- play rendered or real-time animations, calculate radiosity simulations and
- do many other nifty things.  If you want to turn a .blend file into a demo,
- write a script to run the show and link it as a scene "OnLoad" scriptlink.
- The demo will then be played automatically whenever this .blend file is
- opened, B{unless Blender was started with the "-y" parameter}.
      Blender has a demo mode, where once started it can work without user
      intervention, "showing itself off".  Demos can render stills and animations,
      play rendered or real-time animations, calculate radiosity simulations and
      do many other nifty things.  If you want to turn a .blend file into a demo,
      write a script to run the show and link it as a scene "OnLoad" scriptlink.
      The demo will then be played automatically whenever this .blend file is
      opened, B{unless Blender was started with the "-y" parameter}.
 
 The Game Engine API:
 --------------------
 
- Blender has a game engine for users to create and play 3d games.  This
- engine lets programmers add scripts to improve game AI, control, etc, making
- more complex interaction and tricks possible.  The game engine API is
- separate from the Blender Python API this document references and you can
- find its own ref doc in the doc section of the main sites below.
      Blender has a game engine for users to create and play 3d games.  This
      engine lets programmers add scripts to improve game AI, control, etc, making
      more complex interaction and tricks possible.  The game engine API is
      separate from the Blender Python API this document references and you can
      find its own ref doc in the doc section of the main sites below.
 
 Blender Data Structures:
 ------------------------
 
- Programs manipulate data structures.  Blender python scripts are no exception.
- Blender uses an Object Oriented architecture.  The BPython interface tries to
- present Blender objects and their attributes in the same way you see them
- through the User Interface (the GUI).  One key to BPython programming is
- understanding the information presented in Blender's OOPS window where Blender
- objects and their relationships are displayed.
      Programs manipulate data structures.  Blender python scripts are no exception.
      Blender uses an Object Oriented architecture.  The BPython interface tries to
      present Blender objects and their attributes in the same way you see them
      through the User Interface (the GUI).  One key to BPython programming is
      understanding the information presented in Blender's OOPS window where Blender
      objects and their relationships are displayed.
 
- Each Blender graphic element (Mesh, Lamp, Curve, etc.) is composed from two
- parts: an Object and ObData. The Object holds information about the position,
- rotation and size of the element.  This is information that all elements have
- in common.  The ObData holds information specific to that particular type of
- element.  
      Each Blender graphic element (Mesh, Lamp, Curve, etc.) is composed from two
      parts: an Object and ObData. The Object holds information about the position,
      rotation and size of the element.  This is information that all elements have
      in common.  The ObData holds information specific to that particular type of
      element.  
 
- Each Object has a link to its associated ObData.  A single ObData may be
- shared by many Objects.  A graphic element also has a link to a list of
- Materials.  By default, this list is associated with the ObData.
      Each Object has a link to its associated ObData.  A single ObData may be
      shared by many Objects.  A graphic element also has a link to a list of
      Materials.  By default, this list is associated with the ObData.
 
- All Blender objects have a unique name.  However, the name is qualified by the
- type of the object.  This means you can have a Lamp Object called Lamp.001
- (OB:Lamp.001) and a Lamp ObData called Lamp.001 (LA:Lamp.001).
      All Blender objects have a unique name.  However, the name is qualified by the
      type of the object.  This means you can have a Lamp Object called Lamp.001
      (OB:Lamp.001) and a Lamp ObData called Lamp.001 (LA:Lamp.001).
 
- For a more in-depth look at Blender internals, and some understanding of why
- Blender works the way it does, see the U{Blender Architecture document
- <http://www.blender3d.org/cms/Blender_Architecture.336.0.html>}.
      For a more in-depth look at Blender internals, and some understanding of why
      Blender works the way it does, see the U{Blender Architecture document
      <http://www.blender3d.org/cms/Blender_Architecture.336.0.html>}.
 
 
 A note to newbie script writers:
 --------------------------------
 
- Interpreted languages are known to be much slower than compiled code, but for
- many applications the difference is negligible or acceptable.  Also, with
- profiling (or even simple direct timing with L{Blender.sys.time<Sys.time>}) to
- identify slow areas and well thought optimizations, the speed can be
- I{considerably} improved in many cases.  Try some of the best BPython scripts
- to get an idea of what can be done, you may be surprised.
      Interpreted languages are known to be much slower than compiled code, but for
      many applications the difference is negligible or acceptable.  Also, with
      profiling (or even simple direct timing with L{Blender.sys.time<Sys.time>}) to
      identify slow areas and well thought optimizations, the speed can be
      I{considerably} improved in many cases.  Try some of the best BPython scripts
      to get an idea of what can be done, you may be surprised.
 
 @author: The Blender Python Team
 @requires: Blender 2.43 or newer.
@@ -235,14 +235,14 @@ A note to newbie script writers:
 @see: U{www.python.org/doc<http://www.python.org/doc>}
 @see: U{Blending into Python<en.wikibooks.org/wiki/Blender_3D:_Blending_Into_Python>}: User contributed documentation, featuring a blender/python cookbook with many examples.
 @note: this documentation was generated by epydoc, which can output html and
-   pdf.  For pdf it requires a working LaTeX environment.
+         pdf.  For pdf it requires a working LaTeX environment.
 
 @note: the official version of this reference guide is only updated for each
-   new Blender release.  But you can build the current CVS
-   version yourself: install epydoc, grab all files in the
-   source/blender/python/api2_2x/doc/ folder of Blender's CVS and use the
-   epy_docgen.sh script also found there to generate the html docs.
-   Naturally you will also need a recent Blender binary to try the new
-   features.  If you prefer not to compile it yourself, there is a testing
-   builds forum at U{blender.org<http://www.blender.org>}.
+       new Blender release.  But you can build the current CVS
+       version yourself: install epydoc, grab all files in the
+       source/blender/python/api2_2x/doc/ folder of Blender's CVS and use the
+       epy_docgen.sh script also found there to generate the html docs.
+       Naturally you will also need a recent Blender binary to try the new
+       features.  If you prefer not to compile it yourself, there is a testing
+       builds forum at U{blender.org<http://www.blender.org>}.
 """
index c6a5608f7d10d46ce4c14d00f37b873508cf9863..8e179e225836ce0d8cdb7c7ec456e4770b4c5680 100644 (file)
@@ -114,249 +114,245 @@ def Get (name = None):
   """
 
 def New (name = None):
-  """
-  Return a new armature.
-  @type name: string or nothing
-  @param name: The string name of the new armature.
-  @rtype: Blender Armature.
-  @return: A new armature.
-  """
+       """
+       Return a new armature.
+       @type name: string or nothing
+       @param name: The string name of the new armature.
+       @rtype: Blender Armature.
+       @return: A new armature.
+       """
 
 class Armature:
-  """
-  The Armature object
-  ===================
-    This object gives access to Armature-specific data in Blender.
-  @ivar name: The Armature name.
-  @type name: String
-  @ivar bones: A Dictionary of Bones (BonesDict) that make up this armature.
-  @type bones: BonesDict Object
-  @ivar vertexGroups: Whether vertex groups define deformation
-  @type vertexGroups: Bool
-  @ivar envelopes: Whether bone envelopes define deformation
-  @type envelopes: Bool
-  @ivar restPosition: Show rest position (no posing possible)
-  @type restPosition: Bool
-  @ivar delayDeform: Don't deform children when manipulating bones
-  @type delayDeform: Bool
-  @ivar drawAxes: Draw bone axes
-  @type drawAxes: Bool
-  @ivar drawNames: Draw bone names
-  @type drawNames: Bool
-  @ivar ghost: Draw ghosts around frame for current Action
-  @type ghost: Bool
-  @ivar ghostStep: Number of frames between ghosts
-  @type ghostStep: Int
-  @ivar drawType: The drawing type that is used to display the armature
-  Acceptable values are:
-      - Armature.OCTAHEDRON: bones drawn as octahedrons
-      - Armature.STICK: bones drawn as sticks
-      - Armature.BBONE: bones drawn as b-bones
-      - Armature.ENVELOPE: bones drawn as sticks with envelopes
-  @type drawType: Constant Object
-  @ivar mirrorEdit: X-axis mirrored editing
-  @type mirrorEdit: Bool
-  @ivar autoIK: Adds temporary IK chains while grabbing bones
-  @type autoIK: Bool
-  @ivar users: The number of users of the armature.  Read-only.
-  @type users: int
-  @ivar fakeUser: The fake user status.
-    Enabling this will keep it in the blend even if there are no users.
-  @type fakeUser: bool
-  """
-
-  def __init__(name = 'myArmature'):
-    """
-    Initializer for the Armature TypeObject.
-    Example::
-        myNewArmature = Blender.Armature.Armature('AR_1')
-    @param name: The name for the new armature
-    @type name: string
-    @return: New Armature Object
-    @rtype: Armature Object
-    """
-  
-  def makeEditable():
-    """
-    Put the armature into EditMode for editing purposes. (Enters Editmode)
-    @warning: Using Window.Editmode() to switch the editmode manually will cause problems and possibly even crash Blender.
-    @warning: This is only needed for operations such as adding and removing bones.
-    @warning: Do access pose data until you have called update() or settings will be lost. 
-    @warning: The armature should not be in manual editmode
-    prior to calling this method. The armature must be parented
-    to an object prior to editing.
-    @rtype: None
-    """
-
-  def update():
-    """
-    Save all changes and update the armature. (Leaves Editmode)
-    @note: Must have called makeEditable() first.
-    @rtype: None
-    """
+       """
+       The Armature object
+       ===================
+               This object gives access to Armature-specific data in Blender.
+       @ivar bones: A Dictionary of Bones (BonesDict) that make up this armature.
+       @type bones: BonesDict Object
+       @ivar vertexGroups: Whether vertex groups define deformation
+       @type vertexGroups: Bool
+       @ivar envelopes: Whether bone envelopes define deformation
+       @type envelopes: Bool
+       @ivar restPosition: Show rest position (no posing possible)
+       @type restPosition: Bool
+       @ivar delayDeform: Don't deform children when manipulating bones
+       @type delayDeform: Bool
+       @ivar drawAxes: Draw bone axes
+       @type drawAxes: Bool
+       @ivar drawNames: Draw bone names
+       @type drawNames: Bool
+       @ivar ghost: Draw ghosts around frame for current Action
+       @type ghost: Bool
+       @ivar ghostStep: Number of frames between ghosts
+       @type ghostStep: Int
+       @ivar drawType: The drawing type that is used to display the armature
+       Acceptable values are:
+                       - Armature.OCTAHEDRON: bones drawn as octahedrons
+                       - Armature.STICK: bones drawn as sticks
+                       - Armature.BBONE: bones drawn as b-bones
+                       - Armature.ENVELOPE: bones drawn as sticks with envelopes
+       @type drawType: Constant Object
+       @ivar mirrorEdit: X-axis mirrored editing
+       @type mirrorEdit: Bool
+       @ivar autoIK: Adds temporary IK chains while grabbing bones
+       @type autoIK: Bool
+       """
+
+       def __init__(name = 'myArmature'):
+               """
+               Initializer for the Armature TypeObject.
+               Example::
+                         myNewArmature = Blender.Armature.Armature('AR_1')
+               @param name: The name for the new armature
+               @type name: string
+               @return: New Armature Object
+               @rtype: Armature Object
+               """
+       
+       def makeEditable():
+               """
+               Put the armature into EditMode for editing purposes. (Enters Editmode)
+               @warning: Using Window.Editmode() to switch the editmode manually will cause problems and possibly even crash Blender.
+               @warning: This is only needed for operations such as adding and removing bones.
+               @warning: Do access pose data until you have called update() or settings will be lost. 
+               @warning: The armature should not be in manual editmode
+               prior to calling this method. The armature must be parented
+               to an object prior to editing.
+               @rtype: None
+               """
+
+       def update():
+               """
+               Save all changes and update the armature. (Leaves Editmode)
+               @note: Must have called makeEditable() first.
+               @rtype: None
+               """
+
+import id_generics
+Armature.__doc__ += id_generics.attributes 
 
 class BonesDict:
-  """
-  The BonesDict object
-  ====================
-    This object gives gives dictionary like access to the bones in an armature. 
-    It is internal to blender but is called as 'Armature.bones'
-
-    Removing a bone: 
-    Example::
-      del myArmature.bones['bone_name']
-    Adding a bone:
-    Example::
-      myEditBone = Armature.Editbone()
-      myArmature.bones['bone_name'] = myEditBone
-  """
-
-  def items():
-    """
-    Return the key, value pairs in this dictionary
-    @rtype: string, BPy_bone
-    @return: All strings, and py_bones in the armature (in that order)
-    """
-
-  def keys():
-    """
-    Return the keys in this dictionary
-    @rtype: string
-    @return: All strings representing the bone names
-    """
-
-  def values():
-    """
-    Return the values in this dictionary
-    @rtype: BPy_bone
-    @return: All BPy_bones in this dictionary
-    """
+       """
+       The BonesDict object
+       ====================
+               This object gives gives dictionary like access to the bones in an armature. 
+               It is internal to blender but is called as 'Armature.bones'
+
+               Removing a bone: 
+               Example::
+                       del myArmature.bones['bone_name']
+               Adding a bone:
+               Example::
+                       myEditBone = Armature.Editbone()
+                       myArmature.bones['bone_name'] = myEditBone
+       """
+
+       def items():
+               """
+               Return the key, value pairs in this dictionary
+               @rtype: string, BPy_bone
+               @return: All strings, and py_bones in the armature (in that order)
+               """
+
+       def keys():
+               """
+               Return the keys in this dictionary
+               @rtype: string
+               @return: All strings representing the bone names
+               """
+
+       def values():
+               """
+               Return the values in this dictionary
+               @rtype: BPy_bone
+               @return: All BPy_bones in this dictionary
+               """
 
 class Bone:
-  """
-  The Bone object
-  ===============
-    This object gives access to Bone-specific data in Blender. This object
-    cannot be instantiated but is returned by BonesDict when the armature is not in editmode.
-  @ivar name: The name of this Bone.
-  @type name: String
-  @ivar roll: This Bone's roll value.
-    Keys are:
-       - 'ARMATURESPACE' - this roll in relation to the armature
-       - 'BONESPACE' - the roll in relation to itself 
-  @type roll: Dictionary
-  @ivar head: This Bone's "head" ending position when in rest state.
-    Keys are:
-       - 'ARMATURESPACE' - this head position in relation to the armature
-       - 'BONESPACE' - the head position in relation to itself 
-  @type head: Dictionary
-  @ivar tail: This Bone's "tail" ending position when in rest state.
-    Keys are:
-       - 'ARMATURESPACE' - this tail position in relation to the armature
-       - 'BONESPACE' - the tail position in relation to itself 
-  @type tail: Dictionary
-  @ivar matrix: This Bone's matrix. This cannot be set.
-    Keys are:
-       - 'ARMATURESPACE' - this matrix of the bone in relation to the armature
-       - 'BONESPACE' - the matrix of the bone in relation to itself 
-  @type matrix: Matrix Object
-  @ivar parent: The parent Bone.
-  @type parent: Bone Object
-  @ivar children: The children directly attached to this bone.
-  @type children: List of Bone Objects
-  @ivar weight: The bone's weight.
-  @type weight: Float
-  @ivar options: Various bone options which can be:
-       - Armature.CONNECTED: IK to parent
-       - Armature.HINGE: No parent rotation or scaling
-       - Armature.NO_DEFORM: The bone does not deform geometry
-       - Armature.MULTIPLY: Multiply vgroups by envelope
-       - Armature.HIDDEN_EDIT: Hide bones in editmode
-       - Armature.ROOT_SELECTED: Selection of root ball of bone
-       - Armature.BONE_SELECTED: Selection of bone
-       - Armature.TIP_SELECTED: Selection of tip ball of bone
-  @type options: List of Constants
-  @ivar subdivision: The number of bone subdivisions.
-  @type subdivision: Int
-  @ivar deformDist: The deform distance of the bone
-  @type deformDist: Float
-  @ivar length: The length of the bone. This cannot be set.
-  @type length: Float
-  @ivar headRadius: The radius of this bones head (used for envalope bones)
-  @type headRadius: Float
-  @ivar tailRadius: The radius of this bones head (used for envalope bones)
-  @type tailRadius: Float
-  """
-
-  def hasParent():
-    """
-    Whether or not this bone has a parent
-    @rtype: Bool
-    """
-
-  def hasChildren():
-    """
-    Whether or not this bone has children
-    @rtype: Bool
-    """
-
-  def getAllChildren():
-    """
-    Gets all the children under this bone including the children's children.
-    @rtype: List of Bone object
-    @return: all bones under this one
-    """
+       """
+       The Bone object
+       ===============
+               This object gives access to Bone-specific data in Blender. This object
+               cannot be instantiated but is returned by BonesDict when the armature is not in editmode.
+       @ivar name: The name of this Bone.
+       @type name: String
+       @ivar roll: This Bone's roll value.
+               Keys are:
+                        - 'ARMATURESPACE' - this roll in relation to the armature
+                        - 'BONESPACE' - the roll in relation to itself 
+       @type roll: Dictionary
+       @ivar head: This Bone's "head" ending position when in rest state.
+               Keys are:
+                        - 'ARMATURESPACE' - this head position in relation to the armature
+                        - 'BONESPACE' - the head position in relation to itself 
+       @type head: Dictionary
+       @ivar tail: This Bone's "tail" ending position when in rest state.
+               Keys are:
+                        - 'ARMATURESPACE' - this tail position in relation to the armature
+                        - 'BONESPACE' - the tail position in relation to itself 
+       @type tail: Dictionary
+       @ivar matrix: This Bone's matrix. This cannot be set.
+               Keys are:
+                        - 'ARMATURESPACE' - this matrix of the bone in relation to the armature
+                        - 'BONESPACE' - the matrix of the bone in relation to itself 
+       @type matrix: Matrix Object
+       @ivar parent: The parent Bone.
+       @type parent: Bone Object
+       @ivar children: The children directly attached to this bone.
+       @type children: List of Bone Objects
+       @ivar weight: The bone's weight.
+       @type weight: Float
+       @ivar options: Various bone options which can be:
+                        - Armature.CONNECTED: IK to parent
+                        - Armature.HINGE: No parent rotation or scaling
+                        - Armature.NO_DEFORM: The bone does not deform geometry
+                        - Armature.MULTIPLY: Multiply vgroups by envelope
+                        - Armature.HIDDEN_EDIT: Hide bones in editmode
+                        - Armature.ROOT_SELECTED: Selection of root ball of bone
+                        - Armature.BONE_SELECTED: Selection of bone
+                        - Armature.TIP_SELECTED: Selection of tip ball of bone
+       @type options: List of Constants
+       @ivar subdivision: The number of bone subdivisions.
+       @type subdivision: Int
+       @ivar deformDist: The deform distance of the bone
+       @type deformDist: Float
+       @ivar length: The length of the bone. This cannot be set.
+       @type length: Float
+       @ivar headRadius: The radius of this bones head (used for envalope bones)
+       @type headRadius: Float
+       @ivar tailRadius: The radius of this bones head (used for envalope bones)
+       @type tailRadius: Float
+       """
+
+       def hasParent():
+               """
+               Whether or not this bone has a parent
+               @rtype: Bool
+               """
+
+       def hasChildren():
+               """
+               Whether or not this bone has children
+               @rtype: Bool
+               """
+
+       def getAllChildren():
+               """
+               Gets all the children under this bone including the children's children.
+               @rtype: List of Bone object
+               @return: all bones under this one
+               """
 
 class Editbone:
-  """
-  The Editbone Object
-  ===================
-    This object is a wrapper for editbone data and is used only in the manipulation
-    of the armature in editmode.
-  @ivar name: The name of this Bone.
-  @type name: String
-  @ivar roll: This Bone's roll value (armaturespace).
-  @type roll: Float
-  @ivar head: This Bone's "head" ending position when in rest state (armaturespace).
-  @type head: Vector Object
-  @ivar tail: This Bone's "tail" ending position when in rest state (armaturespace).
-  @type tail: Vector Object
-  @ivar matrix: This Bone's matrix. (armaturespace)
-  @type matrix: Matrix Object
-  @ivar parent: The parent Bone.
-  @type parent: Editbone Object
-  @ivar weight: The bone's weight.
-  @type weight: Float
-  @ivar options: Various bone options which can be:
-       - Armature.CONNECTED: IK to parent
-       - Armature.HINGE: No parent rotation or scaling
-       - Armature.NO_DEFORM: The bone does not deform geometry
-       - Armature.MULTIPLY: Multiply vgroups by envelope
-       - Armature.HIDDEN_EDIT: Hide bones in editmode
-       - Armature.ROOT_SELECTED: Selection of root ball of bone
-       - Armature.BONE_SELECTED: Selection of bone
-       - Armature.TIP_SELECTED: Selection of tip ball of bone
-  @type options: List of Constants
-  @ivar subdivision: The number of bone subdivisions.
-  @type subdivision: Int
-  @ivar deformDist: The deform distance of the bone
-  @type deformDist: Float
-  @ivar length: The length of the bone. This cannot be set.
-  @type length: Float
-  @ivar headRadius: The radius of this bones head (used for envalope bones)
-  @type headRadius: Float
-  @ivar tailRadius: The radius of this bones head (used for envalope bones)
-  @type tailRadius: Float
-  """
-
-  def hasParent():
-    """
-    Whether or not this bone has a parent
-    @rtype: Bool
-    """
-
-  def clearParent():
-    """
-    Set the parent to None
-    @rtype: None
-    """
+       """
+       The Editbone Object
+       ===================
+               This object is a wrapper for editbone data and is used only in the manipulation
+               of the armature in editmode.
+       @ivar name: The name of this Bone.
+       @type name: String
+       @ivar roll: This Bone's roll value (armaturespace).
+       @type roll: Float
+       @ivar head: This Bone's "head" ending position when in rest state (armaturespace).
+       @type head: Vector Object
+       @ivar tail: This Bone's "tail" ending position when in rest state (armaturespace).
+       @type tail: Vector Object
+       @ivar matrix: This Bone's matrix. (armaturespace)
+       @type matrix: Matrix Object
+       @ivar parent: The parent Bone.
+       @type parent: Editbone Object
+       @ivar weight: The bone's weight.
+       @type weight: Float
+       @ivar options: Various bone options which can be:
+                        - Armature.CONNECTED: IK to parent
+                        - Armature.HINGE: No parent rotation or scaling
+                        - Armature.NO_DEFORM: The bone does not deform geometry
+                        - Armature.MULTIPLY: Multiply vgroups by envelope
+                        - Armature.HIDDEN_EDIT: Hide bones in editmode
+                        - Armature.ROOT_SELECTED: Selection of root ball of bone
+                        - Armature.BONE_SELECTED: Selection of bone
+                        - Armature.TIP_SELECTED: Selection of tip ball of bone
+       @type options: List of Constants
+       @ivar subdivision: The number of bone subdivisions.
+       @type subdivision: Int
+       @ivar deformDist: The deform distance of the bone
+       @type deformDist: Float
+       @ivar length: The length of the bone. This cannot be set.
+       @type length: Float
+       @ivar headRadius: The radius of this bones head (used for envalope bones)
+       @type headRadius: Float
+       @ivar tailRadius: The radius of this bones head (used for envalope bones)
+       @type tailRadius: Float
+       """
+
+       def hasParent():
+               """
+               Whether or not this bone has a parent
+               @rtype: Bool
+               """
+
+       def clearParent():
+               """
+               Set the parent to None
+               @rtype: None
+               """
index 01dc4525d59b804d80014c3bb1efd6240234e0c8..5d4b5670822c72d01908c404882fa5556b42f570 100644 (file)
@@ -12,243 +12,245 @@ This module provides access to B{Camera Data} objects in Blender.
 
 Example::
 
-  from Blender import Camera, Object, Scene
-  cam = Camera.New('ortho')   # create new ortho camera data
-  cam.scale = 6.0             # set scale value for ortho view
-  scn = Scene.GetCurrent()    # get current scene
-  ob = scn.objects.new(cam)   # add a new camera object from the data
-  scn.setCurrentCamera(ob)    # make this camera the active
+       from Blender import Camera, Object, Scene
+       cam = Camera.New('ortho')   # create new ortho camera data
+       cam.scale = 6.0             # set scale value for ortho view
+       scn = Scene.GetCurrent()    # get current scene
+       ob = scn.objects.new(cam)   # add a new camera object from the data
+       scn.setCurrentCamera(ob)    # make this camera the active
 """
 
 def New (type = 'persp', name = 'CamData'):
-  """
-  Create a new Camera Data object.
-  @type type: string
-  @param type: The Camera type: 'persp' or 'ortho'.
-  @type name: string
-  @param name: The Camera Data name.
-  @rtype: Blender Camera
-  @return: The created Camera Data object.
-  """
+       """
+       Create a new Camera Data object.
+       @type type: string
+       @param type: The Camera type: 'persp' or 'ortho'.
+       @type name: string
+       @param name: The Camera Data name.
+       @rtype: Blender Camera
+       @return: The created Camera Data object.
+       """
 
 def Get (name = None):
-  """
-  Get the Camera Data object(s) from Blender.
-  @type name: string
-  @param name: The name of the Camera Data.
-  @rtype: Blender Camera or a list of Blender Cameras
-  @return: It depends on the I{name} parameter:
-      - (name): The Camera Data object with the given I{name};
-      - ():     A list with all Camera Data objects in the current scene.
-  """
+       """
+       Get the Camera Data object(s) from Blender.
+       @type name: string
+       @param name: The name of the Camera Data.
+       @rtype: Blender Camera or a list of Blender Cameras
+       @return: It depends on the I{name} parameter:
+                       - (name): The Camera Data object with the given I{name};
+                       - ():     A list with all Camera Data objects in the current scene.
+       """
 
 class Camera:
-  """
-  The Camera Data object
-  ======================
-    This object gives access to Camera-specific data in Blender.
-  @ivar name: The Camera Data name.
-  @ivar type: The Camera type: 'persp' or 'ortho'
-  @ivar mode: The mode flags: B{ORed value}: 'showLimits':1, 'showMist':2.
-  @ivar lens: The lens value in [1.0, 250.0], only relevant to *persp* cameras.
-  @ivar scale: The scale value in [0.01, 1000.00], only relevant to *ortho* cameras.
-  @ivar clipStart: The clip start value in [0.0, 100.0].
-  @ivar clipEnd: The clip end value in [1.0, 5000.0].
-  @ivar dofDist: The dofDist value in [0.0, 5000.0].
-  @ivar shiftx: The horizontal offset of the camera [-2.0, 2.0].
-  @ivar shifty: The vertical offset of the camera [-2.0, 2.0].
-  @ivar alpha: The PassePart alpha [0.0, 1.0].
-  @ivar drawSize: The display size for the camera an the 3d view [0.1, 10.0].
-  @type ipo: Blender Ipo
-  @ivar ipo: The "camera data" ipo linked to this camera data object.
-    Set to None to clear the ipo.
-
-  @ivar drawLimits: Toggle the option to show limits in the 3d view.
-  @ivar drawName: Toggle the option to show the camera name in the 3d view.
-  @ivar drawMist: Toggle the option to show mist in the 3d view.
-  @ivar drawTileSafe: Toggle the option to show tile safe in the 3d view.
-  @ivar drawPassepartout: Toggle the option to show pass part out in the 3d view.
-
-  @warning: Most member variables assume values in some [Min, Max] interval.
-      When trying to set them, the given parameter will be clamped to lie in
-      that range: if val < Min, then val = Min, if val > Max, then val = Max.
-  """
-
-  def getName():
-    """
-    Get the name of this Camera Data object.  (B{deprecated}) See the L{name} attribute.
-    @rtype: string
-    """
-
-  def setName(name):
-    """
-    Set the name of this Camera Data object. (B{deprecated}) See the L{name} attribute.
-    @type name: string
-    @param name: The new name.
-    """
-
-  def getIpo():
-    """
-    Get the Ipo associated with this camera data object, if any. (B{deprecated})
-    @rtype: Ipo
-    @return: the wrapped ipo or None. (B{deprecated}) See the L{ipo} attribute.
-    """
-
-  def setIpo(ipo):
-    """
-    Link an ipo to this camera data object.  (B{deprecated}) See the L{ipo} attribute.
-    @type ipo: Blender Ipo
-    @param ipo: a "camera data" ipo.
-    """
-
-  def clearIpo():
-    """
-    Unlink the ipo from this camera data object.  (B{deprecated}) See the L{ipo} attribute.
-    @return: True if there was an ipo linked or False otherwise.
-    """
-
-  def getType():
-    """
-    Get this Camera's type.  (B{deprecated}) See the L{type} attribute.
-    @rtype: int
-    @return: 0 for 'persp' or 1 for 'ortho'.
-    """
-
-  def setType(type):
-    """
-    Set this Camera's type.  (B{deprecated}) See the L{type} attribute.
-    @type type: string
-    @param type: The Camera type: 'persp' or 'ortho'.
-    """
-
-  def getMode():
-    """
-    Get this Camera's mode flags. (B{deprecated}) See the L{mode} attribute.
-    @rtype: int
-    @return: B{OR'ed value}: 'showLimits' is 1, 'showMist' is 2, or
-       respectively, 01 and 10 in binary.
-    """
-
-  def setMode(mode1 = None, mode2 = None):
-    """
-    Set this Camera's mode flags. Mode strings given are turned 'on'.  (B{deprecated}) See the L{mode} attribute.
-    Those not provided are turned 'off', so cam.setMode() -- without 
-    arguments -- turns off all mode flags for Camera cam.
-    @type mode1: string
-    @type mode2: string
-    @param mode1: A mode flag: 'showLimits' or 'showMist'.
-    @param mode2: A mode flag: 'showLimits' or 'showMist'.
-    """
-
-  def getLens():
-    """
-    Get the lens value.  (B{deprecated}) See the L{lens} attribute.
-    @rtype: float
-    @warn: lens is only relevant for perspective (L{getType}) cameras.
-    """
-
-  def setLens(lens):
-    """
-    Set the lens value. (B{deprecated}) See the L{lens} attribute.
-    @type lens: float
-    @param lens: The new lens value. 
-    @warn: lens is only relevant for perspective (L{type}) cameras.
-    """
-
-  def getScale():
-    """
-    Get the scale value. (B{deprecated}) See the L{scale} attribute.
-    @rtype: float
-    @warn: scale is only relevant for ortho (L{type}) cameras.
-    """
-
-  def setScale(scale):
-    """
-    Set the scale value. (B{deprecated}) See the L{scale} attribute.
-    @type scale: float
-    @param scale: The new scale value in [0.01, 1000.00]. 
-    @warn: scale is only relevant for ortho (L{getType}) cameras.
-    """
-
-  def getClipStart():
-    """
-    Get the clip start value. (B{deprecated}) See the L{clipStart} attribute.
-    @rtype: float
-    """
-
-  def setClipStart(clipstart):
-    """
-    Set the clip start value. (B{deprecated}) See the L{clipStart} attribute.
-    @type clipstart: float
-    @param clipstart: The new lens value.
-    """
-
-  def getClipEnd():
-    """
-    Get the clip end value. (B{deprecated}) See the L{clipEnd} attribute.
-    @rtype: float
-    """
-
-  def setClipEnd(clipend):
-    """
-    Set the clip end value. (B{deprecated}) See the L{clipEnd} attribute.
-    @type clipend: float
-    @param clipend: The new clip end value.
-    """
-
-  def getDrawSize():
-    """
-    Get the draw size value. (B{deprecated}) See the L{drawSize} attribute.
-    @rtype: float
-    """
-
-  def setDrawSize(drawsize):
-    """
-    Set the draw size value. (B{deprecated}) See the L{drawSize} attribute.
-    @type drawsize: float
-    @param drawsize: The new draw size value.
-    """
-
-  def getScriptLinks (event):
-    """
-    Get a list with this Camera's script links of type 'event'.
-    @type event: string
-    @param event: "FrameChanged", "Redraw" or "Render".
-    @rtype: list
-    @return: a list with Blender L{Text} names (the script links of the given
-        'event' type) or None if there are no script links at all.
-    """
-
-  def clearScriptLinks (links = None):
-    """
-    Delete script links from this Camera.  If no list is specified, all
-    script links are deleted.
-    @type links: list of strings
-    @param links: None (default) or a list of Blender L{Text} names.
-    """
-
-  def addScriptLink (text, event):
-    """
-    Add a new script link to this Camera.
-    @type text: string
-    @param text: the name of an existing Blender L{Text}.
-    @type event: string
-    @param event: "FrameChanged", "Redraw" or "Render".
-    """
-
-  def insertIpoKey(keytype):
-    """
-    Inserts keytype values in camera ipo at curframe. Uses module constants.
-    @type keytype: Integer
-    @param keytype:
-           -LENS
-           -CLIPPING
-    @return: py_none
-    """  
-
-  def __copy__ ():
-    """
-    Make a copy of this camera
-    @rtype: Camera
-    @return:  a copy of this camera
-    """
\ No newline at end of file
+       """
+       The Camera Data object
+       ======================
+               This object gives access to Camera-specific data in Blender.
+       @ivar type: The Camera type: 'persp' or 'ortho'
+       @ivar mode: The mode flags: B{ORed value}: 'showLimits':1, 'showMist':2.
+       @ivar lens: The lens value in [1.0, 250.0], only relevant to *persp* cameras.
+       @ivar scale: The scale value in [0.01, 1000.00], only relevant to *ortho* cameras.
+       @ivar clipStart: The clip start value in [0.0, 100.0].
+       @ivar clipEnd: The clip end value in [1.0, 5000.0].
+       @ivar dofDist: The dofDist value in [0.0, 5000.0].
+       @ivar shiftx: The horizontal offset of the camera [-2.0, 2.0].
+       @ivar shifty: The vertical offset of the camera [-2.0, 2.0].
+       @ivar alpha: The PassePart alpha [0.0, 1.0].
+       @ivar drawSize: The display size for the camera an the 3d view [0.1, 10.0].
+       @type ipo: Blender Ipo
+       @ivar ipo: The "camera data" ipo linked to this camera data object.
+               Set to None to clear the ipo.
+
+       @ivar drawLimits: Toggle the option to show limits in the 3d view.
+       @ivar drawName: Toggle the option to show the camera name in the 3d view.
+       @ivar drawMist: Toggle the option to show mist in the 3d view.
+       @ivar drawTileSafe: Toggle the option to show tile safe in the 3d view.
+       @ivar drawPassepartout: Toggle the option to show pass part out in the 3d view.
+
+       @warning: Most member variables assume values in some [Min, Max] interval.
+                       When trying to set them, the given parameter will be clamped to lie in
+                       that range: if val < Min, then val = Min, if val > Max, then val = Max.
+       """
+
+       def getName():
+               """
+               Get the name of this Camera Data object.  (B{deprecated}) See the L{name} attribute.
+               @rtype: string
+               """
+
+       def setName(name):
+               """
+               Set the name of this Camera Data object. (B{deprecated}) See the L{name} attribute.
+               @type name: string
+               @param name: The new name.
+               """
+
+       def getIpo():
+               """
+               Get the Ipo associated with this camera data object, if any. (B{deprecated})
+               @rtype: Ipo
+               @return: the wrapped ipo or None. (B{deprecated}) See the L{ipo} attribute.
+               """
+
+       def setIpo(ipo):
+               """
+               Link an ipo to this camera data object.  (B{deprecated}) See the L{ipo} attribute.
+               @type ipo: Blender Ipo
+               @param ipo: a "camera data" ipo.
+               """
+
+       def clearIpo():
+               """
+               Unlink the ipo from this camera data object.  (B{deprecated}) See the L{ipo} attribute.
+               @return: True if there was an ipo linked or False otherwise.
+               """
+
+       def getType():
+               """
+               Get this Camera's type.  (B{deprecated}) See the L{type} attribute.
+               @rtype: int
+               @return: 0 for 'persp' or 1 for 'ortho'.
+               """
+
+       def setType(type):
+               """
+               Set this Camera's type.  (B{deprecated}) See the L{type} attribute.
+               @type type: string
+               @param type: The Camera type: 'persp' or 'ortho'.
+               """
+
+       def getMode():
+               """
+               Get this Camera's mode flags. (B{deprecated}) See the L{mode} attribute.
+               @rtype: int
+               @return: B{OR'ed value}: 'showLimits' is 1, 'showMist' is 2, or
+                        respectively, 01 and 10 in binary.
+               """
+
+       def setMode(mode1 = None, mode2 = None):
+               """
+               Set this Camera's mode flags. Mode strings given are turned 'on'.  (B{deprecated}) See the L{mode} attribute.
+               Those not provided are turned 'off', so cam.setMode() -- without 
+               arguments -- turns off all mode flags for Camera cam.
+               @type mode1: string
+               @type mode2: string
+               @param mode1: A mode flag: 'showLimits' or 'showMist'.
+               @param mode2: A mode flag: 'showLimits' or 'showMist'.
+               """
+
+       def getLens():
+               """
+               Get the lens value.  (B{deprecated}) See the L{lens} attribute.
+               @rtype: float
+               @warn: lens is only relevant for perspective (L{getType}) cameras.
+               """
+
+       def setLens(lens):
+               """
+               Set the lens value. (B{deprecated}) See the L{lens} attribute.
+               @type lens: float
+               @param lens: The new lens value. 
+               @warn: lens is only relevant for perspective (L{type}) cameras.
+               """
+
+       def getScale():
+               """
+               Get the scale value. (B{deprecated}) See the L{scale} attribute.
+               @rtype: float
+               @warn: scale is only relevant for ortho (L{type}) cameras.
+               """
+
+       def setScale(scale):
+               """
+               Set the scale value. (B{deprecated}) See the L{scale} attribute.
+               @type scale: float
+               @param scale: The new scale value in [0.01, 1000.00]. 
+               @warn: scale is only relevant for ortho (L{getType}) cameras.
+               """
+
+       def getClipStart():
+               """
+               Get the clip start value. (B{deprecated}) See the L{clipStart} attribute.
+               @rtype: float
+               """
+
+       def setClipStart(clipstart):
+               """
+               Set the clip start value. (B{deprecated}) See the L{clipStart} attribute.
+               @type clipstart: float
+               @param clipstart: The new lens value.
+               """
+
+       def getClipEnd():
+               """
+               Get the clip end value. (B{deprecated}) See the L{clipEnd} attribute.
+               @rtype: float
+               """
+
+       def setClipEnd(clipend):
+               """
+               Set the clip end value. (B{deprecated}) See the L{clipEnd} attribute.
+               @type clipend: float
+               @param clipend: The new clip end value.
+               """
+
+       def getDrawSize():
+               """
+               Get the draw size value. (B{deprecated}) See the L{drawSize} attribute.
+               @rtype: float
+               """
+
+       def setDrawSize(drawsize):
+               """
+               Set the draw size value. (B{deprecated}) See the L{drawSize} attribute.
+               @type drawsize: float
+               @param drawsize: The new draw size value.
+               """
+
+       def getScriptLinks (event):
+               """
+               Get a list with this Camera's script links of type 'event'.
+               @type event: string
+               @param event: "FrameChanged", "Redraw" or "Render".
+               @rtype: list
+               @return: a list with Blender L{Text} names (the script links of the given
+                         'event' type) or None if there are no script links at all.
+               """
+
+       def clearScriptLinks (links = None):
+               """
+               Delete script links from this Camera.  If no list is specified, all
+               script links are deleted.
+               @type links: list of strings
+               @param links: None (default) or a list of Blender L{Text} names.
+               """
+
+       def addScriptLink (text, event):
+               """
+               Add a new script link to this Camera.
+               @type text: string
+               @param text: the name of an existing Blender L{Text}.
+               @type event: string
+               @param event: "FrameChanged", "Redraw" or "Render".
+               """
+
+       def insertIpoKey(keytype):
+               """
+               Inserts keytype values in camera ipo at curframe. Uses module constants.
+               @type keytype: Integer
+               @param keytype:
+                            -LENS
+                            -CLIPPING
+               @return: py_none
+               """  
+
+       def __copy__ ():
+               """
+               Make a copy of this camera
+               @rtype: Camera
+               @return:  a copy of this camera
+               """
+
+import id_generics
+Camera.__doc__ += id_generics.attributes
index 5e6586218b7541bf9527bbaa3690b5bd26a4ddd5..da69fb23c065187d5c6345766da9871feb2181e2 100644 (file)
 The Blender.Constraint submodule
 
 B{New}: 
-  -  provides access to Blender's constraint stack
+       -  provides access to Blender's constraint stack
 
 This module provides access to the Constraint Data in Blender.
 
 Examples::
-  from Blender import *
-
-  ob = Object.Get('Cube')
-  if len(ob.constraints) > 0:
-    const = ob.constraints[0]
-    if const.type == Constraint.Type.FLOOR:
-      offs = const[Constraint.Settings.OFFSET]
-  
+       from Blender import *
+
+       ob = Object.Get('Cube')
+       if len(ob.constraints) > 0:
+               const = ob.constraints[0]
+               if const.type == Constraint.Type.FLOOR:
+                       offs = const[Constraint.Settings.OFFSET]
+       
 Or to print all the constraints attached to each bone in a pose::
-  from Blender import *
-  
-  ob = Object.Get('Armature')
-  pose = ob.getPose()
-  for bonename in pose.bones.keys():
-    bone = pose.bones[bonename]
-    for const in bone.constraints:
-      print bone.name,'=>',const
+       from Blender import *
+       
+       ob = Object.Get('Armature')
+       pose = ob.getPose()
+       for bonename in pose.bones.keys():
+               bone = pose.bones[bonename]
+               for const in bone.constraints:
+                       print bone.name,'=>',const
 
 @type Type: readonly dictionary
 @var Type: Constant Constraint dict used by L{Constraints.append()} and 
-  for comparison with L{Constraint.type}.  Values are
-  TRACKTO, IKSOLVER, FOLLOWPATH, COPYROT, COPYLOC, COPYSIZE, ACTION,
-  LOCKTRACK, STRETCHTO, FLOOR, LIMITLOC, LIMITROT, LIMITSIZE, NULL
+       for comparison with L{Constraint.type}.  Values are
+       TRACKTO, IKSOLVER, FOLLOWPATH, COPYROT, COPYLOC, COPYSIZE, ACTION,
+       LOCKTRACK, STRETCHTO, FLOOR, LIMITLOC, LIMITROT, LIMITSIZE, NULL
 
 @type Settings: readonly dictionary
 @var Settings: Constant dict used for changing constraint settings.
-  - Used for all constraints
-    - TARGET (Object) (Note: not used by Limit Location (LIMITLOC), 
-      Limit Rotation (LIMITROT), Limit Scale (LIMITSIZE))
-    - BONE (string): name of Bone sub-target (for armature targets) (Note: not
-      used by Stretch To (STRETCHTO), Limit Location (LIMITLOC), Limit Rotation 
-      (LIMITROT), Limit Scale (LIMITSIZE))
-  - Used by IK Solver (IKSOLVER) constraint:
-    - TOLERANCE (float): clamped to [0.0001:1.0]
-    - ITERATIONS (int): clamped to [1,10000]
-    - CHAINLEN (int): clamped to [0,255]
-    - POSWEIGHT (float): clamped to [0.01,1.0]
-    - ROTWEIGHT (float): clamped to [0.01,1.0]
-    - ROTATE (bool)
-    - USETIP (bool)
-  - Used by Action (ACTION) constraint:
-    - ACTION (Action Object)
-    - LOCAL (bool)
-    - START (int): clamped to [1,maxframe]
-    - END (int): clamped to [1,maxframe]
-    - MIN (float): clamped to [-180.0,180.0]
-    - MAX (float): clamped to [-180.0,180.0]
-    - KEYON (int): values are XROT, YROT, ZROT
-  - Used by Track To (TRACKTO) constraint:
-    - TRACK (int): values are TRACKX, TRACKY, TRACKZ, TRACKNEGX,
-      TRACKNEGY, TRACKNEGZ
-    - UP (int): values are UPX, UPY, UPZ
-  - Used by Stretch To (STRETCHTO) constraint:
-    - RESTLENGTH (float): clamped to [0.0:100.0]
-    - VOLVARIATION (float): clamped to [0.0:100.0]
-    - VOLUMEMODE (int): values are VOLUMEXZ, VOLUMEX, VOLUMEZ,
-      VOLUMENONE
-    - PLANE (int): values are PLANEX, PLANEZ
-  - Used by Follow Path (FOLLOWPATH) constraint:
-    - FOLLOW (bool)
-    - OFFSET (float): clamped to [-maxframe:maxframe]
-    - FORWARD (int): values are TRACKX, TRACKY, TRACKZ, TRACKNEGX,
-      TRACKNEGY, TRACKNEGZ
-    - UP (int): values are UPX, UPY, UPZ
-  - Used by Lock Track (FOLLOWPATH) constraint:
-    - TRACK (int): values are TRACKX, TRACKY, TRACKZ, TRACKNEGX,
-      TRACKNEGY, TRACKNEGZ
-    - LOCK (int): values are LOCKX, LOCKY, LOCKZ
-  - Used by Floor (FLOOR) constraint:
-    - MINMAX (int): values are MINX, MINY, MINZ, MAXX, MAXY, MAXZ
-    - OFFSET (float): clamped to [-100.0,100.0]
-    - STICKY (bool)
-  - Used by Copy Location (COPYLOC) and Copy Rotation (COPYROT)
-    - COPY (bitfield): any combination of COPYX, COPYY and COPYZ
-    - LOCAL (bool): Only for constraints which Armature targets.
-  - Used by Copy Size (COPYSIZE) constraint:
-    - COPY (bitfield): any combination of COPYX, COPYY and COPYZ
-  - Used by Limit Location (LIMITLOC) constraint:
-    - LIMIT (bitfield): any combination of LIMIT_XMIN, LIMIT_XMAX,
-      LIMIT_YMIN, LIMIT_YMAX, LIMIT_ZMIN, LIMIT_ZMAX
-    - LIMIT_LOCAL_BONE (boolean): USE WITH CAUTION. Only do something
-      with this value if constraint is assigned to a bone.
-    - LIMIT_LOCAL_NOPARENT (boolean): USE WITH CAUTION. Only do something
-      with this value if constraint is assigned to an object with that 
-      has been parented to something.
-    - XMIN (float): clamped to [-1000.0,1000.0]
-    - XMAX (float): clamped to [-1000.0,1000.0]
-    - YMIN (float): clamped to [-1000.0,1000.0]
-    - YMAX (float): clamped to [-1000.0,1000.0]
-    - ZMIN (float): clamped to [-1000.0,1000.0]
-    - ZMAX (float): clamped to [-1000.0,1000.0]
-  - Used by Limit Rotation (LIMITROT) constraint:
-    - LIMIT (bitfield): any combination of LIMIT_XROT, LIMIT_YROT, 
-      LIMIT_ZROT
-    - LIMIT_LOCAL_BONE (boolean): USE WITH CAUTION. Only do something
-      with this value if constraint is assigned to a bone.
-    - XMIN (float): clamped to [-360.0,360.0]
-    - XMAX (float): clamped to [-360.0,360.0]
-    - YMIN (float): clamped to [-360.0,360.0]
-    - YMAX (float): clamped to [-360.0,360.0]
-    - ZMIN (float): clamped to [-360.0,360.0]
-    - ZMAX (float): clamped to [-360.0,360.0]
-  - Used by Limit Scale (LIMITSIZE) constraint:
-    - LIMIT (bitfield): any combination of LIMIT_XMIN, LIMIT_XMAX,
-      LIMIT_YMIN, LIMIT_YMAX, LIMIT_ZMIN, LIMIT_ZMAX
-    - XMIN (float): clamped to [-1000.0,1000.0]
-    - XMAX (float): clamped to [-1000.0,1000.0]
-    - YMIN (float): clamped to [-1000.0,1000.0]
-    - YMAX (float): clamped to [-1000.0,1000.0]
-    - ZMIN (float): clamped to [-1000.0,1000.0]
-    - ZMAX (float): clamped to [-1000.0,1000.0]
+       - Used for all constraints
+               - TARGET (Object) (Note: not used by Limit Location (LIMITLOC), 
+                       Limit Rotation (LIMITROT), Limit Scale (LIMITSIZE))
+               - BONE (string): name of Bone sub-target (for armature targets) (Note: not
+                       used by Stretch To (STRETCHTO), Limit Location (LIMITLOC), Limit Rotation 
+                       (LIMITROT), Limit Scale (LIMITSIZE))
+       - Used by IK Solver (IKSOLVER) constraint:
+               - TOLERANCE (float): clamped to [0.0001:1.0]
+               - ITERATIONS (int): clamped to [1,10000]
+               - CHAINLEN (int): clamped to [0,255]
+               - POSWEIGHT (float): clamped to [0.01,1.0]
+               - ROTWEIGHT (float): clamped to [0.01,1.0]
+               - ROTATE (bool)
+               - USETIP (bool)
+       - Used by Action (ACTION) constraint:
+               - ACTION (Action Object)
+               - LOCAL (bool)
+               - START (int): clamped to [1,maxframe]
+               - END (int): clamped to [1,maxframe]
+               - MIN (float): clamped to [-180.0,180.0]
+               - MAX (float): clamped to [-180.0,180.0]
+               - KEYON (int): values are XROT, YROT, ZROT
+       - Used by Track To (TRACKTO) constraint:
+               - TRACK (int): values are TRACKX, TRACKY, TRACKZ, TRACKNEGX,
+                       TRACKNEGY, TRACKNEGZ
+               - UP (int): values are UPX, UPY, UPZ
+       - Used by Stretch To (STRETCHTO) constraint:
+               - RESTLENGTH (float): clamped to [0.0:100.0]
+               - VOLVARIATION (float): clamped to [0.0:100.0]
+               - VOLUMEMODE (int): values are VOLUMEXZ, VOLUMEX, VOLUMEZ,
+                       VOLUMENONE
+               - PLANE (int): values are PLANEX, PLANEZ
+       - Used by Follow Path (FOLLOWPATH) constraint:
+               - FOLLOW (bool)
+               - OFFSET (float): clamped to [-maxframe:maxframe]
+               - FORWARD (int): values are TRACKX, TRACKY, TRACKZ, TRACKNEGX,
+                       TRACKNEGY, TRACKNEGZ
+               - UP (int): values are UPX, UPY, UPZ
+       - Used by Lock Track (FOLLOWPATH) constraint:
+               - TRACK (int): values are TRACKX, TRACKY, TRACKZ, TRACKNEGX,
+                       TRACKNEGY, TRACKNEGZ
+               - LOCK (int): values are LOCKX, LOCKY, LOCKZ
+       - Used by Floor (FLOOR) constraint:
+               - MINMAX (int): values are MINX, MINY, MINZ, MAXX, MAXY, MAXZ
+               - OFFSET (float): clamped to [-100.0,100.0]
+               - STICKY (bool)
+       - Used by Copy Location (COPYLOC) and Copy Rotation (COPYROT)
+               - COPY (bitfield): any combination of COPYX, COPYY and COPYZ
+               - LOCAL (bool): Only for constraints which Armature targets.
+       - Used by Copy Size (COPYSIZE) constraint:
+               - COPY (bitfield): any combination of COPYX, COPYY and COPYZ
+       - Used by Limit Location (LIMITLOC) constraint:
+               - LIMIT (bitfield): any combination of LIMIT_XMIN, LIMIT_XMAX,
+                       LIMIT_YMIN, LIMIT_YMAX, LIMIT_ZMIN, LIMIT_ZMAX
+               - LIMIT_LOCAL_BONE (boolean): USE WITH CAUTION. Only do something
+                       with this value if constraint is assigned to a bone.
+               - LIMIT_LOCAL_NOPARENT (boolean): USE WITH CAUTION. Only do something
+                       with this value if constraint is assigned to an object with that 
+                       has been parented to something.
+               - XMIN (float): clamped to [-1000.0,1000.0]
+               - XMAX (float): clamped to [-1000.0,1000.0]
+               - YMIN (float): clamped to [-1000.0,1000.0]
+               - YMAX (float): clamped to [-1000.0,1000.0]
+               - ZMIN (float): clamped to [-1000.0,1000.0]
+               - ZMAX (float): clamped to [-1000.0,1000.0]
+       - Used by Limit Rotation (LIMITROT) constraint:
+               - LIMIT (bitfield): any combination of LIMIT_XROT, LIMIT_YROT, 
+                       LIMIT_ZROT
+               - LIMIT_LOCAL_BONE (boolean): USE WITH CAUTION. Only do something
+                       with this value if constraint is assigned to a bone.
+               - XMIN (float): clamped to [-360.0,360.0]
+               - XMAX (float): clamped to [-360.0,360.0]
+               - YMIN (float): clamped to [-360.0,360.0]
+               - YMAX (float): clamped to [-360.0,360.0]
+               - ZMIN (float): clamped to [-360.0,360.0]
+               - ZMAX (float): clamped to [-360.0,360.0]
+       - Used by Limit Scale (LIMITSIZE) constraint:
+               - LIMIT (bitfield): any combination of LIMIT_XMIN, LIMIT_XMAX,
+                       LIMIT_YMIN, LIMIT_YMAX, LIMIT_ZMIN, LIMIT_ZMAX
+               - XMIN (float): clamped to [-1000.0,1000.0]
+               - XMAX (float): clamped to [-1000.0,1000.0]
+               - YMIN (float): clamped to [-1000.0,1000.0]
+               - YMAX (float): clamped to [-1000.0,1000.0]
+               - ZMIN (float): clamped to [-1000.0,1000.0]
+               - ZMAX (float): clamped to [-1000.0,1000.0]
 
 """
 
 class Constraints:
-  """
-  The Constraints object
-  ======================
-  This object provides access to sequence of
-  L{constraints<Constraint.Constraint>} for a particular object.
-  They can be accessed from L{Object.constraints<Object.Object.constraints>}.
-  or L{PoseBone.constraints<Pose.PoseBone.constraints>}.
-  """
-
-  def __getitem__(index):
-    """
-    This operator returns one of the constraints in the stack.
-    @type index: int
-    @return: an Constraint object
-    @rtype: Constraint
-    @raise KeyError: index was out of range
-    """
-
-  def __len__():
-    """
-    Returns the number of constraints in the constraint stack.
-    @return: number of Constraints
-    @rtype: int
-    """
-
-  def append(type):
-    """
-    Appends a new constraint to the end of the constraint stack.
-    @param type: a constant specifying the type of constraint to create. as from L{Type}
-    @type type: int constant
-    @rtype: Constraint
-    @return: the new Constraint
-    """
-
-  def remove(con):
-    """
-    Remove a constraint from this objects constraint sequence.
-    @param con: a constraint from this sequence to remove.
-    @type con: Constraint
-    @note: Accessing attributes of the constraint after it is removed will 
-    throw an exception.
-    """
-
-  def moveUp(con):
-    """
-    Moves the constraint up in the object's constraint stack.
-    @param con: a constraint from this sequence to remove.
-    @type con: Constraint
-    @rtype: None
-    """
-
-  def moveDown(con):
-    """
-    Moves the constraint down in the object's constraint stack.
-    @param con: a constraint from this sequence to remove.
-    @type con: Constraint
-    @rtype: None
-    """
+       """
+       The Constraints object
+       ======================
+       This object provides access to sequence of
+       L{constraints<Constraint.Constraint>} for a particular object.
+       They can be accessed from L{Object.constraints<Object.Object.constraints>}.
+       or L{PoseBone.constraints<Pose.PoseBone.constraints>}.
+       """
+
+       def __getitem__(index):
+               """
+               This operator returns one of the constraints in the stack.
+               @type index: int
+               @return: an Constraint object
+               @rtype: Constraint
+               @raise KeyError: index was out of range
+               """
+
+       def __len__():
+               """
+               Returns the number of constraints in the constraint stack.
+               @return: number of Constraints
+               @rtype: int
+               """
+
+       def append(type):
+               """
+               Appends a new constraint to the end of the constraint stack.
+               @param type: a constant specifying the type of constraint to create. as from L{Type}
+               @type type: int constant
+               @rtype: Constraint
+               @return: the new Constraint
+               """
+
+       def remove(con):
+               """
+               Remove a constraint from this objects constraint sequence.
+               @param con: a constraint from this sequence to remove.
+               @type con: Constraint
+               @note: Accessing attributes of the constraint after it is removed will 
+               throw an exception.
+               """
+
+       def moveUp(con):
+               """
+               Moves the constraint up in the object's constraint stack.
+               @param con: a constraint from this sequence to remove.
+               @type con: Constraint
+               @rtype: None
+               """
+
+       def moveDown(con):
+               """
+               Moves the constraint down in the object's constraint stack.
+               @param con: a constraint from this sequence to remove.
+               @type con: Constraint
+               @rtype: None
+               """
 
 class Constraint:
-  """
-  The Constraint object
-  =====================
-  This object provides access to a constraint for a particular object
-  accessed from L{Constraints}.
-  @ivar name: The name of this constraint. 29 chars max.
-  @type name: string
-  @ivar type: The type of this constraint. Read-only.  The returned value
-  matches the types in L{Type}.
-  @type type: int
-  @ivar influence: The influence value of the constraint.  Valid values
-  are in the range [0.0,1.0].
-  @type influence: float
-  """
-
-  def __getitem__(key):
-    """
-    This operator returns one of the constraint's data attributes.
-    @param key: value from constraint's L{Constraint.Settings} constant
-    @type key: int constant
-    @return: the requested data
-    @rtype: varies
-    @raise KeyError: the key does not exist for the constraint
-    """
-
-  def __setitem__(key):
-    """
-    This operator changes one of the constraint's data attributes.
-    @param key: value from constraint's L{Constraint.Settings} constant
-    @type key: int constant
-    @raise KeyError: the key does not exist for the constraint
-    """
-
-  def insertKey(frame):
-    """
-    Adds an influence keyframe for the constraint Ipo.  
-    @rtype: None
-    @param frame: the frame number at which to insert the key.
-    @type frame: float
-    """
+       """
+       The Constraint object
+       =====================
+       This object provides access to a constraint for a particular object
+       accessed from L{Constraints}.
+       @ivar name: The name of this constraint. 29 chars max.
+       @type name: string
+       @ivar type: The type of this constraint. Read-only.  The returned value
+       matches the types in L{Type}.
+       @type type: int
+       @ivar influence: The influence value of the constraint.  Valid values
+       are in the range [0.0,1.0].
+       @type influence: float
+       """
+
+       def __getitem__(key):
+               """
+               This operator returns one of the constraint's data attributes.
+               @param key: value from constraint's L{Constraint.Settings} constant
+               @type key: int constant
+               @return: the requested data
+               @rtype: varies
+               @raise KeyError: the key does not exist for the constraint
+               """
+
+       def __setitem__(key):
+               """
+               This operator changes one of the constraint's data attributes.
+               @param key: value from constraint's L{Constraint.Settings} constant
+               @type key: int constant
+               @raise KeyError: the key does not exist for the constraint
+               """
+
+       def insertKey(frame):
+               """
+               Adds an influence keyframe for the constraint Ipo.  
+               @rtype: None
+               @param frame: the frame number at which to insert the key.
+               @type frame: float
+               """
index cc1b1647d50a1842c189ce60fb4306e087cade1e..84996d47380931956eed25d9185f7c393582d68f 100644 (file)
@@ -20,694 +20,694 @@ Python B{for} statement.
 
 
 Add a Curve to a Scene Example::
-  from Blender import Curve, Object, Scene
-  cu = Curve.New()             # create new  curve data
-  scn = Scene.GetCurrent()    # get current scene
-  ob = scn.objects.new(cu)     # make a new curve from the curve data
+       from Blender import Curve, Object, Scene
+       cu = Curve.New()             # create new  curve data
+       scn = Scene.GetCurrent()    # get current scene
+       ob = scn.objects.new(cu)     # make a new curve from the curve data
 
 Iterator Example::
-  from Blender import Curve, Object, Scene
-  scn = Scene.GetCurrent()    # get current scene
-  ob = scn.objects.active
-  curvedata = ob.data
-  for curnurb in curvedata:
-    print type( curnurb ), curnurb
-    for point in curnurb:
-      print type( point ), point
+       from Blender import Curve, Object, Scene
+       scn = Scene.GetCurrent()    # get current scene
+       ob = scn.objects.active
+       curvedata = ob.data
+       for curnurb in curvedata:
+               print type( curnurb ), curnurb
+               for point in curnurb:
+                       print type( point ), point
 
 Creating a Curve from a list of Vec triples Examples::
-  from Blender import *
-  def bezList2Curve(bezier_vecs):
-    '''
-    Take a list or vector triples and converts them into a bezier curve object
-    '''
-    
-    def bezFromVecs(vecs):
-       '''
-       Bezier triple from 3 vecs, shortcut functon
-       '''
-       bt= BezTriple.New(\
-       vecs[0].x, vecs[0].y, vecs[0].z,\
-       vecs[1].x, vecs[1].y, vecs[1].z,\
-       vecs[2].x, vecs[2].y, vecs[2].z)
-       
-       bt.handleTypes= (BezTriple.HandleTypes.FREE, BezTriple.HandleTypes.FREE)
-       
-       return bt
-    
-    # Create the curve data with one point
-    cu= Curve.New()
-    cu.appendNurb(bezFromVecs(bezier_vecs[0])) # We must add with a point to start with
-    cu_nurb= cu[0] # Get the first curve just added in the CurveData
-    
-    
-    i= 1 # skip first vec triple because it was used to init the curve
-    while i<len(bezier_vecs):
-       bt_vec_triple= bezier_vecs[i]
-       bt= bezFromVecs(bt_vec_triple)
-       cu_nurb.append(bt)
-       i+=1
-    
-    # Add the Curve into the scene
-    scn= Scene.GetCurrent()
-    ob = scn.objects.new(cu)
-       return ob
+       from Blender import *
+       def bezList2Curve(bezier_vecs):
+               '''
+               Take a list or vector triples and converts them into a bezier curve object
+               '''
+               
+               def bezFromVecs(vecs):
+                       '''
+                       Bezier triple from 3 vecs, shortcut functon
+                       '''
+                       bt= BezTriple.New(\
+                       vecs[0].x, vecs[0].y, vecs[0].z,\
+                       vecs[1].x, vecs[1].y, vecs[1].z,\
+                       vecs[2].x, vecs[2].y, vecs[2].z)
+                       
+                       bt.handleTypes= (BezTriple.HandleTypes.FREE, BezTriple.HandleTypes.FREE)
+                       
+                       return bt
+               
+               # Create the curve data with one point
+               cu= Curve.New()
+               cu.appendNurb(bezFromVecs(bezier_vecs[0])) # We must add with a point to start with
+               cu_nurb= cu[0] # Get the first curve just added in the CurveData
+               
+               
+               i= 1 # skip first vec triple because it was used to init the curve
+               while i<len(bezier_vecs):
+                       bt_vec_triple= bezier_vecs[i]
+                       bt= bezFromVecs(bt_vec_triple)
+                       cu_nurb.append(bt)
+                       i+=1
+               
+               # Add the Curve into the scene
+               scn= Scene.GetCurrent()
+               ob = scn.objects.new(cu)
+               return ob
 """
 
 def New ( name):
-    """
-  Create a new Curve Data object.
-  @type name: string
-  @param name: The Curve Data name.
-  @rtype: Blender Curve
-  @return: The created Curve Data object.
-  """
+               """
+       Create a new Curve Data object.
+       @type name: string
+       @param name: The Curve Data name.
+       @rtype: Blender Curve
+       @return: The created Curve Data object.
+       """
 
 def Get (name = None):
-  """
-  Get the Curve Data object(s) from Blender.
-  @type name: string
-  @param name: The name of the Curve Data.
-  @rtype: Blender Curve or a list of Blender Curves
-  @return: It depends on the 'name' parameter:
-        - (name): The Curve Data object with the given name;
-        - ():     A list with all Curve Data objects in the current scene.
-  """
+       """
+       Get the Curve Data object(s) from Blender.
+       @type name: string
+       @param name: The name of the Curve Data.
+       @rtype: Blender Curve or a list of Blender Curves
+       @return: It depends on the 'name' parameter:
+                               - (name): The Curve Data object with the given name;
+                               - ():     A list with all Curve Data objects in the current scene.
+       """
 
 class Curve:
-  """
-  The Curve Data object
-  =====================
-  This object gives access to Curve and Surface data linked from Blender Objects.
-  
-  @ivar name: The Curve Data name.
-  @type name: string
-  @ivar pathlen: The Curve Data path length, used to set the number of frames for an animation (not the physical length).
-  @type pathlen: int
-  @ivar totcol: The Curve Data maximal number of linked materials. Read-only.
-  @type totcol: int
-  @ivar flag: The Curve Data flag value; see L{getFlag()} for the semantics.
-  @ivar bevresol: The Curve Data bevel resolution. [0 - 32]
-  @type bevresol: int
-  @ivar resolu: The Curve Data U-resolution (used for curve and surface resolution) [0 - 1024].
-  @type resolu: int
-  @ivar resolv: The Curve Data V-resolution (used for surface resolution) [0 - 1024].
-  @type resolv: int
-  @ivar width: The Curve Data width [0 - 2].
-  @type width: float
-  @ivar ext1: The Curve Data extent1 (for bevels).
-  @type ext1: float
-  @ivar ext2: The Curve Data extent2 (for bevels).
-  @type ext2: float
-  @ivar loc: The Curve Data location(from the center).
-  @type loc: list of 3 floats
-  @ivar rot: The Curve Data rotation(from the center).
-  @type rot: list of 3 floats
-  @ivar size: The Curve Data size(from the center).
-  @type size: list of 3 floats
-  @ivar bevob: The Curve Bevel Object
-  @type bevob: Blender L{Object<Object.Object>} or None
-  @ivar key: The Key object associated with this Curve, if any.
-  @type key: Blender L{Key<Key.Key>}
-  @ivar materials: The curves's materials.  Each curve can reference up to
-    16 materials.  Empty slots in the curve's list are represented by B{None}.
-    B{Note}: L{Object.colbits<Object.Object.colbits>} needs to be set correctly
-    for each object in order for these materials to be used instead of
-    the object's materials.
-    B{Note}: The list that's returned is I{not} linked to the original curve.
-    curve.materials.append(material) won't do anything.
-    Use curve.materials += [material] instead.
-  @type materials: list of L{Material}s
-  """
-
-  def getName():
-    """
-    Get the name of this Curve Data object.
-    @rtype: string
-    """
-
-  def setName(name):
-    """
-    Set the name of this Curve Data object.
-    @rtype: None
-    @type name: string
-    @param name: The new name.
-    """
-
-  def getPathLen():
-    """
-    Get this Curve's path frame length, used for an animated path.
-    @rtype: int
-    @return: the path length.
-    """
-
-  def setPathLen(len):
-    """
-    Set this Curve's path length.
-    @rtype: None
-    @type len: int
-    @param len: the new curve's length.
-    """
-
-  def getTotcol():
-    """
-    Get the number of materials linked to the Curve.
-    @rtype: int
-    @return: number of materials linked.
-    """
-
-  def setTotcol(totcol):
-    """
-    Set the number of materials linked to the Curve.  B{Note}: this method
-    will probably be deprecated in the future.
-    @rtype: None
-    @type totcol: int
-    @param totcol: number of materials linked.
-    @warn: It is not advisable to use this method unless you know what you
-    are doing; it's possible to
-    corrupt a .blend file if you don't know what you're doing.  If you want
-    to change the number of materials, use the L{materials} attribute.
-    """
-
-  def getFlag():
-    """
-    Get the Curve flag value.   
-    This item is a bitfield whose value is a combination of the following parameters.
-       - Bit 0 :  "3D" is set
-       - Bit 1 :  "Front" is set
-       - Bit 2 :  "Back" is set
-       - Bit 3 :  "CurvePath" is set.
-       - Bit 4 :  "CurveFollow" is set.
-      
-    @rtype: integer bitfield
-    """
-
-  def setFlag(val):
-    """
-    Set the Curve flag value.  The flag corresponds to the Blender settings for 3D, Front, Back, CurvePath and CurveFollow.  This parameter is a bitfield.
-    @rtype: None
-    @type val: integer bitfield
-    @param val : The Curve's flag bits.  See L{getFlag} for the meaning of the individual bits.
-    """
-
-  def getBevresol():
-    """
-    Get the Curve's bevel resolution value.
-    @rtype: float
-    """
-
-  def setBevresol(bevelresol):
-    """
-    Set the Curve's bevel resolution value.
-    @rtype: None
-    @type bevelresol: float
-    @param bevelresol: The new Curve's bevel resolution value.
-    """
-
-  def getResolu():
-    """
-    Get the Curve's U-resolution value.
-    @rtype: float
-    """
-
-  def setResolu(resolu):
-    """
-    Set the Curve's U-resolution value. [0 - 1024]
-    This is used for surfaces and curves.
-    @rtype: None
-    @type resolu: float
-    @param resolu: The new Curve's U-resolution value.
-    """
-
-  def getResolv():
-    """
-    Get the Curve's V-resolution value.
-    @rtype: float
-    """
-
-  def setResolv(resolv):
-    """
-    Set the Curve's V-resolution value. [0 - 1024].
-    This is used for surfaces only.
-    @rtype: None
-    @type resolv: float
-    @param resolv: The new Curve's V-resolution value.
-    """
-
-  def getWidth():
-    """
-    Get the Curve's width value.
-    @rtype: float
-    """
-
-  def setWidth(width):
-    """
-    Set the Curve's width value. 
-    @rtype: None
-    @type width: float
-    @param width: The new Curve's width value. 
-    """
-
-  def getExt1():
-    """
-    Get the Curve's ext1 value.
-    @rtype: float
-    """
-
-  def setExt1(ext1):
-    """
-    Set the Curve's ext1 value. 
-    @rtype: None
-    @type ext1: float
-    @param ext1: The new Curve's ext1 value. 
-    """
-
-  def getExt2():
-    """
-    Get the Curve's ext2 value.
-    @rtype: float
-    """
-
-  def setExt2(ext2):
-    """
-    Set the Curve's ext2 value.
-    @rtype: None 
-    @type ext2: float
-    @param ext2: The new Curve's ext2 value. 
-    """
-
-  def getControlPoint(numcurve,numpoint):
-    """
-    Get the curve's control point value (B{deprecated}).  The numpoint arg
-    is an index into the list of points and starts with 0.  B{Note}: new
-    scripts should use the [] operator on Curves and CurNurbs.  Example::
-      curve = Blender.Curve.Get('Curve')
-      p0 = curve[0][0]    # get first point from first nurb
-             # -- OR --
-      nurb = curve[0]     # get first nurb
-      p0 = nurb[0]        # get nurb's first point
-
-    @type numcurve: int
-    @type numpoint: int
-    @rtype: list of floats
-    @return: depends upon the curve's type.
-      - type Bezier : a list of nine floats.  Values are x, y, z for handle-1, vertex and handle-2 
-      - type Nurb : a list of 4 floats.  Values are x, y, z, w.
-
-    """
-
-  def setControlPoint( numcurve, numpoint, controlpoint):
-    """
-    Set the Curve's controlpoint value.   The numpoint arg is an index into the list of points and starts with 0.
-    @rtype: None
-    @type numcurve: int
-    @type numpoint: int
-    @type controlpoint: list
-    @param numcurve: index for spline in Curve, starting from 0
-    @param numpoint: index for point in spline, starting from 0
-    @param controlpoint: The new controlpoint value.
-    See L{getControlPoint} for the length of the list.
-    """
-
-  def appendPoint( numcurve, new_control_point ):
-    """
-      Add a new control point to the indicated curve (B{deprecated}).
-      New scripts should use L{CurNurb.append()}.
-      @rtype: None
-      @type numcurve: int
-      @type new_control_point: list of floats or BezTriple
-      @param numcurve:  index for spline in Curve, starting from 0
-      @param new_control_point: depends on curve's type.
-        - type Bezier: a BezTriple 
-        - type Nurb: a list of four or five floats for the xyzw values
-      @raise AttributeError:  throws exception if numcurve is out of range.
-    """
-
-  def appendNurb( new_point ):
-      """
-      add a new curve to this Curve.  The new point is added to the new curve.  Blender does not support a curve with zero points.  The new curve is added to the end of the list of curves in the Curve.
-      @rtype: CurNurb
-      @return: the newly added spline
-      @type new_point: BezTriple or list of xyzw coordinates for a Nurb curve.
-      @param new_point: see L{CurNurb.append} for description of parameter.
-      """
-
-  def getLoc():
-    """
-    Get the curve's location value.
-    @rtype: a list of 3 floats.
-    """
-
-  def setLoc(location):
-    """
-    Set the curve's location value.
-    @rtype: None 
-    @type location: list[3]
-    @param location: The new Curve's location values. 
-    """
-
-  def getRot():
-    """
-    Get the curve's rotation value.
-    @rtype: a list of 3 floats.
-    """
-
-  def setRot(rotation):
-    """
-    Set the Curve's rotation value. 
-    @rtype: None
-    @type rotation: list[3]
-    @param rotation: The new Curve's rotation values. 
-    """
-
-  def getSize():
-    """
-    Get the curve's size value.
-    @rtype: a list of 3 floats.
-    """
-
-  def setSize(size):
-    """
-    Set the curve size value.
-    @rtype: None 
-    @type size: list[3]
-    @param size: The new Curve's size values. 
-    """
-
-  def getMaterials():
-    """
-    Returns a list of materials assigned to the Curve.
-    @rtype: list of Material Objects
-    @return: list of Material Objects assigned to the Curve.
-    """
-
-  def getBevOb():
-    """
-    Returns the Bevel Object (BevOb) assigned to the Curve.
-    @rtype: Blender Object or None
-    @return: Bevel Object (BevOb) assigned to the Curve.
-    """
-
-  def setBevOb( object ):
-    """
-    Assign a Bevel Object (BevOb) to the Curve.  Passing None as the object parameter removes the bevel.
-    @rtype: None
-    @return: None
-    @type object: Curve type Blender Object
-    @param object: Blender Object to assign as Bevel Object (BevOb)
-    @raise TypeError: throws exception if the parameter is not a Curve type Blender Object or None
-    """
-
-  def getTaperOb():
-    """
-    Returns the Taper Object (TaperOb) assigned to the Curve.
-    @rtype: Blender Object or None
-    @return: Taper Object (TaperOb) assigned to the Curve.
-    """
-
-  def setTaperOb( object ):
-    """
-    Assign a Taper Object (TaperOb) to the Curve.  Passing None as the object parameter removes the taper.
-    @rtype: None
-    @return: None
-    @type object: Curve type Blender Object
-    @param object: Blender Object to assign as Taper Object (TaperOb)
-    @raise TypeError: throws exception if the parameter is not a Curve type Blender Object or None
-    """
-
-  def update():
-    """
-    Updates display list for a Curve.
-    Used after making changes to control points.
-    You B{must} use this if you want to see your changes!
-    @rtype: None
-    @return: None
-    """
-
-  def isNurb( curve_num ):
-      """
-      Tells type of a CurNurb (B{deprecated}).
-      New scripts should use L{CurNurb.isNurb()}.
-
-      @rtype: integer
-      @return:  Zero if curve is type Bezier, one if curve is of type Nurb.
-      @type curve_num: integer
-      @param curve_num: zero-based index into list of curves in this Curve.
-      @raise AttributeError:  throws exception if curve_num is out of range.
-      """
-
-  def isCyclic( curve_num ):
-      """
-      Tells whether or not a CurNurb is cyclic (closed) (B{deprecated}).
-      New scripts should use L{CurNurb.isCyclic()}.
-
-      @rtype: boolean
-      @return: True if is cyclic, False if not
-      @type curve_num: integer
-      @param curve_num: zero-based index into list of curves in this Curve
-      @raise AttributeError:  throws exception if curve_num is out of range.
-      """
-
-  def switchDirection( ):
-      """
-      Reverse the direction of a curve.
-      @return: None
-
-      I{B{Example:}}
-      # This example switches the direction of all curves on the active object.
-      from Blender import *
-      scn = Scene.GetCurrent()
-      ob = scn.objects.active # must be a curve
-      data = ob.data
-      for cu in data: cu.switchDirection()
-      """
-
-  def getNumCurves():
-      """
-      Get the number of curves in this Curve Data object.
-      @rtype: integer
-      """
-
-  def getNumPoints( curve_num ):
-      """
-      Get the number of control points in the curve (B{deprecated}).
-      New scripts should use the len operator (I{len(curve)}).
-      @type curve_num: integer
-      @param curve_num: zero-based index into list of curves in this Curve
-      @rtype: integer
-      """
-
-  def getKey():
-      """
-      Return the L{Key<Key.Key>} object containing the keyframes for this
-      curve, if any.
-      @rtype: L{Key<Key.Key>} object or None
-      """
-
-  def recalc():
-      """
-      Recalculate control point handles after a curve has been changed.
-      @rtype: None
-      """
-
-  def __copy__ ():
-    """
-    Make a copy of this curve
-    @rtype: Curve
-    @return:  a copy of this curve
-    """
+       """
+       The Curve Data object
+       =====================
+       This object gives access to Curve and Surface data linked from Blender Objects.
+       
+       @ivar name: The Curve Data name.
+       @type name: string
+       @ivar pathlen: The Curve Data path length, used to set the number of frames for an animation (not the physical length).
+       @type pathlen: int
+       @ivar totcol: The Curve Data maximal number of linked materials. Read-only.
+       @type totcol: int
+       @ivar flag: The Curve Data flag value; see L{getFlag()} for the semantics.
+       @ivar bevresol: The Curve Data bevel resolution. [0 - 32]
+       @type bevresol: int
+       @ivar resolu: The Curve Data U-resolution (used for curve and surface resolution) [0 - 1024].
+       @type resolu: int
+       @ivar resolv: The Curve Data V-resolution (used for surface resolution) [0 - 1024].
+       @type resolv: int
+       @ivar width: The Curve Data width [0 - 2].
+       @type width: float
+       @ivar ext1: The Curve Data extent1 (for bevels).
+       @type ext1: float
+       @ivar ext2: The Curve Data extent2 (for bevels).
+       @type ext2: float
+       @ivar loc: The Curve Data location(from the center).
+       @type loc: list of 3 floats
+       @ivar rot: The Curve Data rotation(from the center).
+       @type rot: list of 3 floats
+       @ivar size: The Curve Data size(from the center).
+       @type size: list of 3 floats
+       @ivar bevob: The Curve Bevel Object
+       @type bevob: Blender L{Object<Object.Object>} or None
+       @ivar key: The Key object associated with this Curve, if any.
+       @type key: Blender L{Key<Key.Key>}
+       @ivar materials: The curves's materials.  Each curve can reference up to
+               16 materials.  Empty slots in the curve's list are represented by B{None}.
+               B{Note}: L{Object.colbits<Object.Object.colbits>} needs to be set correctly
+               for each object in order for these materials to be used instead of
+               the object's materials.
+               B{Note}: The list that's returned is I{not} linked to the original curve.
+               curve.materials.append(material) won't do anything.
+               Use curve.materials += [material] instead.
+       @type materials: list of L{Material}s
+       """
+
+       def getName():
+               """
+               Get the name of this Curve Data object.
+               @rtype: string
+               """
+
+       def setName(name):
+               """
+               Set the name of this Curve Data object.
+               @rtype: None
+               @type name: string
+               @param name: The new name.
+               """
+
+       def getPathLen():
+               """
+               Get this Curve's path frame length, used for an animated path.
+               @rtype: int
+               @return: the path length.
+               """
+
+       def setPathLen(len):
+               """
+               Set this Curve's path length.
+               @rtype: None
+               @type len: int
+               @param len: the new curve's length.
+               """
+
+       def getTotcol():
+               """
+               Get the number of materials linked to the Curve.
+               @rtype: int
+               @return: number of materials linked.
+               """
+
+       def setTotcol(totcol):
+               """
+               Set the number of materials linked to the Curve.  B{Note}: this method
+               will probably be deprecated in the future.
+               @rtype: None
+               @type totcol: int
+               @param totcol: number of materials linked.
+               @warn: It is not advisable to use this method unless you know what you
+               are doing; it's possible to
+               corrupt a .blend file if you don't know what you're doing.  If you want
+               to change the number of materials, use the L{materials} attribute.
+               """
+
+       def getFlag():
+               """
+               Get the Curve flag value.   
+               This item is a bitfield whose value is a combination of the following parameters.
+                       - Bit 0 :  "3D" is set
+                       - Bit 1 :  "Front" is set
+                       - Bit 2 :  "Back" is set
+                       - Bit 3 :  "CurvePath" is set.
+                       - Bit 4 :  "CurveFollow" is set.
+                       
+               @rtype: integer bitfield
+               """
+
+       def setFlag(val):
+               """
+               Set the Curve flag value.  The flag corresponds to the Blender settings for 3D, Front, Back, CurvePath and CurveFollow.  This parameter is a bitfield.
+               @rtype: None
+               @type val: integer bitfield
+               @param val : The Curve's flag bits.  See L{getFlag} for the meaning of the individual bits.
+               """
+
+       def getBevresol():
+               """
+               Get the Curve's bevel resolution value.
+               @rtype: float
+               """
+
+       def setBevresol(bevelresol):
+               """
+               Set the Curve's bevel resolution value.
+               @rtype: None
+               @type bevelresol: float
+               @param bevelresol: The new Curve's bevel resolution value.
+               """
+
+       def getResolu():
+               """
+               Get the Curve's U-resolution value.
+               @rtype: float
+               """
+
+       def setResolu(resolu):
+               """
+               Set the Curve's U-resolution value. [0 - 1024]
+               This is used for surfaces and curves.
+               @rtype: None
+               @type resolu: float
+               @param resolu: The new Curve's U-resolution value.
+               """
+
+       def getResolv():
+               """
+               Get the Curve's V-resolution value.
+               @rtype: float
+               """
+
+       def setResolv(resolv):
+               """
+               Set the Curve's V-resolution value. [0 - 1024].
+               This is used for surfaces only.
+               @rtype: None
+               @type resolv: float
+               @param resolv: The new Curve's V-resolution value.
+               """
+
+       def getWidth():
+               """
+               Get the Curve's width value.
+               @rtype: float
+               """
+
+       def setWidth(width):
+               """
+               Set the Curve's width value. 
+               @rtype: None
+               @type width: float
+               @param width: The new Curve's width value. 
+               """
+
+       def getExt1():
+               """
+               Get the Curve's ext1 value.
+               @rtype: float
+               """
+
+       def setExt1(ext1):
+               """
+               Set the Curve's ext1 value. 
+               @rtype: None
+               @type ext1: float
+               @param ext1: The new Curve's ext1 value. 
+               """
+
+       def getExt2():
+               """
+               Get the Curve's ext2 value.
+               @rtype: float
+               """
+
+       def setExt2(ext2):
+               """
+               Set the Curve's ext2 value.
+               @rtype: None 
+               @type ext2: float
+               @param ext2: The new Curve's ext2 value. 
+               """
+
+       def getControlPoint(numcurve,numpoint):
+               """
+               Get the curve's control point value (B{deprecated}).  The numpoint arg
+               is an index into the list of points and starts with 0.  B{Note}: new
+               scripts should use the [] operator on Curves and CurNurbs.  Example::
+                       curve = Blender.Curve.Get('Curve')
+                       p0 = curve[0][0]    # get first point from first nurb
+                                               # -- OR --
+                       nurb = curve[0]     # get first nurb
+                       p0 = nurb[0]        # get nurb's first point
+
+               @type numcurve: int
+               @type numpoint: int
+               @rtype: list of floats
+               @return: depends upon the curve's type.
+                       - type Bezier : a list of nine floats.  Values are x, y, z for handle-1, vertex and handle-2 
+                       - type Nurb : a list of 4 floats.  Values are x, y, z, w.
+
+               """
+
+       def setControlPoint( numcurve, numpoint, controlpoint):
+               """
+               Set the Curve's controlpoint value.   The numpoint arg is an index into the list of points and starts with 0.
+               @rtype: None
+               @type numcurve: int
+               @type numpoint: int
+               @type controlpoint: list
+               @param numcurve: index for spline in Curve, starting from 0
+               @param numpoint: index for point in spline, starting from 0
+               @param controlpoint: The new controlpoint value.
+               See L{getControlPoint} for the length of the list.
+               """
+
+       def appendPoint( numcurve, new_control_point ):
+               """
+               Add a new control point to the indicated curve (B{deprecated}).
+               New scripts should use L{CurNurb.append()}.
+               @rtype: None
+               @type numcurve: int
+               @type new_control_point: list of floats or BezTriple
+               @param numcurve:  index for spline in Curve, starting from 0
+               @param new_control_point: depends on curve's type.
+                       - type Bezier: a BezTriple 
+                       - type Nurb: a list of four or five floats for the xyzw values
+               @raise AttributeError:  throws exception if numcurve is out of range.
+               """
+
+       def appendNurb( new_point ):
+               """
+               add a new curve to this Curve.  The new point is added to the new curve.  Blender does not support a curve with zero points.  The new curve is added to the end of the list of curves in the Curve.
+               @rtype: CurNurb
+               @return: the newly added spline
+               @type new_point: BezTriple or list of xyzw coordinates for a Nurb curve.
+               @param new_point: see L{CurNurb.append} for description of parameter.
+               """
+
+       def getLoc():
+               """
+               Get the curve's location value.
+               @rtype: a list of 3 floats.
+               """
+
+       def setLoc(location):
+               """
+               Set the curve's location value.
+               @rtype: None 
+               @type location: list[3]
+               @param location: The new Curve's location values. 
+               """
+
+       def getRot():
+               """
+               Get the curve's rotation value.
+               @rtype: a list of 3 floats.
+               """
+
+       def setRot(rotation):
+               """
+               Set the Curve's rotation value. 
+               @rtype: None
+               @type rotation: list[3]
+               @param rotation: The new Curve's rotation values. 
+               """
+
+       def getSize():
+               """
+               Get the curve's size value.
+               @rtype: a list of 3 floats.
+               """
+
+       def setSize(size):
+               """
+               Set the curve size value.
+               @rtype: None 
+               @type size: list[3]
+               @param size: The new Curve's size values. 
+               """
+
+       def getMaterials():
+               """
+               Returns a list of materials assigned to the Curve.
+               @rtype: list of Material Objects
+               @return: list of Material Objects assigned to the Curve.
+               """
+
+       def getBevOb():
+               """
+               Returns the Bevel Object (BevOb) assigned to the Curve.
+               @rtype: Blender Object or None
+               @return: Bevel Object (BevOb) assigned to the Curve.
+               """
+
+       def setBevOb( object ):
+               """
+               Assign a Bevel Object (BevOb) to the Curve.  Passing None as the object parameter removes the bevel.
+               @rtype: None
+               @return: None
+               @type object: Curve type Blender Object
+               @param object: Blender Object to assign as Bevel Object (BevOb)
+               @raise TypeError: throws exception if the parameter is not a Curve type Blender Object or None
+               """
+
+       def getTaperOb():
+               """
+               Returns the Taper Object (TaperOb) assigned to the Curve.
+               @rtype: Blender Object or None
+               @return: Taper Object (TaperOb) assigned to the Curve.
+               """
+
+       def setTaperOb( object ):
+               """
+               Assign a Taper Object (TaperOb) to the Curve.  Passing None as the object parameter removes the taper.
+               @rtype: None
+               @return: None
+               @type object: Curve type Blender Object
+               @param object: Blender Object to assign as Taper Object (TaperOb)
+               @raise TypeError: throws exception if the parameter is not a Curve type Blender Object or None
+               """
+
+       def update():
+               """
+               Updates display list for a Curve.
+               Used after making changes to control points.
+               You B{must} use this if you want to see your changes!
+               @rtype: None
+               @return: None
+               """
+
+       def isNurb( curve_num ):
+               """
+               Tells type of a CurNurb (B{deprecated}).
+               New scripts should use L{CurNurb.isNurb()}.
+
+               @rtype: integer
+               @return:  Zero if curve is type Bezier, one if curve is of type Nurb.
+               @type curve_num: integer
+               @param curve_num: zero-based index into list of curves in this Curve.
+               @raise AttributeError:  throws exception if curve_num is out of range.
+               """
+
+       def isCyclic( curve_num ):
+               """
+               Tells whether or not a CurNurb is cyclic (closed) (B{deprecated}).
+               New scripts should use L{CurNurb.isCyclic()}.
+
+               @rtype: boolean
+               @return: True if is cyclic, False if not
+               @type curve_num: integer
+               @param curve_num: zero-based index into list of curves in this Curve
+               @raise AttributeError:  throws exception if curve_num is out of range.
+               """
+
+       def switchDirection( ):
+               """
+               Reverse the direction of a curve.
+               @return: None
+
+               I{B{Example:}}
+               # This example switches the direction of all curves on the active object.
+               from Blender import *
+               scn = Scene.GetCurrent()
+               ob = scn.objects.active # must be a curve
+               data = ob.data
+               for cu in data: cu.switchDirection()
+               """
+
+       def getNumCurves():
+               """
+               Get the number of curves in this Curve Data object.
+               @rtype: integer
+               """
+
+       def getNumPoints( curve_num ):
+               """
+               Get the number of control points in the curve (B{deprecated}).
+               New scripts should use the len operator (I{len(curve)}).
+               @type curve_num: integer
+               @param curve_num: zero-based index into list of curves in this Curve
+               @rtype: integer
+               """
+
+       def getKey():
+               """
+               Return the L{Key<Key.Key>} object containing the keyframes for this
+               curve, if any.
+               @rtype: L{Key<Key.Key>} object or None
+               """
+
+       def recalc():
+               """
+               Recalculate control point handles after a curve has been changed.
+               @rtype: None
+               """
+
+       def __copy__ ():
+               """
+               Make a copy of this curve
+               @rtype: Curve
+               @return:  a copy of this curve
+               """
 
 class CurNurb:
-    """
-    The CurNurb Object
-    ==================
-    This object provides access to the control points of the curves that make up a Blender Curve ObData.
-
-    The CurNurb supports the python iterator protocol which means you can use a python for statement to access the points in a curve.
-
-    The CurNurb also supports the sequence protocol which means you can access the control points of a CurNurb using the [] operator.
-
-    Note that CurNurb is used for accesing poly, bezier and nurbs type curves.
-
-    @ivar flagU: The CurNurb knot flag U.  See L{setFlagU} for description.
-    @type flagU: int
-    @ivar flagV: The CurNurb knot flag V.  See L{setFlagU} for description.
-    @type flagV: int
-    @ivar type: The type of the curve (Poly: 0, Bezier: 1, NURBS: 4)
-    @type type: int
-    """
-
-    def __setitem__( n, point ):
-      """
-      Replace the Nth point in the curve. The type of the argument must match the type of the curve. List of 4 floats (optional 5th float is the tilt value in radians) for Nurbs or BezTriple for Bezier.
-      @rtype: None
-      @return: None
-      @type n: integer
-      @param n: the index of the element to replace
-      @type point: BezTriple or list of 4 floats (optional 5th float is the tilt value in radians)
-      @param point: the point that will replace the one in the curve.  The point can be either a BezTriple type or a list of 4 floats in x,y,z,w (optionally tilt in radians as 5th value) format for a Nurb curve.
-      """
-
-    def __getitem__( n ):
-      """
-      Get the Nth element in the curve. For Bezier curves, that element is a BezTriple. For the rest (Poly and Nurbs), it is a list of 5 floats: x, y, z, weight, tilt (in radians). NOTE 1: This element is independent on the curve, modifying it will not affect the curve. NOTE 2: Each successive call returns a new object.
-      @rtype: BezTriple (Bezier Curve) or List of 5 floats [x, y, z, w, t] for Poly or Nurbs
-      @return: The Nth element in the curve
-      @type n: integer
-      @param n: the index of the element to return
-      """
-
-    def append( new_point ):
-      """
-      Appends a new point to a curve.  This method appends points to both Bezier and Nurb curves. The type of the argument must match the type of the curve. List of 4 floats (optional 5th float is the tilt value in radians) for Nurbs or BezTriple for Bezier.
-      @rtype: None
-      @return: None
-      @type new_point: BezTriple or list of 4 floats (optional 5th float is the tilt value in radians)
-      @param new_point: the new point to be appended to the curve.  The new point can be either a BezTriple type or a list of 4 floats in x,y,z,w (optionally tilt in radians as 5th value) format for a Nurb curve.
-      """
-
-    def setMatIndex( index ):
-      """
-      Sets the Material index for this CurNurb.
-      @rtype: None
-      @return: None
-      @type index:  integer
-      @param index: the new value for the Material number of this CurNurb.  No range checking is done.
-      """
-
-    def getMatIndex():
-      """
-      Returns the Material index for this CurNurb.
-      @rtype: integer
-      @return: integer
-      """
-
-    def isNurb():
-      """
-      Boolean method used to determine whether a CurNurb is of type Bezier or of type Nurb.
-      @rtype: boolean
-      @return:  True or False
-      """
-
-    def isCyclic():
-      """
-      Boolean method checks whether a CurNurb is cyclic (a closed curve) or not.
-      @rtype: boolean
-      @return: True or False
-      """
-
-    def getFlagU():
-      """
-      Get the CurNurb knot flag U.  
-      @rtype: integer
-      @return: See L{setFlagU} for description of return value.
-      """
-
-    def setFlagU( flag ):
-      """
-      Set the entire CurNurb knot flag U (knots are recalculated automatically).
-      The flag can be one of six values:
-           - 0 or 1: uniform knots
-           - 2 or 3: endpoints knots
-           - 4 or 5: bezier knots
-      Bit 0 controls whether or not the curve is cyclic (1 = cyclic).
-      @type flag: integer
-      @param flag: CurNurb knot flag
-      @rtype: None
-      @return: None
-      """
-
-    def getFlagV():
-      """
-      Get the CurNurb knot flag V.
-      @rtype: integer
-      @return: See L{setFlagU} for description of return value.
-      """
-
-    def setFlagV( value ):
-      """
-      Set the CurNurb knot flag V (knots are recalculated automatically).
-      @type value: integer
-      @param value: See L{setFlagU} for description of return.
-      @rtype: None
-      @return: None
-      """
-
-    def getType():
-      """
-      Get the type of the curve.
-      @rtype: integer
-      @return:  0 - Poly, 1 - Bezier, 4 - NURBS
-      """
-
-    def setType( value ):
-      """
-      Set the type of the curve and converts the curve to its new type if needed
-      @type value: integer
-      @param value: CurNurb type flag (0 - Poly, 1 - Bezier, 4 - NURBS)
-      @rtype: None
-      @return: None
-      """
+       """
+       The CurNurb Object
+       ==================
+       This object provides access to the control points of the curves that make up a Blender Curve ObData.
+
+       The CurNurb supports the python iterator protocol which means you can use a python for statement to access the points in a curve.
+
+       The CurNurb also supports the sequence protocol which means you can access the control points of a CurNurb using the [] operator.
+
+       Note that CurNurb is used for accesing poly, bezier and nurbs type curves.
+
+       @ivar flagU: The CurNurb knot flag U.  See L{setFlagU} for description.
+       @type flagU: int
+       @ivar flagV: The CurNurb knot flag V.  See L{setFlagU} for description.
+       @type flagV: int
+       @ivar type: The type of the curve (Poly: 0, Bezier: 1, NURBS: 4)
+       @type type: int
+       """
+
+       def __setitem__( n, point ):
+               """
+               Replace the Nth point in the curve. The type of the argument must match the type of the curve. List of 4 floats (optional 5th float is the tilt value in radians) for Nurbs or BezTriple for Bezier.
+               @rtype: None
+               @return: None
+               @type n: integer
+               @param n: the index of the element to replace
+               @type point: BezTriple or list of 4 floats (optional 5th float is the tilt value in radians)
+               @param point: the point that will replace the one in the curve.  The point can be either a BezTriple type or a list of 4 floats in x,y,z,w (optionally tilt in radians as 5th value) format for a Nurb curve.
+               """
+
+       def __getitem__( n ):
+               """
+               Get the Nth element in the curve. For Bezier curves, that element is a BezTriple. For the rest (Poly and Nurbs), it is a list of 5 floats: x, y, z, weight, tilt (in radians). NOTE 1: This element is independent on the curve, modifying it will not affect the curve. NOTE 2: Each successive call returns a new object.
+               @rtype: BezTriple (Bezier Curve) or List of 5 floats [x, y, z, w, t] for Poly or Nurbs
+               @return: The Nth element in the curve
+               @type n: integer
+               @param n: the index of the element to return
+               """
+
+       def append( new_point ):
+               """
+               Appends a new point to a curve.  This method appends points to both Bezier and Nurb curves. The type of the argument must match the type of the curve. List of 4 floats (optional 5th float is the tilt value in radians) for Nurbs or BezTriple for Bezier.
+               @rtype: None
+               @return: None
+               @type new_point: BezTriple or list of 4 floats (optional 5th float is the tilt value in radians)
+               @param new_point: the new point to be appended to the curve.  The new point can be either a BezTriple type or a list of 4 floats in x,y,z,w (optionally tilt in radians as 5th value) format for a Nurb curve.
+               """
+
+       def setMatIndex( index ):
+               """
+               Sets the Material index for this CurNurb.
+               @rtype: None
+               @return: None
+               @type index:  integer
+               @param index: the new value for the Material number of this CurNurb.  No range checking is done.
+               """
+
+       def getMatIndex():
+               """
+               Returns the Material index for this CurNurb.
+               @rtype: integer
+               @return: integer
+               """
+
+       def isNurb():
+               """
+               Boolean method used to determine whether a CurNurb is of type Bezier or of type Nurb.
+               @rtype: boolean
+               @return:  True or False
+               """
+
+       def isCyclic():
+               """
+               Boolean method checks whether a CurNurb is cyclic (a closed curve) or not.
+               @rtype: boolean
+               @return: True or False
+               """
+
+       def getFlagU():
+               """
+               Get the CurNurb knot flag U.  
+               @rtype: integer
+               @return: See L{setFlagU} for description of return value.
+               """
+
+       def setFlagU( flag ):
+               """
+               Set the entire CurNurb knot flag U (knots are recalculated automatically).
+               The flag can be one of six values:
+                                - 0 or 1: uniform knots
+                                - 2 or 3: endpoints knots
+                                - 4 or 5: bezier knots
+               Bit 0 controls whether or not the curve is cyclic (1 = cyclic).
+               @type flag: integer
+               @param flag: CurNurb knot flag
+               @rtype: None
+               @return: None
+               """
+
+       def getFlagV():
+               """
+               Get the CurNurb knot flag V.
+               @rtype: integer
+               @return: See L{setFlagU} for description of return value.
+               """
+
+       def setFlagV( value ):
+               """
+               Set the CurNurb knot flag V (knots are recalculated automatically).
+               @type value: integer
+               @param value: See L{setFlagU} for description of return.
+               @rtype: None
+               @return: None
+               """
+
+       def getType():
+               """
+               Get the type of the curve.
+               @rtype: integer
+               @return:  0 - Poly, 1 - Bezier, 4 - NURBS
+               """
+
+       def setType( value ):
+               """
+               Set the type of the curve and converts the curve to its new type if needed
+               @type value: integer
+               @param value: CurNurb type flag (0 - Poly, 1 - Bezier, 4 - NURBS)
+               @rtype: None
+               @return: None
+               """
 
 class SurfNurb:
-  """
-  The SurfNurb Object
-  ===================
-  This object provides access to the control points of the surfaces that make
-  up a Blender Curve.
-
-  The SurfNurb supports the Python iterator and sequence protocols which
-  means you can use a python B{for} statement or [] operator to access the
-  points in a surface.  Points are accessed linearly; for a N-by-M UV surface,
-  the first N control points correspond to V=0, then second N to V=1, and so
-  on.
-
-  @ivar flagU: The knot flag U.  Changing the knot type automatically
-  recalculates the knots.  The flag can be one of three values:
-           - 0 : uniform knots
-           - 1 : endpoints knots
-           - 2 : bezier knots
-  @type flagU: int
-  @ivar flagV: The knot flag V.  See L{flagU} for description.
-  @type flagV: int
-  @ivar pointsU: The number of control points in the U direction (read only).
-  @type pointsU: int
-  @ivar pointsV: The number of control points in the V direction (read only).
-  @type pointsV: int
-  @ivar cyclicU: The cyclic setting for the U direction (True = cyclic).
-  @type cyclicU: boolean
-  @ivar cyclicV: The cyclic setting for the V direction (True = cyclic).
-  @type cyclicV: boolean
-  @ivar orderU: The order setting for the U direction.  Values are clamped
-  to the range [2:6] and not greater than the U dimension.
-  @type orderU: int
-  @ivar orderV: The order setting for the V direction.  Values are clamped
-  to the range [2:6] and not greater than the V dimension.
-  @type orderV: int
-  """
-
-  def __setitem__( n, point ):
-      """
-      Set the Nth control point in the surface. 
-      @rtype: None
-      @return: None
-      @type n: integer
-      @param n: the index of the point to replace
-      @type point: list of 4 floats (optional 5th float is the tilt value
-      in radians)
-      @param point: the point that will replace the one in the curve.  The
-      point is  list of 4 floats in x,y,z,w (optionally tilt in radians as
-      5th value) format.
-      """
-
-  def __getitem__( n ):
-      """
-      Get the Nth control point in the surface. 
-      @rtype: List of 5 floats [x, y, z, w, t] for Poly or Nurbs
-      @return: The Nth point in the curve
-      @type n: integer
-      @param n: the index of the point to return
-      @note: This returned value is independent on the curve; modifying it will not affect the curve. 
-      @note: Each successive call returns a new object.
-      """
+       """
+       The SurfNurb Object
+       ===================
+       This object provides access to the control points of the surfaces that make
+       up a Blender Curve.
+
+       The SurfNurb supports the Python iterator and sequence protocols which
+       means you can use a python B{for} statement or [] operator to access the
+       points in a surface.  Points are accessed linearly; for a N-by-M UV surface,
+       the first N control points correspond to V=0, then second N to V=1, and so
+       on.
+
+       @ivar flagU: The knot flag U.  Changing the knot type automatically
+       recalculates the knots.  The flag can be one of three values:
+                                        - 0 : uniform knots
+                                        - 1 : endpoints knots
+                                        - 2 : bezier knots
+       @type flagU: int
+       @ivar flagV: The knot flag V.  See L{flagU} for description.
+       @type flagV: int
+       @ivar pointsU: The number of control points in the U direction (read only).
+       @type pointsU: int
+       @ivar pointsV: The number of control points in the V direction (read only).
+       @type pointsV: int
+       @ivar cyclicU: The cyclic setting for the U direction (True = cyclic).
+       @type cyclicU: boolean
+       @ivar cyclicV: The cyclic setting for the V direction (True = cyclic).
+       @type cyclicV: boolean
+       @ivar orderU: The order setting for the U direction.  Values are clamped
+       to the range [2:6] and not greater than the U dimension.
+       @type orderU: int
+       @ivar orderV: The order setting for the V direction.  Values are clamped
+       to the range [2:6] and not greater than the V dimension.
+       @type orderV: int
+       """
+
+       def __setitem__( n, point ):
+               """
+               Set the Nth control point in the surface. 
+               @rtype: None
+               @return: None
+               @type n: integer
+               @param n: the index of the point to replace
+               @type point: list of 4 floats (optional 5th float is the tilt value
+               in radians)
+               @param point: the point that will replace the one in the curve.  The
+               point is  list of 4 floats in x,y,z,w (optionally tilt in radians as
+               5th value) format.
+               """
+
+       def __getitem__( n ):
+               """
+               Get the Nth control point in the surface. 
+               @rtype: List of 5 floats [x, y, z, w, t] for Poly or Nurbs
+               @return: The Nth point in the curve
+               @type n: integer
+               @param n: the index of the point to return
+               @note: This returned value is independent on the curve; modifying it will not affect the curve. 
+               @note: Each successive call returns a new object.
+               """
 
index 0cc561aaff69309cf4017cd8f911b46d5353fdda..c0ad66d04624ab4fc59d57245b0144d1faf64754 100644 (file)
@@ -9,61 +9,61 @@ Text3d.Font Objects
 This module provides access to B{Font} objects in Blender.
 
 Example::
-  import Blender
-  from Blender import Text3d
-  
-  # Load a font
-  myfont= Text3d.Font.Load('/usr/share/fonts/ttf/verdana.ttf')
-  
-  # 
-  for font in Text3d.Font.Get():
-    print font.name, font.filename, font.packed
+       import Blender
+       from Blender import Text3d
+       
+       # Load a font
+       myfont= Text3d.Font.Load('/usr/share/fonts/ttf/verdana.ttf')
+       
+       
+       for font in Text3d.Font.Get():
+               print font.name, font.filename, font.packed
 """
 
 def Load (filename):
-  """
-  Create a new Text3d.Font object.
-  @type filename: string
-  @param filename: file of the font
-  @rtype: Blender Text3d.Font
-  @return: The created Text3d.Font Data object.
-  """
+       """
+       Create a new Text3d.Font object.
+       @type filename: string
+       @param filename: file of the font
+       @rtype: Blender Text3d.Font
+       @return: The created Text3d.Font Data object.
+       """
 
 def Get (name = None):
-  """
-  Get the Text3d.Font object(s) from Blender.
-  @type name: string
-  @param name: The name of the Text3d object.
-  @rtype: Blender Text3d or a list of Blender Text3ds
-  @return: It depends on the 'name' parameter:
-      - (name): The Text3d object with the given name;
-      - ():     A list with all Font objects in the current .blend file.
-  """
+       """
+       Get the Text3d.Font object(s) from Blender.
+       @type name: string
+       @param name: The name of the Text3d object.
+       @rtype: Blender Text3d or a list of Blender Text3ds
+       @return: It depends on the 'name' parameter:
+                       - (name): The Text3d object with the given name;
+                       - ():     A list with all Font objects in the current .blend file.
+       """
 class Font:
-  """
-  The Text3d.Font object
-  ======================
-    This object gives access  Blender's B{Font} objects
-  @ivar name: The Font name.
-  @ivar filename: The filename (path) of the file loaded into this Font.
-  @ivar packed: Boolean, True when the sample is packed (readonly).
-  @ivar users: The number of users this font has (read only)
-  """
+       """
+       The Text3d.Font object
+       ======================
+               This object gives access  Blender's B{Font} objects
+       @ivar filename: The filename (path) of the file loaded into this Font.
+       @type filename: string
+       @ivar packed: Boolean, True when the sample is packed (readonly).
+       @type packed: string
+       """
 
-  def pack():
-    """
-    Packs the sound into the current blend file.
-    @note: An error will be raised if the sound is already packed or the filename path does not exist.
-    @returns: nothing
-    @rtype: none
-    """
+       def pack():
+               """
+               Packs the sound into the current blend file.
+               @note: An error will be raised if the sound is already packed or the filename path does not exist.
+               @returns: nothing
+               @rtype: none
+               """
 
-  def unpack(mode):
-    """
-    Unpacks the sound to the samples filename.
-    @param mode: One of the values in Blender.UnpackModes dict.
-    @note: An error will be raised if the sound is not packed or the filename path does not exist.
-    @returns: nothing
-    @rtype: none
-    @type mode: int
-    """
+       def unpack(mode):
+               """
+               Unpacks the sound to the samples filename.
+               @param mode: One of the values in Blender.UnpackModes dict.
+               @note: An error will be raised if the sound is not packed or the filename path does not exist.
+               @returns: nothing
+               @rtype: none
+               @type mode: int
+               """
index 8e04518fe35a8039e818c95fb6430ef319bf541a..aca7c56b4a52c8bb0a9fa155518a40f0b60c740f 100644 (file)
@@ -10,121 +10,118 @@ This module provides access to B{Group} data in Blender.
 
 Example::
 
-  # Make Dupli's Real, as a python script.
+       # Make Dupli's Real, as a python script.
 
-  from Blender import *
+       from Blender import *
 
-  scn= Scene.GetCurrent()
-  for ob in scn.objects:
-    print 'Object Group Settings'
-    print ob.name, ob.type
-    print 'enableDupVerts:', ob.enableDupVerts
-    print 'enableDupFrames:', ob.enableDupFrames
-    print 'enableDupGroup:', ob.enableDupGroup
-    print 'DupGroup:', ob.DupGroup
-    dupe_obs= ob.DupObjects
-    print 'num dup obs:', len(dupe_obs)
+       scn= Scene.GetCurrent()
+       for ob in scn.objects:
+               print 'Object Group Settings'
+               print ob.name, ob.type
+               print 'enableDupVerts:', ob.enableDupVerts
+               print 'enableDupFrames:', ob.enableDupFrames
+               print 'enableDupGroup:', ob.enableDupGroup
+               print 'DupGroup:', ob.DupGroup
+               dupe_obs= ob.DupObjects
+               print 'num dup obs:', len(dupe_obs)
 
-    for dup_ob, dup_matrix in dupe_obs:
-      print '\tDupOb', dup_ob.name
-      scn.objects.new(dup_ob.data)
-      new_ob.setMatrix(dup_matrix)
-      new_ob.sel= 1 # select all real instances.
+               for dup_ob, dup_matrix in dupe_obs:
+                       print '\tDupOb', dup_ob.name
+                       scn.objects.new(dup_ob.data)
+                       new_ob.setMatrix(dup_matrix)
+                       new_ob.sel= 1 # select all real instances.
 
-    ob.sel=0 # Desel the original object
+               ob.sel=0 # Desel the original object
 
-  Window.RedrawAll()
+       Window.RedrawAll()
 
 Example::
 
-  # Make a new group with the selected objects, and add an instance of this group.
-
-  from Blender import *
-  
-  scn= Scene.GetCurrent()
-  
-  # New Group
-  grp= Group.New('mygroup')
-  grp.objects= scn.objects
-  
-  # Instance the group at an empty using dupligroups
-  ob= scn.objects.new(None)
-  ob.enableDupGroup= True
-  ob.DupGroup= grp
-  Window.RedrawAll()
-  
-  
+       # Make a new group with the selected objects, and add an instance of this group.
+
+       from Blender import *
+       
+       scn= Scene.GetCurrent()
+       
+       # New Group
+       grp= Group.New('mygroup')
+       grp.objects= scn.objects
+       
+       # Instance the group at an empty using dupligroups
+       ob= scn.objects.new(None)
+       ob.enableDupGroup= True
+       ob.DupGroup= grp
+       Window.RedrawAll()
+       
+       
 Example::
 
-  # Remove all non mesh objects from a group.
-
-  from Blender import *
-  
-  scn= Scene.GetCurrent()
-  
-  # New Group
-  grp= Group.Get('mygroup')
-  for ob in list(grp.objects): # Convert to a list before looping because we are removing items
-    if ob.type != 'Mesh':
-      grp.objects.unlink(ob)
+       # Remove all non mesh objects from a group.
+
+       from Blender import *
+       
+       scn= Scene.GetCurrent()
+       
+       # New Group
+       grp= Group.Get('mygroup')
+       for ob in list(grp.objects): # Convert to a list before looping because we are removing items
+               if ob.type != 'Mesh':
+                       grp.objects.unlink(ob)
 """
 
 def New (name = None):
-  """
-  Make a new empty group, name optional, default is "Group"
-  @type name: string
-  @param name: The name of the new group.
-  @rtype:  Blender Group
-  @return: A Empty Blender Group object
-  """
+       """
+       Make a new empty group, name optional, default is "Group"
+       @type name: string
+       @param name: The name of the new group.
+       @rtype:  Blender Group
+       @return: A Empty Blender Group object
+       """
 
 def Get (name = None):
-  """
-  Get the Group object(s) from Blender.
-  @type name: string
-  @param name: The name of the Group object.
-  @rtype: Blender Group or a list of Blender Groups
-  @return: It depends on the I{name} parameter:
-      - (name): The Group object called I{name}, Exception if it is not found.
-      - (): A list with all Group objects in the current blend file.
-  """
+       """
+       Get the Group object(s) from Blender.
+       @type name: string
+       @param name: The name of the Group object.
+       @rtype: Blender Group or a list of Blender Groups
+       @return: It depends on the I{name} parameter:
+                       - (name): The Group object called I{name}, Exception if it is not found.
+                       - (): A list with all Group objects in the current blend file.
+       """
 
 def Unlink (group):
-  """
-  Unlink (delete) this group from Blender.
-  @Note: No objects will be removed, just the group that references them.
-  @type group: group
-  @param group: A group to remove from this blend file, does not remove objects that this group uses.
-  """
+       """
+       Unlink (delete) this group from Blender.
+       @Note: No objects will be removed, just the group that references them.
+       @type group: group
+       @param group: A group to remove from this blend file, does not remove objects that this group uses.
+       """
 
 
 class Group:
-  """
-  The Group object
-  ================
-    This object gives access to Groups in Blender.
-  @ivar name: The name of this Group object.
-  @type name: string
-  @ivar users: Number of users this group has (read only)
-  @type users: int
-  @ivar fakeUser: The fake user status.
-    Enabling this will keep it in the blend even if there are no users.
-  @type fakeUser: bool
-  @ivar layers: Layer bitmask for this group.
-  @type layers: int
-  @ivar objects: Objects that this group uses.
-    This is a sequence with-list like access so use list(grp.objects) if you need to use a list (where grp is a group).
-    The groups objects can be set by assigning a list or iterator of objects to the groups objects.
-    objects.link() and objects.unlink() also work with the the objects iterator just like with lists.
-
-    B{Note}: append() and remove() have been deprecated and replaced by link() and unlink(),
-    after Blender 2.43 append() and remove() will not be available.
-  @type objects: custom object sequence
-  """
-
-  def __copy__ ():
-    """
-    Make a copy of this group
-    @rtype: Group
-    @return:  a copy of this group
-    """
\ No newline at end of file
+       """
+       The Group object
+       ================
+               This object gives access to Groups in Blender.
+       @ivar layers: Layer bitmask for this group.
+       @type layers: int
+       @ivar objects: Objects that this group uses.
+               This is a sequence with-list like access so use list(grp.objects) if you need to use a list (where grp is a group).
+               The groups objects can be set by assigning a list or iterator of objects to the groups objects.
+               objects.link() and objects.unlink() also work with the the objects iterator just like with lists.
+
+               B{Note}: append() and remove() have been deprecated and replaced by link() and unlink(),
+               after Blender 2.43 append() and remove() will not be available.
+       @type objects: custom object sequence
+       """
+
+       def __copy__ ():
+               """
+               Make a copy of this group
+               @rtype: Group
+               @return:  a copy of this group
+               """
+
+import id_generics
+Group.__doc__ += id_generics.attributes 
+
index ef5fe04dbca1d0297102f1cad46539101b6115e4..d22cffbe1e80b128c454dd3d4233f817c73a50fb 100644 (file)
@@ -11,348 +11,345 @@ B{New}: L{Image.setFilename}.
 This module provides access to B{Image} objects in Blender.
 
 Example::
-  import Blender
-  from Blender import Image
-  #
-  image = Image.Load("/path/to/my/image.png")    # load an image file
-  print "Image from", image.getFilename(),
-  print "loaded to obj", image.getName())
-  image.setXRep(4)                               # set x tiling factor
-  image.setYRep(2)                               # set y tiling factor
-  print "All Images available now:", Image.Get()
+       import Blender
+       from Blender import Image
+       #
+       image = Image.Load("/path/to/my/image.png")    # load an image file
+       print "Image from", image.getFilename(),
+       print "loaded to obj", image.getName())
+       image.setXRep(4)                               # set x tiling factor
+       image.setYRep(2)                               # set y tiling factor
+       print "All Images available now:", Image.Get()
 """
 
 def Load (filename):
-  """
-  Load the image called 'filename' into an Image object.
-  @type filename: string
-  @param filename: The full path to the image file.
-  @rtype:  Blender Image
-  @return: A Blender Image object with the data from I{filename}.
-  """
+       """
+       Load the image called 'filename' into an Image object.
+       @type filename: string
+       @param filename: The full path to the image file.
+       @rtype:  Blender Image
+       @return: A Blender Image object with the data from I{filename}.
+       """
 
 def New (name, width, height, depth):
-  """
-  Create a new Image object.
-  @type name: string
-  @param name: The name of the new Image object.
-  @type width: int
-  @param width: The width of the new Image object, between 1 and 5000.
-  @type height: int
-  @param height: The height of the new Image object, between 1 and 5000.
-  @type depth: int
-  @param depth: The colour depth of the new Image object. (8:Grey, 24:RGB, 32:RGBA). (Not implimented yet, all new images will be 24bit)
-  @rtype: Blender Image
-  @return: A new Blender Image object.
-  """
+       """
+       Create a new Image object.
+       @type name: string
+       @param name: The name of the new Image object.
+       @type width: int
+       @param width: The width of the new Image object, between 1 and 5000.
+       @type height: int
+       @param height: The height of the new Image object, between 1 and 5000.
+       @type depth: int
+       @param depth: The colour depth of the new Image object. (8:Grey, 24:RGB, 32:RGBA). (Not implimented yet, all new images will be 24bit)
+       @rtype: Blender Image
+       @return: A new Blender Image object.
+       """
 
 def Get (name = None):
-  """
-  Get the Image object(s) from Blender.
-  @type name: string
-  @param name: The name of the Image object.
-  @rtype: Blender Image or a list of Blender Images
-  @return: It depends on the I{name} parameter:
-      - (name): The Image object called I{name}, None if not found;
-      - (): A list with all Image objects in the current scene.
-  """
+       """
+       Get the Image object(s) from Blender.
+       @type name: string
+       @param name: The name of the Image object.
+       @rtype: Blender Image or a list of Blender Images
+       @return: It depends on the I{name} parameter:
+                       - (name): The Image object called I{name}, None if not found;
+                       - (): A list with all Image objects in the current scene.
+       """
 
 def GetCurrent ():
-  """
-  Get the currently displayed Image from Blenders UV/Image window.
-  When multiple images are displayed, the last active UV/Image windows image is used.
-  @rtype: Blender Image
-  @return: The Current Blender Image, If there is no current image it returns None.
-  """
+       """
+       Get the currently displayed Image from Blenders UV/Image window.
+       When multiple images are displayed, the last active UV/Image windows image is used.
+       @rtype: Blender Image
+       @return: The Current Blender Image, If there is no current image it returns None.
+       """
 
 from IDProp import IDGroup, IDArray
 class Image:
-  """
-  The Image object
-  ================
-    This object gives access to Images in Blender.
-  @ivar properties: Returns an L{IDGroup<IDProp.IDGroup>} reference to this 
-  image's ID Properties.
-  @type properties: L{IDGroup<IDProp.IDGroup>}
-  @ivar name: The name of this Image object.
-  @type name: string
-  @ivar filename: The filename (path) to the image file loaded into this Image
-     object.
-  @type filename: string
-  @ivar size: The [width, height] dimensions of the image (in pixels).
-  @type size: list
-  @ivar depth: The pixel depth of the image. [8, 16, 18, 24, 32]
-  @type depth: int
-  @ivar xrep: Texture tiling: the number of repetitions in the x (horizontal)
-     axis. [1, 16].
-  @ivar yrep: Texture tiling: the number of repetitions in the y (vertical)
-     axis [1, 16].
-  @type xrep: int 
-  @type yrep: int 
-  @ivar start: Texture's animation start frame [0, 128].
-  @type start: int
-  @ivar end: Texture's animation end frame [0, 128].
-  @type end: int
-  @ivar speed: Texture's animation speed [1, 100].
-  @type speed: int
-  @ivar packed: True when the Texture is packed (readonly).
-  @type packed: boolean
-  @ivar has_data: True when the image has pixel data (readonly).
-  @type has_data: boolean
-  @ivar fields: enable or disable the fields option for this image.
-  @type fields: boolean
-  @ivar fields_odd: enable or disable the odd fields option for this image.
-  @type fields_odd: boolean
-  @ivar antialias: enable or disable the antialias option for this image.
-  @type antialias: boolean
-  @ivar bindcode: Texture's bind code (readonly).
-  @type bindcode: int
-  """
-
-  def getName():
-    """
-    Get the name of this Image object.
-    @rtype: string
-    """
-
-  def getFilename():
-    """
-    Get the filename of the image file loaded into this Image object.
-    @rtype: string
-    """
-
-  def getSize():
-    """
-    Get the [width, height] dimensions (in pixels) of this image.
-    @rtype: list of 2 ints
-    """
-
-  def getDepth():
-    """
-    Get the pixel depth of this image.
-    @rtype: int
-    """
-
-  def getPixelF(x, y):
-    """
-    Get the the colors of the current pixel in the form [r,g,b,a].
-    Returned values are floats normalized to 0.0 - 1.0.
-    Pixel coordinates are in the range from 0 to N-1.  See L{getMaxXY}
-    @returns: [ r, g, b, a]
-    @rtype: list of 4 floats
-    @type x: int
-    @type y: int
-    @param x:  the x coordinate of pixel.
-    @param y:  the y coordinate of pixel.  
-    """
-  def getPixelI(x, y):
-    """
-    Get the the colors of the current pixel in the form [r,g,b,a].
-    Returned values are ints normalized to 0 - 255.
-    Pixel coordinates are in the range from 0 to N-1.  See L{getMaxXY}
-    @returns: [ r, g, b, a]
-    @rtype: list of 4 ints
-    @type x: int
-    @type y: int
-    @param x:  the x coordinate of pixel.
-    @param y:  the y coordinate of pixel.  
-    """
-
-  def getMaxXY():
-    """
-    Get the  x & y size for the image.  Image coordinates range from 0 to size-1.
-    @returns: [x, y]
-    @rtype: list of 2 ints
-    """
-
-  def getMinXY():
-    """
-    Get the x & y origin for the image. Image coordinates range from 0 to size-1.
-    @returns: [x, y]
-    @rtype: list of 2 ints
-    """
-
-  def getXRep():
-    """
-    Get the number of repetitions in the x (horizontal) axis for this Image.
-    This is for texture tiling.
-    @rtype: int
-    """
-
-  def getYRep():
-    """
-    Get the number of repetitions in the y (vertical) axis for this Image.
-    This is for texture tiling.
-    @rtype: int
-    """
-
-  def getBindCode():
-    """
-    Get the Image's bindcode.  This is for texture loading using BGL calls.
-    See, for example, L{BGL.glBindTexture} and L{glLoad}.
-    @rtype: int
-    """
-
-  def getStart():
-    """
-    Get the Image's start frame. Used for animated textures.
-    @rtype: int
-    """
-
-  def getEnd():
-    """
-    Get the Image's end frame. Used for animated textures.
-    @rtype: int
-    """
-
-  def getSpeed():
-    """
-    Get the Image's speed (fps). Used for animated textures.
-    @rtype: int
-    """
-
-  def reload():
-    """
-    Reloads this image from the filesystem.  If used within a loop you need to
-    redraw the Window to see the change in the image, e.g. with
-    Window.RedrawAll().
-    @warn: if the image file is corrupt or still being written, it will be
-       replaced by a blank image in Blender, but no error will be returned.
-    @returns: None
-    """
-
-  def glLoad():
-    """
-    Load this image's data into OpenGL texture memory, if it is not already
-    loaded (image.bindcode is 0 if it is not loaded yet).
-    @note: Usually you don't need to call this method.  It is only necessary
-       if you want to draw textured objects in the Scripts window and the
-       image's bind code is zero at that moment, otherwise Blender itself can
-       take care of binding / unbinding textures.  Calling this method for an
-       image with nonzero bind code simply returns the image's bind code value
-       (see L{getBindCode}).
-    @rtype: int
-    @returns: the texture's bind code.
-    """
-
-  def glFree():
-    """
-    Delete this image's data from OpenGL texture memory, only (the image itself
-    is not removed from Blender's memory).  Internally, glDeleteTextures (see
-    L{BGL.glDeleteTextures}) is used, but this method also updates Blender's
-    Image object so that its bind code is set to 0.  See also L{Image.glLoad},
-    L{Image.getBindCode}.
-    """
-
-  def setName(name):
-    """
-    Set the name of this Image object.
-    @type name: string
-    @param name: The new name.
-    """
-
-  def setFilename(name):
-    """
-    Change the filename of this Image object.
-    @type name: string
-    @param name: The new full filename.
-    @warn: use this with caution and note that the filename is truncated if
-       larger than 160 characters.
-    """
-
-  def setXRep(xrep):
-    """
-    Texture tiling: set the number of x repetitions for this Image.
-    @type xrep: int
-    @param xrep: The new value in [1, 16].
-    """
-
-  def setYRep(yrep):
-    """
-    Texture tiling: set the number of y repetitions for this Image.
-    @type yrep: int
-    @param yrep: The new value in [1, 16].
-    """
-
-  def setStart(start):
-    """
-    Get the Image's start frame. Used for animated textures.
-    @type start: int
-    @param start: The new value in [0, 128].
-    """
-
-  def setEnd(end):
-    """
-    Set the Image's end frame. Used for animated textures.
-    @type end: int
-    @param end: The new value in [0, 128].
-    """
-
-  def setSpeed(speed):
-    """
-    Set the Image's speed (fps). Used for animated textures.
-    @type speed: int
-    @param speed: The new value in [1, 100].
-    """
-
-  def setPixelF(x, y, (r, g, b,a )):
-    """
-    Set the the colors of the current pixel in the form [r,g,b,a].
-    Color values must be floats in the range 0.0 - 1.0.
-    Pixel coordinates are in the range from 0 to N-1.  See L{getMaxXY}
-    @type x: int
-    @type y: int
-    @type r: float
-    @type g: float
-    @type b: float
-    @type a: float
-    @returns: nothing
-    @rtype: none
-    """
-    
-  def setPixelI(x, y, (r, g, b, a)):
-    """
-    Set the the colors of the current pixel in the form [r,g,b,a].
-    Color values must be ints in the range 0 - 255.
-    Pixel coordinates are in the range from 0 to N-1.  See L{getMaxXY}
-    @type x: int
-    @type y: int
-    @type r: int
-    @type g: int
-    @type b: int
-    @type a: int
-    @returns: nothing
-    @rtype: none
-    """
-    
-  def save():
-    """
-    Saves the current image.
-    @returns: nothing
-    @rtype: none
-    """
-  
-  def pack():
-    """
-    Packs the image into the current blend file.
-    @note: An error will be raised if the image is already packed or the filename path does not exist.
-    @returns: nothing
-    @rtype: none
-    """
-
-  def unpack(mode):
-    """
-    Unpacks the image to the images filename.
-    @param mode: One of the values in Blender.Unpackmodes dict.
-    @note: An error will be raised if the image is not packed or the filename path does not exist.
-    @returns: nothing
-    @rtype: none
-    @type mode: int
-    """
-  def makeCurrent():
-    """
-    Set the currently displayed Image from Blenders UV/Image window.
-    When multiple images are displayed, the last active UV/Image windows image is used.
-    @rtype: bool
-    @return: True if the current image could be set, if no window was available, return False.
-    """
+       """
+       The Image object
+       ================
+               This object gives access to Images in Blender.
+       @ivar filename: The filename (path) to the image file loaded into this Image
+                object.
+       @type filename: string
+       @ivar size: The [width, height] dimensions of the image (in pixels).
+       @type size: list
+       @ivar depth: The pixel depth of the image. [8, 16, 18, 24, 32]
+       @type depth: int
+       @ivar xrep: Texture tiling: the number of repetitions in the x (horizontal)
+                axis. [1, 16].
+       @ivar yrep: Texture tiling: the number of repetitions in the y (vertical)
+                axis [1, 16].
+       @type xrep: int 
+       @type yrep: int 
+       @ivar start: Texture's animation start frame [0, 128].
+       @type start: int
+       @ivar end: Texture's animation end frame [0, 128].
+       @type end: int
+       @ivar speed: Texture's animation speed [1, 100].
+       @type speed: int
+       @ivar packed: True when the Texture is packed (readonly).
+       @type packed: boolean
+       @ivar has_data: True when the image has pixel data (readonly).
+       @type has_data: boolean
+       @ivar fields: enable or disable the fields option for this image.
+       @type fields: boolean
+       @ivar fields_odd: enable or disable the odd fields option for this image.
+       @type fields_odd: boolean
+       @ivar antialias: enable or disable the antialias option for this image.
+       @type antialias: boolean
+       @ivar bindcode: Texture's bind code (readonly).
+       @type bindcode: int
+       """
+
+       def getName():
+               """
+               Get the name of this Image object.
+               @rtype: string
+               """
+
+       def getFilename():
+               """
+               Get the filename of the image file loaded into this Image object.
+               @rtype: string
+               """
+
+       def getSize():
+               """
+               Get the [width, height] dimensions (in pixels) of this image.
+               @rtype: list of 2 ints
+               """
+
+       def getDepth():
+               """
+               Get the pixel depth of this image.
+               @rtype: int
+               """
+
+       def getPixelF(x, y):
+               """
+               Get the the colors of the current pixel in the form [r,g,b,a].
+               Returned values are floats normalized to 0.0 - 1.0.
+               Pixel coordinates are in the range from 0 to N-1.  See L{getMaxXY}
+               @returns: [ r, g, b, a]
+               @rtype: list of 4 floats
+               @type x: int
+               @type y: int
+               @param x:  the x coordinate of pixel.
+               @param y:  the y coordinate of pixel.  
+               """
+       def getPixelI(x, y):
+               """
+               Get the the colors of the current pixel in the form [r,g,b,a].
+               Returned values are ints normalized to 0 - 255.
+               Pixel coordinates are in the range from 0 to N-1.  See L{getMaxXY}
+               @returns: [ r, g, b, a]
+               @rtype: list of 4 ints
+               @type x: int
+               @type y: int
+               @param x:  the x coordinate of pixel.
+               @param y:  the y coordinate of pixel.  
+               """
+
+       def getMaxXY():
+               """
+               Get the  x & y size for the image.  Image coordinates range from 0 to size-1.
+               @returns: [x, y]
+               @rtype: list of 2 ints
+               """
+
+       def getMinXY():
+               """
+               Get the x & y origin for the image. Image coordinates range from 0 to size-1.
+               @returns: [x, y]
+               @rtype: list of 2 ints
+               """
+
+       def getXRep():
+               """
+               Get the number of repetitions in the x (horizontal) axis for this Image.
+               This is for texture tiling.
+               @rtype: int
+               """
+
+       def getYRep():
+               """
+               Get the number of repetitions in the y (vertical) axis for this Image.
+               This is for texture tiling.
+               @rtype: int
+               """
+
+       def getBindCode():
+               """
+               Get the Image's bindcode.  This is for texture loading using BGL calls.
+               See, for example, L{BGL.glBindTexture} and L{glLoad}.
+               @rtype: int
+               """
+
+       def getStart():
+               """
+               Get the Image's start frame. Used for animated textures.
+               @rtype: int
+               """
+
+       def getEnd():
+               """
+               Get the Image's end frame. Used for animated textures.
+               @rtype: int
+               """
+
+       def getSpeed():
+               """
+               Get the Image's speed (fps). Used for animated textures.
+               @rtype: int
+               """
+
+       def reload():
+               """
+               Reloads this image from the filesystem.  If used within a loop you need to
+               redraw the Window to see the change in the image, e.g. with
+               Window.RedrawAll().
+               @warn: if the image file is corrupt or still being written, it will be
+                       replaced by a blank image in Blender, but no error will be returned.
+               @returns: None
+               """
+
+       def glLoad():
+               """
+               Load this image's data into OpenGL texture memory, if it is not already
+               loaded (image.bindcode is 0 if it is not loaded yet).
+               @note: Usually you don't need to call this method.  It is only necessary
+                       if you want to draw textured objects in the Scripts window and the
+                       image's bind code is zero at that moment, otherwise Blender itself can
+                       take care of binding / unbinding textures.  Calling this method for an
+                       image with nonzero bind code simply returns the image's bind code value
+                       (see L{getBindCode}).
+               @rtype: int
+               @returns: the texture's bind code.
+               """
+
+       def glFree():
+               """
+               Delete this image's data from OpenGL texture memory, only (the image itself
+               is not removed from Blender's memory).  Internally, glDeleteTextures (see
+               L{BGL.glDeleteTextures}) is used, but this method also updates Blender's
+               Image object so that its bind code is set to 0.  See also L{Image.glLoad},
+               L{Image.getBindCode}.
+               """
+
+       def setName(name):
+               """
+               Set the name of this Image object.
+               @type name: string
+               @param name: The new name.
+               """
+
+       def setFilename(name):
+               """
+               Change the filename of this Image object.
+               @type name: string
+               @param name: The new full filename.
+               @warn: use this with caution and note that the filename is truncated if
+                       larger than 160 characters.
+               """
+
+       def setXRep(xrep):
+               """
+               Texture tiling: set the number of x repetitions for this Image.
+               @type xrep: int
+               @param xrep: The new value in [1, 16].
+               """
+
+       def setYRep(yrep):
+               """
+               Texture tiling: set the number of y repetitions for this Image.
+               @type yrep: int
+               @param yrep: The new value in [1, 16].
+               """
+
+       def setStart(start):
+               """
+               Get the Image's start frame. Used for animated textures.
+               @type start: int
+               @param start: The new value in [0, 128].
+               """
+
+       def setEnd(end):
+               """
+               Set the Image's end frame. Used for animated textures.
+               @type end: int
+               @param end: The new value in [0, 128].
+               """
+
+       def setSpeed(speed):
+               """
+               Set the Image's speed (fps). Used for animated textures.
+               @type speed: int
+               @param speed: The new value in [1, 100].
+               """
+
+       def setPixelF(x, y, (r, g, b,a )):
+               """
+               Set the the colors of the current pixel in the form [r,g,b,a].
+               Color values must be floats in the range 0.0 - 1.0.
+               Pixel coordinates are in the range from 0 to N-1.  See L{getMaxXY}
+               @type x: int
+               @type y: int
+               @type r: float
+               @type g: float
+               @type b: float
+               @type a: float
+               @returns: nothing
+               @rtype: none
+               """
+               
+       def setPixelI(x, y, (r, g, b, a)):
+               """
+               Set the the colors of the current pixel in the form [r,g,b,a].
+               Color values must be ints in the range 0 - 255.
+               Pixel coordinates are in the range from 0 to N-1.  See L{getMaxXY}
+               @type x: int
+               @type y: int
+               @type r: int
+               @type g: int
+               @type b: int
+               @type a: int
+               @returns: nothing
+               @rtype: none
+               """
+               
+       def save():
+               """
+               Saves the current image.
+               @returns: nothing
+               @rtype: none
+               """
+       
+       def pack():
+               """
+               Packs the image into the current blend file.
+               @note: An error will be raised if the image is already packed or the filename path does not exist.
+               @returns: nothing
+               @rtype: none
+               """
+
+       def unpack(mode):
+               """
+               Unpacks the image to the images filename.
+               @param mode: One of the values in Blender.Unpackmodes dict.
+               @note: An error will be raised if the image is not packed or the filename path does not exist.
+               @returns: nothing
+               @rtype: none
+               @type mode: int
+               """
+       def makeCurrent():
+               """
+               Set the currently displayed Image from Blenders UV/Image window.
+               When multiple images are displayed, the last active UV/Image windows image is used.
+               @rtype: bool
+               @return: True if the current image could be set, if no window was available, return False.
+               """
+import id_generics
+Image.__doc__ += id_generics.attributes
index 86de771ee2d24b137b102eaceb38aaef0bc11beb..8658f9cda1c8138af452248f4671c23aa5d286b1 100644 (file)
@@ -4,62 +4,62 @@
 The Blender.Ipo submodule
 
 B{New}: 
-  -  Ipo updates to both the program and Bpython access.
-  -  access to Blender's new Ipo driver capabilities.
-  -  Ipo now supports the mapping operator [] to access IpoCurves
+       -  Ipo updates to both the program and Bpython access.
+       -  access to Blender's new Ipo driver capabilities.
+       -  Ipo now supports the mapping operator [] to access IpoCurves
 
 This module provides access to the Ipo Data in Blender. An Ipo is composed of
 several IpoCurves, and an IpoCurve is composed of several BezTriples.
 
 Example::
-  from Blender import Ipo
-
-  ob = Ipo.Get('ObIpo')          # retrieves an Ipo object
-  ob.name = 'ipo1'                              # change the Ipo's name
-  icu = ipo[Ipo.OB_LOCX]         # request X Location Ipo curve object
-  if icu != None and len(icu.bezierPoints) > 0: # if curve exists and has BezTriple points
-     val = icu[2.5]              # get the curve's value at time 2.5
-     icu[Ipo.OB_LOCX] = None     # delete the ipo curve
-  
+       from Blender import Ipo
+
+       ob = Ipo.Get('ObIpo')          # retrieves an Ipo object
+       ob.name = 'ipo1'                                 # change the Ipo's name
+       icu = ipo[Ipo.OB_LOCX]         # request X Location Ipo curve object
+       if icu != None and len(icu.bezierPoints) > 0: # if curve exists and has BezTriple points
+                val = icu[2.5]              # get the curve's value at time 2.5
+                icu[Ipo.OB_LOCX] = None     # delete the ipo curve
+       
 Each type of Ipo has different types Ipocurves.  With the exception of Shape
 Key Ipos, constants are used to specify all Ipocurves.  There are two ways
 to tell which Ipo curves go with which Ipo type:
-  - all constants start with a two-character identifier for their Ipo type;
-  for example, "OB_LOCX" is the LocX curve for an Object Ipo
-  - each Ipo now has a read-only attribute L{Ipo.curveConsts}, which returns 
-  the valid Ipo curve types for that specific Ipo
+       - all constants start with a two-character identifier for their Ipo type;
+       for example, "OB_LOCX" is the LocX curve for an Object Ipo
+       - each Ipo now has a read-only attribute L{Ipo.curveConsts}, which returns 
+       the valid Ipo curve types for that specific Ipo
 
 The valid IpoCurve constants are:
-      1. Material Ipo: MA_R, MA_G, MA_B, MA_SPECR, MA_SPECG, MA_SPECB,
-      MA_MIRR, MA_MIRG, MA_MIRB, MA_REF, MA_ALPHA, MA_EMIT, MA_AMB,
-      MA_SPEC, MA_HARD, MA_SPTRA, MA_IOR, MA_MODE, MA_HASIZE, MA_TRANSLU,
-      MA_RAYMIR, MA_FRESMIR, MA_FRESMIRI, MA_FRESTRA, MA_FRESTRAI,
-      MA_TRAGLOW, MA_OFSX, MA_OFSY, MA_OFSZ, MA_SIZEX, MA_SIZEY, MA_SIZEZ,
-      MA_TEXR, MA_TEXG, MA_TEXB, MA_DEFVAR, MA_COL, MA_NOR, MA_VAR, MA_DISP
-      2. Lamp Ipo: LA_ENERG, LA_R, LA_G, LA_B, LA_DIST, LA_SPOSI, LA_SPOBL,
-      LA_QUAD1, LA_QUAD2, LA_HAINT, LA_OFSX, LA_OFSY, LA_OFSZ, LA_SIZEX,
-      LA_SIZEY, LA_SIZEZ, LA_TEXR, LA_TEXG, LA_TEXB, LA_DEFVAR, LA_COL
-      3. World Ipo: WO_HORR, WO_HORG, WO_HORB, WO_ZENR, WO_ZENG, WO_ZENB,
-      WO_EXPOS, WO_MISI, WO_MISDI, WO_MISSTA, WO_MISHI, WO_STARR,
-      WO_STARB, WO_STARG, WO_STARDI, WO_STARSI, WO_OFSX, WO_OFSY,
-      WO_OFSZ, WO_SIZEX, WO_SIZEY, WO_SIZEZ, WO_TEXR, WO_TEXG,
-      WO_TEXB, WO_DEFVAR, WO_COL, WO_NOR, WO_VAR
-      4. Camera Ipo: CA_LENS, CA_CLSTA, CA_CLEND, CA_APERT, CA_FDIST
-      5. Object Ipo: OB_LOCX, OB_LOCY, OB_LOCZ, OB_DLOCX, OB_DLOCY, OB_DLOCZ,
-      OB_ROTX, OB_ROTY, OB_ROTZ, OB_DROTX, OB_DROTY, OB_DROTZ,
-      OB_SIZEX, OB_SIZEY, OB_SIZEZ, OB_DSIZEX, OB_DSIZEY, OB_DSIZEZ,
-      OB_LAYER, OB_TIME, OB_COLR, OB_COLG, OB_COLB, OB_COLA,
-      OB_FSTRENG, OB_FFALL, OB_RDAMP, OB_DAMPING, OB_PERM
-      6. Curve Ipo: CU_SPEED
-      7. Constraint Ipo: CO_INF
-      8. Texture Ipo: TE_NSIZE, TE_NDEPTH, TE_NTYPE, TE_TURB, TE_VNW1, TE_VNW2,
-      TE_VNW3, TE_VNW4, TE_MINKMEXP, TE_DISTM, TE_COLT, TE_ISCALE,
-      TE_DISTA, TE_MGTYPE, TE_MGH, TE_LACU, TE_OCT, TE_MGOFF,
-      TE_MGGAIN, TE_NBASE1, TE_NBASE2, TE_COLR, TE_COLG, TE_COLB,
-      TE_BRIGHT, TE_CONTRAS
-      9. Pose/Action Ipo: PO_LOCX, PO_LOCY, PO_LOCZ, PO_SIZEX, PO_SIZEY,
-      PO_SIZEZ, PO_QUATW, PO_QUATX, PO_QUATY, PO_QUATZ
-      10. Sequence Ipo: SQ_FAC
+                       1. Material Ipo: MA_R, MA_G, MA_B, MA_SPECR, MA_SPECG, MA_SPECB,
+                       MA_MIRR, MA_MIRG, MA_MIRB, MA_REF, MA_ALPHA, MA_EMIT, MA_AMB,
+                       MA_SPEC, MA_HARD, MA_SPTRA, MA_IOR, MA_MODE, MA_HASIZE, MA_TRANSLU,
+                       MA_RAYMIR, MA_FRESMIR, MA_FRESMIRI, MA_FRESTRA, MA_FRESTRAI,
+                       MA_TRAGLOW, MA_OFSX, MA_OFSY, MA_OFSZ, MA_SIZEX, MA_SIZEY, MA_SIZEZ,
+                       MA_TEXR, MA_TEXG, MA_TEXB, MA_DEFVAR, MA_COL, MA_NOR, MA_VAR, MA_DISP
+                       2. Lamp Ipo: LA_ENERG, LA_R, LA_G, LA_B, LA_DIST, LA_SPOSI, LA_SPOBL,
+                       LA_QUAD1, LA_QUAD2, LA_HAINT, LA_OFSX, LA_OFSY, LA_OFSZ, LA_SIZEX,
+                       LA_SIZEY, LA_SIZEZ, LA_TEXR, LA_TEXG, LA_TEXB, LA_DEFVAR, LA_COL
+                       3. World Ipo: WO_HORR, WO_HORG, WO_HORB, WO_ZENR, WO_ZENG, WO_ZENB,
+                       WO_EXPOS, WO_MISI, WO_MISDI, WO_MISSTA, WO_MISHI, WO_STARR,
+                       WO_STARB, WO_STARG, WO_STARDI, WO_STARSI, WO_OFSX, WO_OFSY,
+                       WO_OFSZ, WO_SIZEX, WO_SIZEY, WO_SIZEZ, WO_TEXR, WO_TEXG,
+                       WO_TEXB, WO_DEFVAR, WO_COL, WO_NOR, WO_VAR
+                       4. Camera Ipo: CA_LENS, CA_CLSTA, CA_CLEND, CA_APERT, CA_FDIST
+                       5. Object Ipo: OB_LOCX, OB_LOCY, OB_LOCZ, OB_DLOCX, OB_DLOCY, OB_DLOCZ,
+                       OB_ROTX, OB_ROTY, OB_ROTZ, OB_DROTX, OB_DROTY, OB_DROTZ,
+                       OB_SIZEX, OB_SIZEY, OB_SIZEZ, OB_DSIZEX, OB_DSIZEY, OB_DSIZEZ,
+                       OB_LAYER, OB_TIME, OB_COLR, OB_COLG, OB_COLB, OB_COLA,
+                       OB_FSTRENG, OB_FFALL, OB_RDAMP, OB_DAMPING, OB_PERM
+                       6. Curve Ipo: CU_SPEED
+                       7. Constraint Ipo: CO_INF
+                       8. Texture Ipo: TE_NSIZE, TE_NDEPTH, TE_NTYPE, TE_TURB, TE_VNW1, TE_VNW2,
+                       TE_VNW3, TE_VNW4, TE_MINKMEXP, TE_DISTM, TE_COLT, TE_ISCALE,
+                       TE_DISTA, TE_MGTYPE, TE_MGH, TE_LACU, TE_OCT, TE_MGOFF,
+                       TE_MGGAIN, TE_NBASE1, TE_NBASE2, TE_COLR, TE_COLG, TE_COLB,
+                       TE_BRIGHT, TE_CONTRAS
+                       9. Pose/Action Ipo: PO_LOCX, PO_LOCY, PO_LOCZ, PO_SIZEX, PO_SIZEY,
+                       PO_SIZEZ, PO_QUATW, PO_QUATX, PO_QUATY, PO_QUATZ
+                       10. Sequence Ipo: SQ_FAC
 
 Shape Key Ipos are handled differently from other Ipos.  The user can rename
 the curves, so string are used to access them instead of constants.  The
@@ -68,371 +68,370 @@ key names.
 """
 
 def New (type, name):
-  """
-  Creates a new Ipo.
-  @type type: string
-  @type name: string
-  @param type: The Ipo's blocktype. Depends on the object the Ipo will be
-      linked to. Currently supported types are Object, Camera, World,
-      Material, Texture, Lamp, Action, Constraint, Sequence, Curve, Key.
-  @param name: The name for this Ipo.
-  @rtype: Blender Ipo
-  @return: The created Ipo.
-  """
+       """
+       Creates a new Ipo.
+       @type type: string
+       @type name: string
+       @param type: The Ipo's blocktype. Depends on the object the Ipo will be
+                       linked to. Currently supported types are Object, Camera, World,
+                       Material, Texture, Lamp, Action, Constraint, Sequence, Curve, Key.
+       @param name: The name for this Ipo.
+       @rtype: Blender Ipo
+       @return: The created Ipo.
+       """
 
 def Get (name = None):
-  """
-  Get the Ipo from Blender.
-  @type name: string
-  @param name: The name of the requested Ipo, or nothing.
-  @rtype: Blender Ipo or a list of Blender Ipos
-  @return: It depends on the 'name' parameter:
-      - (name): The Ipo with the given name;
-      - (): A list with all Ipos in the current scene.
-  """
+       """
+       Get the Ipo from Blender.
+       @type name: string
+       @param name: The name of the requested Ipo, or nothing.
+       @rtype: Blender Ipo or a list of Blender Ipos
+       @return: It depends on the 'name' parameter:
+                       - (name): The Ipo with the given name;
+                       - (): A list with all Ipos in the current scene.
+       """
 
 class Ipo:
-  """
-  The Ipo object
-  ==============
-  This object gives access to Ipo data from all objects in Blender.
-  @Note: Blender Materials, Lamps and Worlds have I{texture channels} which
-  allow the user to assign textures to them.  The Blender Ipo Window allows
-  the user to access the IpoCurves for these channels by specifying a number
-  between 0 and 9 (the number appears next to the Ipo type in the window
-  header).  Prior to Version 2.42, the BPy API did not allow users to access
-  these texture channels in a predictable manner.  A new attribute named
-  L{channel} was added to the API in Version 2.42 to correct this problem.
-
-  The current channel setting has an effect on the operators B{[]}, B{len()} 
-  and others.  For example, suppose a Material has three IpoCurves 
-  (R, G, and B), and two texture channels (numbered 0 and 1), and furthermore
-  channel 0 has one Ipocurve (Col).  The IpoCurve Col can only be
-  "seen" through the API when B{ipo.channel} is 0.  Setting B{ipo.channel} to
-  1 will cause this curve to be ignored by B{len(ipo)}::
-
-    from Blender import Ipo
-
-    ipo = Ipo.Get('MatIpo')
-    for channel in xrange(2):
-        ipo.channel = channel
-        print 'channel is',channel
-           print ' len is',len(ipo)
-        names = dict([(x[1],x[0]) for x in ipo.curveConsts.items()])
-        for curve in [Ipo.MA_R,Ipo.MA_COL]:
-            print ' ',names[curve],'is',curve in ipo
-
-  will output::
-    channel is 0
-    len is 4
-      MA_R is True
-      MA_COL is True
-    channel is 1
-    len is 3
-      MA_R is True
-      MA_COL is False
-
-  @ivar name: The Ipo datablock's name
-  @type name: string
-  @ivar curves: Ipo curves currently defined for the Ipo.
-  @type curves: list of Ipocurves.
-  @ivar curveConsts: The valid Ipo curves for this Ipo.  These can be used
-  by the [] mapping operator.  The value 
-  depends on the Ipo curve type.  If the Ipo is any type other than a Key or
-  Shape Ipo, this attribute returns a set of constants that can be
-  used to specify a particular curve.  For Key or Shape Ipos, the attribute
-  returns a list of all defined keys by name.  
-  @type curveConsts: constant or list of strings. Read-only.
-  @ivar channel: the current texture channel for Blender object which support
-  textures (materials, lamps and worlds).  Returns None if the Ipo does
-  not support texture channels. Value must be in the range [0,9].
-  @type channel: int or None
-  """
-
-  def __contains__():
-    """
-    The "in" operator for Ipos. It returns B{True} if the specified 
-    IpoCurve exists for the Ipo.  This operator B{should not} be used to 
-    test for whether a curve constant is valid for a particular Ipo type.
-    Many constants for different Ipo types have the same value, and it is
-    the constant's value used internally.
-    No exceptions are raised if the argument is not a valid curve constant or
-    or string, nor does the operator return B{True} when the curve
-    constant is valid but does not currently exist.  As such, it should only be
-    used to test for specific curves when the Ipo type is known::
-      ipo = Object.Get('Cube').ipo # get Object-type Ipo 
-      if ipo:
-        print Ipo.OB_LOCX in ipo # prints "True" if 'LocX' curve exists
-        print Ipo.MA_R in ipo    # also prints "True" since MA_R and OB_LOCX are have the same value
-        print 'hiccup' in ipo    # always prints "False" since argument is not a constant
-
-    @return: see above.
-    @rtype: Boolean
-    """
-
-  def __getitem__():
-    """
-    This operator is similar to the Python dictionary mapping operator [],
-    except that the user cannot assign arbitrary keys.  Each Ipo type has
-    a pre-defined set of IpoCurves which may or may not exist at a given time.      This operator
-    will either return an IpoCurve object if the specified curve exists,
-    return None if the curve does not exists, or throws a KeyError exception
-    if the curve is not valid for this Ipo type.
-    @return: an IpoCurve object if it exists
-    @rtype: IpoCurve or None
-    @raise KeyError: an undefined IpoCurve was specified for the Ipo
-    """
-
-  def __iter__():
-    """
-    Iterator for Ipos.  It returns all the defined IpoCurve objects associated 
-    with the Ipo.  For example::
-       from Blender import Ipo
-
-       ipo = Ipo.Get()
-       if len(ipo) > 0:
-         ipo = ipo[0]
-         print 'ipo name is',ipo.name
-         for icu in ipo:
-           print ' curve name is',icu.name
-    might result in::
-       ipo name is ObIpo
-         curve name is LocX
-         curve name is LocY
-         curve name is LocZ
-
-    @return: an IpoCurve object
-    @rtype: IpoCurve
-    """
-
-  def __len__():
-    """
-    Returns the number of curves defined for the Ipo.
-    @return: number of defined IpoCurves
-    @rtype: int
-    """
-
-  def getName():
-    """
-    Gets the name of the Ipo (B{deprecated}).  See the L{name} attribute.
-    @rtype: string
-    @return: the name of the Ipo.
-    """
-
-  def setName(newname):
-    """
-    Sets the name of the Ipo (B{deprecated}).  See the L{name} attribute.
-    @type newname: string
-    @rtype: None
-    @return: None
-    """
-
-  def getCurves():
-    """
-    Gets all the IpoCurves of the Ipo (B{deprecated}).  Use the
-    L{iterator operator []<__iter__>} instead.
-    @rtype: list of IpoCurves
-    @return: A list (possibly empty) containing all the IpoCurves associated
-    to the Ipo object.
-    """
-
-  def getCurve(curve):
-    """
-    Return the specified IpoCurve (B{deprecated}).  Use the L{mapping
-    operator B{[]}<__getitem__>} instead.
-    If the curve does not exist in the Ipo,
-    None is returned.  I{curve} can be either a string or an integer,
-    denoting either the name of the Ipo curve or its internal adrcode.
-    The possible Ipo curve names are:
-    
-      1. Camera Ipo:  Lens, ClSta, ClEnd, Apert, FDist.
-      2. Material Ipo: R, G, B, SpecR, SpecG, SpecB, MirR, MirG, MirB, Ref,
-      Alpha, Emit, Amb, Spec, Hard, SpTra, Ior, Mode, HaSize, Translu,
-      RayMir, FresMir, FresMirI, FresTra, FresTraI, TraGlow, OfsX, OfsY,
-      OfsZ, SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var,
-      Disp.
-      3. Object Ipo: LocX, LocY, LocZ, dLocX, dLocY, dLocZ, RotX, RotY, RotZ,
-      dRotX, dRotY, dRotZ, SizeX, SizeY, SizeZ, dSizeX, dSizeY, dSizeZ,
-      Layer, Time, ColR, ColG, ColB, ColA, FStreng, FFall, Damping,
-      RDamp, Perm.
-      4. Lamp Ipo: Energ, R, G, B, Dist, SpoSi, SpoBl, Quad1, Quad2, HaInt.
-      5. World Ipo: HorR, HorG, HorB, ZenR, ZenG, ZenB, Expos, Misi, MisDi,
-      MisSta, MisHi, StaR, StaG, StaB, StarDi, StarSi, OfsX, OfsY, OfsZ,
-      SizeX, SizeY, SizeZ, TexR, TexG, TexB, DefVar, Col, Nor, Var.
-      5. World Ipo: HorR, HorG, HorB, ZenR, ZenG, ZenB, Expos, Misi, MisDi,
-      MisSta, MisHi, StarR, StarB, StarG, StarDi, StarSi, OfsX, OfsY, OfsZ,i
-      SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var.
-      6. Texture Ipo: NSize, NDepth, NType, Turb, Vnw1, Vnw2, Vnw3, Vnw4,
-      MinkMExp, DistM, ColT, iScale, DistA, MgType, MgH, Lacu, Oct,
-      MgOff, MgGain, NBase1, NBase2.
-      7. Curve Ipo: Speed.
-      8. Action Ipo: LocX, LocY, LocZ, SizeX, SizeY, SizeZ, QuatX, QuatY,
-      QuatZ, QuatW.
-      9. Sequence Ipo: Fac.
-      10. Constraint Ipo: Inf.
-
-    The adrcode for the Ipo curve can also be given; this is useful for
-    accessing curves for Shape Key Ipos.  The adrcodes for Shape Key Ipo are
-    numbered consecutively starting at 0.
-    @type curve : string or int
-    @rtype: IpoCurve object
-    @return: the corresponding IpoCurve, or None.
-    @raise ValueError: I{curve} is not a valid name or adrcode for this Ipo
-    type.
-    """
-
-  def addCurve(curvename):
-    """
-    Add a new curve to the Ipo object. The possible values for I{curvename} are:
-      1. Camera Ipo:  Lens, ClSta, ClEnd, Apert, FDist.
-      2. Material Ipo: R, G, B, SpecR, SpecG, SpecB, MirR, MirG, MirB, Ref,
-      Alpha, Emit, Amb, Spec, Hard, SpTra, Ior, Mode, HaSize, Translu,
-      RayMir, FresMir, FresMirI, FresTra, FresTraI, TraGlow, OfsX, OfsY,
-      OfsZ, SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var,
-      Disp.
-      3. Object Ipo: LocX, LocY, LocZ, dLocX, dLocY, dLocZ, RotX, RotY, RotZ,
-      dRotX, dRotY, dRotZ, SizeX, SizeY, SizeZ, dSizeX, dSizeY, dSizeZ,
-      Layer, Time, ColR, ColG, ColB, ColA, FStreng, FFall, Damping,
-      RDamp, Perm.
-      4. Lamp Ipo: Energ, R, G, B, Dist, SpoSi, SpoBl, Quad1, Quad2, HaInt.
-      5. World Ipo: HorR, HorG, HorB, ZenR, ZenG, ZenB, Expos, Misi, MisDi,
-      MisSta, MisHi, StaR, StaG, StaB, StarDi, StarSi, OfsX, OfsY, OfsZ,
-      SizeX, SizeY, SizeZ, TexR, TexG, TexB, DefVar, Col, Nor, Var.
-      5. World Ipo: HorR, HorG, HorB, ZenR, ZenG, ZenB, Expos, Misi, MisDi,
-      MisSta, MisHi, StarR, StarB, StarG, StarDi, StarSi, OfsX, OfsY, OfsZ,i
-      SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var.
-      6. Texture Ipo: NSize, NDepth, NType, Turb, Vnw1, Vnw2, Vnw3, Vnw4,
-      MinkMExp, DistM, ColT, iScale, DistA, MgType, MgH, Lacu, Oct,
-      MgOff, MgGain, NBase1, NBase2.
-      7. Curve Ipo: Speed.
-      8. Action Ipo: LocX, LocY, LocZ, SizeX, SizeY, SizeZ, QuatX, QuatY,
-      QuatZ, QuatW.
-      9. Sequence Ipo: Fac.
-      10. Constraint Ipo: Inf.
-
-    For Key IPOs, the name must be an existing KeyBlock name.  Use
-    L{curveConsts} to determine the set of valid names.
-
-    @type curvename : string
-    @rtype: IpoCurve object
-    @return: the corresponding IpoCurve, or None.
-    @raise ValueError: I{curvename} is not valid or already exists
-    """
-
-  def delCurve(curvename):
-    """
-    Delete an existing curve from the Ipo object (B{deprecated}).
-    Use the L{mapping operator B{[]}<__getitem__>} instead::
-       from Blender import Ipo
-
-       ipo = Ipo.Get('ObIpo')
-       ipo[Ipo.LOCX] = None
-
-    @type curvename : string
-    @rtype: None
-    @return: None.
-    """
-
-  def getBlocktype():
-    """
-    Gets the blocktype of the Ipo.
-    @rtype: int
-    @return: the blocktype of the Ipo.
-    """
-
-  def setBlocktype(newblocktype):
-    """
-    Sets the blocktype of the Ipo.
-    @type newblocktype: int 
-    @rtype: None
-    @return: None
-    @warn: 'newblocktype' should not be changed unless you really know what
-       you are doing ...
-    """
-
-  def getRctf():
-    """
-    Gets the rctf of the Ipo.
-    Kind of bounding box...
-    @rtype: list of floats
-    @return: the rctf of the Ipo.
-    """
-
-  def setRctf(newrctf):
-    """
-    Sets the rctf of the Ipo.
-    @type newrctf: four floats.
-    @rtype: None
-    @return: None
-    @warn: rctf should not be changed unless you really know what you are
-       doing ...
-    """
-
-  def getNcurves():
-    """
-    Gets the number of curves of the Ipo (B{deprecated}).  Use
-    L{len(ipo)<__len__>} instead.
-    @rtype: int 
-    @return: the number of curve of the Ipo.
-    """
-    
-  def getCurveBP(curvepos):
-    """
-    This method is unsupported.  BPoint Ipo curves are not implemented.
-    Calling this method throws a NotImplementedError exception.
-    @raise NotImplementedError: this method B{always} raises an exception
-    """
-  def getBeztriple(curvepos,pointpos):
-    """
-    Gets a beztriple of the Ipo (B{deprecated}).  B{Note}:
-    Use L{IpoCurve.bezierPoints<IpoCurve.IpoCurve.bezierPoints>} instead.
-    @type curvepos: int
-    @param curvepos: the position of the curve in the Ipo.
-    @type pointpos: int
-    @param pointpos: the position of the point in the curve.
-    @rtype: list of 9 floats
-    @return: the beztriple of the Ipo, or an error is raised.
-    """
-
-  def setBeztriple(curvepos,pointpos,newbeztriple):
-    """
-    Sets the beztriple of the Ipo (B{deprecated}).  B{Note}: use 
-    L{IpoCurve.bezierPoints<IpoCurve.IpoCurve.bezierPoints>} to get a
-    BezTriple point, then use the
-    L{BezTriple} API to set the point's attributes.
-    @type curvepos: int
-    @param curvepos: the position of the curve in the Ipo.
-    @type pointpos: int
-    @param pointpos: the position of the point in the curve.
-    @type newbeztriple: list of 9 floats
-    @param newbeztriple: the new value for the point
-    @rtype: None
-    @return: None
-    """
-    
-  def getCurveCurval(curvepos):
-    """
-    Gets the current value of a curve of the Ipo (B{deprecated}). B{Note}:
-    new scripts should use L{IpoCurve.evaluate()<IpoCurve.IpoCurve.evaluate>}.
-    @type curvepos: int or string
-    @param curvepos: the position of the curve in the Ipo or the name of the
-        curve
-    @rtype: float
-    @return: the current value of the selected curve of the Ipo.
-    """
-
-  def EvaluateCurveOn(curvepos,time):
-    """
-    Gets the value at a specific time of a curve of the Ipo (B{deprecated}).
-    B{Note}: new scripts should use 
-    L{IpoCurve.evaluate()<IpoCurve.IpoCurve.evaluate>}.
-    @type curvepos: int
-    @param curvepos: the position of the curve in the Ipo.
-    @type time: float
-    @param time: the desired time.
-    @rtype: float
-    @return: the current value of the selected curve of the Ipo at the given
-    time.
-    """
-
+       """
+       The Ipo object
+       ==============
+       This object gives access to Ipo data from all objects in Blender.
+       @Note: Blender Materials, Lamps and Worlds have I{texture channels} which
+       allow the user to assign textures to them.  The Blender Ipo Window allows
+       the user to access the IpoCurves for these channels by specifying a number
+       between 0 and 9 (the number appears next to the Ipo type in the window
+       header).  Prior to Version 2.42, the BPy API did not allow users to access
+       these texture channels in a predictable manner.  A new attribute named
+       L{channel} was added to the API in Version 2.42 to correct this problem.
+
+       The current channel setting has an effect on the operators B{[]}, B{len()} 
+       and others.  For example, suppose a Material has three IpoCurves 
+       (R, G, and B), and two texture channels (numbered 0 and 1), and furthermore
+       channel 0 has one Ipocurve (Col).  The IpoCurve Col can only be
+       "seen" through the API when B{ipo.channel} is 0.  Setting B{ipo.channel} to
+       1 will cause this curve to be ignored by B{len(ipo)}::
+
+               from Blender import Ipo
+
+               ipo = Ipo.Get('MatIpo')
+               for channel in xrange(2):
+                               ipo.channel = channel
+                               print 'channel is',channel
+                               print ' len is',len(ipo)
+                               names = dict([(x[1],x[0]) for x in ipo.curveConsts.items()])
+                               for curve in [Ipo.MA_R,Ipo.MA_COL]:
+                                               print ' ',names[curve],'is',curve in ipo
+
+       will output::
+               channel is 0
+               len is 4
+                       MA_R is True
+                       MA_COL is True
+               channel is 1
+               len is 3
+                       MA_R is True
+                       MA_COL is False
+
+       @ivar curves: Ipo curves currently defined for the Ipo.
+       @type curves: list of Ipocurves.
+       @ivar curveConsts: The valid Ipo curves for this Ipo.  These can be used
+       by the [] mapping operator.  The value 
+       depends on the Ipo curve type.  If the Ipo is any type other than a Key or
+       Shape Ipo, this attribute returns a set of constants that can be
+       used to specify a particular curve.  For Key or Shape Ipos, the attribute
+       returns a list of all defined keys by name.  
+       @type curveConsts: constant or list of strings. Read-only.
+       @ivar channel: the current texture channel for Blender object which support
+       textures (materials, lamps and worlds).  Returns None if the Ipo does
+       not support texture channels. Value must be in the range [0,9].
+       @type channel: int or None
+       """
+
+       def __contains__():
+               """
+               The "in" operator for Ipos. It returns B{True} if the specified 
+               IpoCurve exists for the Ipo.  This operator B{should not} be used to 
+               test for whether a curve constant is valid for a particular Ipo type.
+               Many constants for different Ipo types have the same value, and it is
+               the constant's value used internally.
+               No exceptions are raised if the argument is not a valid curve constant or
+               or string, nor does the operator return B{True} when the curve
+               constant is valid but does not currently exist.  As such, it should only be
+               used to test for specific curves when the Ipo type is known::
+                       ipo = Object.Get('Cube').ipo # get Object-type Ipo 
+                       if ipo:
+                               print Ipo.OB_LOCX in ipo # prints "True" if 'LocX' curve exists
+                               print Ipo.MA_R in ipo    # also prints "True" since MA_R and OB_LOCX are have the same value
+                               print 'hiccup' in ipo    # always prints "False" since argument is not a constant
+
+               @return: see above.
+               @rtype: Boolean
+               """
+
+       def __getitem__():
+               """
+               This operator is similar to the Python dictionary mapping operator [],
+               except that the user cannot assign arbitrary keys.  Each Ipo type has
+               a pre-defined set of IpoCurves which may or may not exist at a given time.      This operator
+               will either return an IpoCurve object if the specified curve exists,
+               return None if the curve does not exists, or throws a KeyError exception
+               if the curve is not valid for this Ipo type.
+               @return: an IpoCurve object if it exists
+               @rtype: IpoCurve or None
+               @raise KeyError: an undefined IpoCurve was specified for the Ipo
+               """
+
+       def __iter__():
+               """
+               Iterator for Ipos.  It returns all the defined IpoCurve objects associated 
+               with the Ipo.  For example::
+                       from Blender import Ipo
+
+                       ipo = Ipo.Get()
+                       if len(ipo) > 0:
+                               ipo = ipo[0]
+                               print 'ipo name is',ipo.name
+                               for icu in ipo:
+                                       print ' curve name is',icu.name
+               might result in::
+                       ipo name is ObIpo
+                               curve name is LocX
+                               curve name is LocY
+                               curve name is LocZ
+
+               @return: an IpoCurve object
+               @rtype: IpoCurve
+               """
+
+       def __len__():
+               """
+               Returns the number of curves defined for the Ipo.
+               @return: number of defined IpoCurves
+               @rtype: int
+               """
+
+       def getName():
+               """
+               Gets the name of the Ipo (B{deprecated}).  See the L{name} attribute.
+               @rtype: string
+               @return: the name of the Ipo.
+               """
+
+       def setName(newname):
+               """
+               Sets the name of the Ipo (B{deprecated}).  See the L{name} attribute.
+               @type newname: string
+               @rtype: None
+               @return: None
+               """
+
+       def getCurves():
+               """
+               Gets all the IpoCurves of the Ipo (B{deprecated}).  Use the
+               L{iterator operator []<__iter__>} instead.
+               @rtype: list of IpoCurves
+               @return: A list (possibly empty) containing all the IpoCurves associated
+               to the Ipo object.
+               """
+
+       def getCurve(curve):
+               """
+               Return the specified IpoCurve (B{deprecated}).  Use the L{mapping
+               operator B{[]}<__getitem__>} instead.
+               If the curve does not exist in the Ipo,
+               None is returned.  I{curve} can be either a string or an integer,
+               denoting either the name of the Ipo curve or its internal adrcode.
+               The possible Ipo curve names are:
+               
+                       1. Camera Ipo:  Lens, ClSta, ClEnd, Apert, FDist.
+                       2. Material Ipo: R, G, B, SpecR, SpecG, SpecB, MirR, MirG, MirB, Ref,
+                       Alpha, Emit, Amb, Spec, Hard, SpTra, Ior, Mode, HaSize, Translu,
+                       RayMir, FresMir, FresMirI, FresTra, FresTraI, TraGlow, OfsX, OfsY,
+                       OfsZ, SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var,
+                       Disp.
+                       3. Object Ipo: LocX, LocY, LocZ, dLocX, dLocY, dLocZ, RotX, RotY, RotZ,
+                       dRotX, dRotY, dRotZ, SizeX, SizeY, SizeZ, dSizeX, dSizeY, dSizeZ,
+                       Layer, Time, ColR, ColG, ColB, ColA, FStreng, FFall, Damping,
+                       RDamp, Perm.
+                       4. Lamp Ipo: Energ, R, G, B, Dist, SpoSi, SpoBl, Quad1, Quad2, HaInt.
+                       5. World Ipo: HorR, HorG, HorB, ZenR, ZenG, ZenB, Expos, Misi, MisDi,
+                       MisSta, MisHi, StaR, StaG, StaB, StarDi, StarSi, OfsX, OfsY, OfsZ,
+                       SizeX, SizeY, SizeZ, TexR, TexG, TexB, DefVar, Col, Nor, Var.
+                       5. World Ipo: HorR, HorG, HorB, ZenR, ZenG, ZenB, Expos, Misi, MisDi,
+                       MisSta, MisHi, StarR, StarB, StarG, StarDi, StarSi, OfsX, OfsY, OfsZ,i
+                       SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var.
+                       6. Texture Ipo: NSize, NDepth, NType, Turb, Vnw1, Vnw2, Vnw3, Vnw4,
+                       MinkMExp, DistM, ColT, iScale, DistA, MgType, MgH, Lacu, Oct,
+                       MgOff, MgGain, NBase1, NBase2.
+                       7. Curve Ipo: Speed.
+                       8. Action Ipo: LocX, LocY, LocZ, SizeX, SizeY, SizeZ, QuatX, QuatY,
+                       QuatZ, QuatW.
+                       9. Sequence Ipo: Fac.
+                       10. Constraint Ipo: Inf.
+
+               The adrcode for the Ipo curve can also be given; this is useful for
+               accessing curves for Shape Key Ipos.  The adrcodes for Shape Key Ipo are
+               numbered consecutively starting at 0.
+               @type curve : string or int
+               @rtype: IpoCurve object
+               @return: the corresponding IpoCurve, or None.
+               @raise ValueError: I{curve} is not a valid name or adrcode for this Ipo
+               type.
+               """
+
+       def addCurve(curvename):
+               """
+               Add a new curve to the Ipo object. The possible values for I{curvename} are:
+                       1. Camera Ipo:  Lens, ClSta, ClEnd, Apert, FDist.
+                       2. Material Ipo: R, G, B, SpecR, SpecG, SpecB, MirR, MirG, MirB, Ref,
+                       Alpha, Emit, Amb, Spec, Hard, SpTra, Ior, Mode, HaSize, Translu,
+                       RayMir, FresMir, FresMirI, FresTra, FresTraI, TraGlow, OfsX, OfsY,
+                       OfsZ, SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var,
+                       Disp.
+                       3. Object Ipo: LocX, LocY, LocZ, dLocX, dLocY, dLocZ, RotX, RotY, RotZ,
+                       dRotX, dRotY, dRotZ, SizeX, SizeY, SizeZ, dSizeX, dSizeY, dSizeZ,
+                       Layer, Time, ColR, ColG, ColB, ColA, FStreng, FFall, Damping,
+                       RDamp, Perm.
+                       4. Lamp Ipo: Energ, R, G, B, Dist, SpoSi, SpoBl, Quad1, Quad2, HaInt.
+                       5. World Ipo: HorR, HorG, HorB, ZenR, ZenG, ZenB, Expos, Misi, MisDi,
+                       MisSta, MisHi, StaR, StaG, StaB, StarDi, StarSi, OfsX, OfsY, OfsZ,
+                       SizeX, SizeY, SizeZ, TexR, TexG, TexB, DefVar, Col, Nor, Var.
+                       5. World Ipo: HorR, HorG, HorB, ZenR, ZenG, ZenB, Expos, Misi, MisDi,
+                       MisSta, MisHi, StarR, StarB, StarG, StarDi, StarSi, OfsX, OfsY, OfsZ,i
+                       SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var.
+                       6. Texture Ipo: NSize, NDepth, NType, Turb, Vnw1, Vnw2, Vnw3, Vnw4,
+                       MinkMExp, DistM, ColT, iScale, DistA, MgType, MgH, Lacu, Oct,
+                       MgOff, MgGain, NBase1, NBase2.
+                       7. Curve Ipo: Speed.
+                       8. Action Ipo: LocX, LocY, LocZ, SizeX, SizeY, SizeZ, QuatX, QuatY,
+                       QuatZ, QuatW.
+                       9. Sequence Ipo: Fac.
+                       10. Constraint Ipo: Inf.
+
+               For Key IPOs, the name must be an existing KeyBlock name.  Use
+               L{curveConsts} to determine the set of valid names.
+
+               @type curvename : string
+               @rtype: IpoCurve object
+               @return: the corresponding IpoCurve, or None.
+               @raise ValueError: I{curvename} is not valid or already exists
+               """
+
+       def delCurve(curvename):
+               """
+               Delete an existing curve from the Ipo object (B{deprecated}).
+               Use the L{mapping operator B{[]}<__getitem__>} instead::
+                        from Blender import Ipo
+
+                        ipo = Ipo.Get('ObIpo')
+                        ipo[Ipo.LOCX] = None
+
+               @type curvename : string
+               @rtype: None
+               @return: None.
+               """
+
+       def getBlocktype():
+               """
+               Gets the blocktype of the Ipo.
+               @rtype: int
+               @return: the blocktype of the Ipo.
+               """
+
+       def setBlocktype(newblocktype):
+               """
+               Sets the blocktype of the Ipo.
+               @type newblocktype: int 
+               @rtype: None
+               @return: None
+               @warn: 'newblocktype' should not be changed unless you really know what
+                        you are doing ...
+               """
+
+       def getRctf():
+               """
+               Gets the rctf of the Ipo.
+               Kind of bounding box...
+               @rtype: list of floats
+               @return: the rctf of the Ipo.
+               """
+
+       def setRctf(newrctf):
+               """
+               Sets the rctf of the Ipo.
+               @type newrctf: four floats.
+               @rtype: None
+               @return: None
+               @warn: rctf should not be changed unless you really know what you are
+                        doing ...
+               """
+
+       def getNcurves():
+               """
+               Gets the number of curves of the Ipo (B{deprecated}).  Use
+               L{len(ipo)<__len__>} instead.
+               @rtype: int 
+               @return: the number of curve of the Ipo.
+               """
+               
+       def getCurveBP(curvepos):
+               """
+               This method is unsupported.  BPoint Ipo curves are not implemented.
+               Calling this method throws a NotImplementedError exception.
+               @raise NotImplementedError: this method B{always} raises an exception
+               """
+
+       def getBeztriple(curvepos,pointpos):
+               """
+               Gets a beztriple of the Ipo (B{deprecated}).  B{Note}:
+               Use L{IpoCurve.bezierPoints<IpoCurve.IpoCurve.bezierPoints>} instead.
+               @type curvepos: int
+               @param curvepos: the position of the curve in the Ipo.
+               @type pointpos: int
+               @param pointpos: the position of the point in the curve.
+               @rtype: list of 9 floats
+               @return: the beztriple of the Ipo, or an error is raised.
+               """
+
+       def setBeztriple(curvepos,pointpos,newbeztriple):
+               """
+               Sets the beztriple of the Ipo (B{deprecated}).  B{Note}: use 
+               L{IpoCurve.bezierPoints<IpoCurve.IpoCurve.bezierPoints>} to get a
+               BezTriple point, then use the
+               L{BezTriple} API to set the point's attributes.
+               @type curvepos: int
+               @param curvepos: the position of the curve in the Ipo.
+               @type pointpos: int
+               @param pointpos: the position of the point in the curve.
+               @type newbeztriple: list of 9 floats
+               @param newbeztriple: the new value for the point
+               @rtype: None
+               @return: None
+               """
+               
+       def getCurveCurval(curvepos):
+               """
+               Gets the current value of a curve of the Ipo (B{deprecated}). B{Note}:
+               new scripts should use L{IpoCurve.evaluate()<IpoCurve.IpoCurve.evaluate>}.
+               @type curvepos: int or string
+               @param curvepos: the position of the curve in the Ipo or the name of the
+                               curve
+               @rtype: float
+               @return: the current value of the selected curve of the Ipo.
+               """
+
+       def EvaluateCurveOn(curvepos,time):
+               """
+               Gets the value at a specific time of a curve of the Ipo (B{deprecated}).
+               B{Note}: new scripts should use 
+               L{IpoCurve.evaluate()<IpoCurve.IpoCurve.evaluate>}.
+               @type curvepos: int
+               @param curvepos: the position of the curve in the Ipo.
+               @type time: float
+               @param time: the desired time.
+               @rtype: float
+               @return: the current value of the selected curve of the Ipo at the given
+               time.
+               """
+import id_generics
+Ipo.__doc__ += id_generics.attributes
index d3dddc104ce859fe59d018757ddf796499b75f4d..584a7f066b14ce8538ba3dfde3a74c4a6dc3a4a1 100644 (file)
@@ -8,97 +8,97 @@ This module provides access to B{Key} objects in Blender.
 @type Types: readonly dictionary
 @var Types: The type of a key owner, indicating the type of data in the
 data blocks.
-    - MESH - the key is a Mesh key; data blocks contain
-    L{NMVert<NMesh.NMVert>} vertices.
-    - CURVE - the key is a Curve key; data blocks contains either
-    L{BezTriples<BezTriple.BezTriple>} or points (represented by a list of
-    3 floating point numbers).
-    - LATTICE - the key is a Lattice key; data blocks contain
-    BPoints, each point represented by a list of 3 floating point numbers.
+       - MESH - the key is a Mesh key; data blocks contain
+       L{NMVert<NMesh.NMVert>} vertices.
+       - CURVE - the key is a Curve key; data blocks contains either
+       L{BezTriples<BezTriple.BezTriple>} or points (represented by a list of
+       3 floating point numbers).
+       - LATTICE - the key is a Lattice key; data blocks contain
+       BPoints, each point represented by a list of 3 floating point numbers.
 """
 
 def Get(name = None):
-    """
-    Get the named Key object from Blender. If the name is omitted, it
-    will retrieve a list of all keys in Blender.
-    @type name: string
-    @param name: the name of the requested key
-    @return: If name was given, return that Key object (or None if not
-    found). If a name was not given, return a list of every Key object
-    in Blender.
-    """
+       """
+       Get the named Key object from Blender. If the name is omitted, it
+       will retrieve a list of all keys in Blender.
+       @type name: string
+       @param name: the name of the requested key
+       @return: If name was given, return that Key object (or None if not
+       found). If a name was not given, return a list of every Key object
+       in Blender.
+       """
 
 class Key:
-    """
-    The Key object
-    ==============
-    An object with keyframes (L{Lattice}, L{NMesh} or
-    L{Curve}) will contain a Key object representing the
-    keyframe data.
-    
-    @ivar ipo:  Key Ipo.  Contains the Ipo if one is assigned to the
-    object, B{None} otherwise.  Setting to B{None} clears the current Ipo.
-    @type ipo:  Blender Ipo
-    @ivar value: The value of the key. Read-only.
-    @type value: float
-    @ivar type: An integer from the L{Types} dictionary
-    representing the Key type.  Read-only.
-    @type type: int
-    @ivar blocks: A list of KeyBlocks for the key.  Read-only.
-    @type blocks: Blender KeyBlock.
-    @ivar relative: Indicates whether the key is relative(=True) or normal.
-    @type relative: bool
-    """
+       """
+       The Key object
+       ==============
+       An object with keyframes (L{Lattice}, L{NMesh} or
+       L{Curve}) will contain a Key object representing the
+       keyframe data.
+       
+       @ivar ipo:  Key Ipo.  Contains the Ipo if one is assigned to the
+       object, B{None} otherwise.  Setting to B{None} clears the current Ipo.
+       @type ipo:  Blender Ipo
+       @ivar value: The value of the key. Read-only.
+       @type value: float
+       @ivar type: An integer from the L{Types} dictionary
+       representing the Key type.  Read-only.
+       @type type: int
+       @ivar blocks: A list of KeyBlocks for the key.  Read-only.
+       @type blocks: Blender KeyBlock.
+       @ivar relative: Indicates whether the key is relative(=True) or normal.
+       @type relative: bool
+       """
 
-    def getIpo():
-        """
-        Get the L{Ipo} object associated with this key.
-        """
-    def getBlocks():
-        """
-        Get a list of L{KeyBlock}s, containing the keyframes defined for
-        this Key.
-        """
+       def getIpo():
+               """
+               Get the L{Ipo} object associated with this key.
+               """
+       def getBlocks():
+               """
+               Get a list of L{KeyBlock}s, containing the keyframes defined for
+               this Key.
+               """
 
 class KeyBlock:
-  """  
-  The KeyBlock object
-  ===================
-  Each Key object has a list of KeyBlocks attached, each KeyBlock
-  representing a keyframe.
+       """     
+       The KeyBlock object
+       ===================
+       Each Key object has a list of KeyBlocks attached, each KeyBlock
+       representing a keyframe.
 
-  @ivar curval: Current value of the corresponding IpoCurve.  Read-only.
-  @type curval: float
-  @ivar name: The name of the Keyblock.  Truncated to 32 characters.
-  @type name: string
-  @ivar pos: The position of the keyframe.
-  @type pos: float
-  @ivar slidermin: The minimum value for the action slider.
-  Value is clamped to the range [-10.0,10.0].
-  @type slidermin: float
-  @ivar slidermax: The maximum value for the action slider.
-  Value is clamped to the range [-10.0,10.0].
-  @type slidermax: float
-  @ivar vgroup: The assigned VGroup for the Key Block.
-  @type vgroup: string
-  @ivar data: The data of the KeyBlock (see L{getData}). This
-  attribute is read-only.
-  @type data: varies
-  """
+       @ivar curval: Current value of the corresponding IpoCurve.  Read-only.
+       @type curval: float
+       @ivar name: The name of the Keyblock.  Truncated to 32 characters.
+       @type name: string
+       @ivar pos: The position of the keyframe.
+       @type pos: float
+       @ivar slidermin: The minimum value for the action slider.
+       Value is clamped to the range [-10.0,10.0].
+       @type slidermin: float
+       @ivar slidermax: The maximum value for the action slider.
+       Value is clamped to the range [-10.0,10.0].
+       @type slidermax: float
+       @ivar vgroup: The assigned VGroup for the Key Block.
+       @type vgroup: string
+       @ivar data: The data of the KeyBlock (see L{getData}). This
+       attribute is read-only.
+       @type data: varies
+       """
 
-  def getData():
-    """
-    Get the data of a KeyBlock, as a list of data items. Each item
-    will have a different data type depending on the type of this
-    Key.
-      - Mesh keys have a list of L{NMVert<NMesh.NMVert>} objects in the data
-      block.
-      - Lattice keys have a list of BPoints in the data block. These
-      don't have corresponding Python objects yet, so each BPoint is
-      represented using a list of three floating-point numbers (the
-      coordinate for each lattice vertex).
-      - Curve keys return either a list of L{BezTriple<BezTriple.BezTriple>}
-      objects in the data if the curve is a Bezier curve, otherwise it 
-      returns lists of three floats for each NURB or poly coordinate.
-    """
+       def getData():
+               """
+               Get the data of a KeyBlock, as a list of data items. Each item
+               will have a different data type depending on the type of this
+               Key.
+                       - Mesh keys have a list of L{NMVert<NMesh.NMVert>} objects in the data
+                       block.
+                       - Lattice keys have a list of BPoints in the data block. These
+                       don't have corresponding Python objects yet, so each BPoint is
+                       represented using a list of three floating-point numbers (the
+                       coordinate for each lattice vertex).
+                       - Curve keys return either a list of L{BezTriple<BezTriple.BezTriple>}
+                       objects in the data if the curve is a Bezier curve, otherwise it 
+                       returns lists of three floats for each NURB or poly coordinate.
+               """
 
index 865cf7a152fc4f28a84dc56d5cfc25175f5e655a..b65fe253530fd1ffb0f4c840fab4fca45c65e52f 100644 (file)
@@ -12,511 +12,510 @@ This module provides control over B{Lamp Data} objects in Blender.
 
 Example::
 
-  from Blender import Lamp, Scene
-  l = Lamp.New('Spot')            # create new 'Spot' lamp data
-  l.setMode('Square', 'Shadow')   # set these two lamp mode flags
-  scn = Scene.GetCurrent()
-  ob = scn.objects.new(l)
+       from Blender import Lamp, Scene
+       l = Lamp.New('Spot')            # create new 'Spot' lamp data
+       l.setMode('Square', 'Shadow')   # set these two lamp mode flags
+       scn = Scene.GetCurrent()
+       ob = scn.objects.new(l)
 
 @type Types: read-only dictionary
 @var Types: The lamp types.
-  - 'Lamp': 0
-  - 'Sun' : 1
-  - 'Spot': 2
-  - 'Hemi': 3
-  - 'Area': 4
-  - 'Photon': 5
+       - 'Lamp': 0
+       - 'Sun' : 1
+       - 'Spot': 2
+       - 'Hemi': 3
+       - 'Area': 4
+       - 'Photon': 5
 @type Modes: read-only dictionary
 @var Modes: The lamp modes.  Modes may be ORed together.
-  - 'Shadows'
-  - 'Halo'
-  - 'Layer'
-  - 'Quad'
-  - 'Negative'
-  - 'OnlyShadow'
-  - 'Sphere'
-  - 'Square'
-  - 'NoDiffuse'
-  - 'NoSpecular'
-  - 'RayShadow'
-
-  Example::
-    from Blender import Lamp, Object
-    # Change the mode of selected lamp objects.
-    for ob in Object.GetSelected():   # Loop through the current selection
-      if ob.getType() == "Lamp":      # if this is a lamp.
-        lamp = ob.getData()           # get the lamp data.
-        if lamp.type == Lamp.Types["Spot"]:  # Lamp type is not a flag
-          lamp.mode &= ~Lamp.Modes["RayShadow"] # Disable RayShadow.
-          lamp.mode |= Lamp.Modes["Shadows"]    # Enable Shadowbuffer shadows
+       - 'Shadows'
+       - 'Halo'
+       - 'Layer'
+       - 'Quad'
+       - 'Negative'
+       - 'OnlyShadow'
+       - 'Sphere'
+       - 'Square'
+       - 'NoDiffuse'
+       - 'NoSpecular'
+       - 'RayShadow'
+
+       Example::
+               from Blender import Lamp, Object
+               # Change the mode of selected lamp objects.
+               for ob in Object.GetSelected():   # Loop through the current selection
+                       if ob.getType() == "Lamp":      # if this is a lamp.
+                               lamp = ob.getData()           # get the lamp data.
+                               if lamp.type == Lamp.Types["Spot"]:  # Lamp type is not a flag
+                                       lamp.mode &= ~Lamp.Modes["RayShadow"] # Disable RayShadow.
+                                       lamp.mode |= Lamp.Modes["Shadows"]    # Enable Shadowbuffer shadows
 """
 
 def New (type = 'Lamp', name = 'LampData'):
-  """
-  Create a new Lamp Data object.
-  @type type: string
-  @param type: The Lamp type: 'Lamp', 'Sun', 'Spot', 'Hemi', 'Area', or 'Photon'.
-  @type name: string
-  @param name: The Lamp Data name.
-  @rtype: Blender Lamp
-  @return: The created Lamp Data object.
-  """
+       """
+       Create a new Lamp Data object.
+       @type type: string
+       @param type: The Lamp type: 'Lamp', 'Sun', 'Spot', 'Hemi', 'Area', or 'Photon'.
+       @type name: string
+       @param name: The Lamp Data name.
+       @rtype: Blender Lamp
+       @return: The created Lamp Data object.
+       """
 
 def Get (name = None):
-  """
-  Get the Lamp Data object(s) from Blender.
-  @type name: string
-  @param name: The name of the Lamp Data.
-  @rtype: Blender Lamp or a list of Blender Lamps
-  @return: It depends on the I{name} parameter:
-      - (name): The Lamp Data object with the given I{name};
-      - ():     A list with all Lamp Data objects in the current scene.
-  """
+       """
+       Get the Lamp Data object(s) from Blender.
+       @type name: string
+       @param name: The name of the Lamp Data.
+       @rtype: Blender Lamp or a list of Blender Lamps
+       @return: It depends on the I{name} parameter:
+                       - (name): The Lamp Data object with the given I{name};
+                       - ():     A list with all Lamp Data objects in the current scene.
+       """
 
 class Lamp:
-  """
-  The Lamp Data object
-  ====================
-    This object gives access to Lamp-specific data in Blender.
-
-  @ivar B:  Lamp color blue component.
-  Value is clamped to the range [0.0,1.0].
-  @type B:  float
-  @ivar G:  Lamp color green component.
-  Value is clamped to the range [0.0,1.0].
-  @type G:  float
-  @ivar R:  Lamp color red component.
-  Value is clamped to the range [0.0,1.0].
-  @type R:  float
-  @ivar bias:  Lamp shadow map sampling bias.
-  Value is clamped to the range [0.01,5.0].
-  @type bias:  float
-  @ivar bufferSize:  Lamp shadow buffer size.
-  Value is clamped to the range [512,5120].
-  @type bufferSize:  int
-  @ivar clipEnd:  Lamp shadow map clip end.
-  Value is clamped to the range [1.0,5000.0].
-  @type clipEnd:  float
-  @ivar clipStart:  Lamp shadow map clip start.
-  Value is clamped to the range [0.1,1000.0].
-  @type clipStart:  float
-  @ivar col:  Lamp RGB color triplet.
-  Components are clamped to the range [0.0,1.0].
-  @type col:  RGB tuple
-  @ivar dist:  Lamp clipping distance.
-  Value is clamped to the range [0.1,5000.0].
-  @type dist:  float
-  @ivar energy:  Lamp light intensity.
-  Value is clamped to the range [0.0,10.0].
-  @type energy:  float
-  @ivar haloInt:  Lamp spotlight halo intensity.
-  Value is clamped to the range [0.0,5.0].
-  @type haloInt:  float
-  @ivar haloStep:  Lamp volumetric halo sampling frequency.
-  Value is clamped to the range [0,12].
-  @type haloStep:  int
-  @ivar ipo:  Lamp Ipo.
-  Contains the Ipo if one is assigned to the object, B{None} otherwise.  Setting to B{None} clears the current Ipo..
-  @type ipo:  Blender Ipo
-  @ivar mode:  Lamp mode bitfield.  See L{Modes} for values.
-  @type mode:  int
-  @ivar name:  Lamp data name.
-  @type name:  str
-  @ivar quad1:  Quad lamp linear distance attenuation.
-  Value is clamped to the range [0.0,1.0].
-  @type quad1:  float
-  @ivar quad2:  Quad lamp quadratic distance attenuation.
-  Value is clamped to the range [0.0,1.0].
-  @type quad2:  float
-  @ivar samples:  Lamp shadow map samples.
-  Value is clamped to the range [1,16].
-  @type samples:  int
-  @ivar raySamplesX:  Lamp raytracing X samples (X is used for the Y axis with square area lamps).
-  Value is clamped to the range [1,16].
-  @type raySamplesX:  int
-  @ivar raySamplesY:  Lamp raytracing Y samples (Y is only used for rectangle area lamps).
-  Value is clamped to the range [1,16].
-  @type raySamplesY:  int
-  @ivar areaSizeX:  Lamp X size (X is used for the Y axis with square area lamps)
-  Value is clamped to the range [0.01,100.0].
-  @type areaSizeX:  float
-  @ivar areaSizeY:  Lamp Y size (Y is only used for rectangle area lamps).
-  Value is clamped to the range [0.01,100.0].
-  @type areaSizeY:  float
-  @ivar softness:  Lamp shadow sample area size.
-  Value is clamped to the range [1.0,100.0].
-  @type softness:  float
-  @ivar spotBlend:  Lamp spotlight edge softness.
-  Value is clamped to the range [0.0,1.0].
-  @type spotBlend:  float
-  @ivar spotSize:  Lamp spotlight beam angle (in degrees).
-  Value is clamped to the range [1.0,180.0].
-  @type spotSize:  float
-  @ivar type:  Lamp type.  See L{Types} for values.
-  @type type:  int
-  @ivar users:  Number of lamp users.
-  @type users:  int
-
-  @warning: Most member variables assume values in some [Min, Max] interval.
-      When trying to set them, the given parameter will be clamped to lie in
-      that range: if val < Min, then val = Min, if val > Max, then val = Max.
-  """
-
-  def getName():
-    """
-    Get the name of this Lamp Data object.
-    @rtype: string
-    """
-
-  def setName(name):
-    """
-    Set the name of this Lamp Data object.
-    @type name: string
-    @param name: The new name.
-    """
-
-  def getType():
-    """
-    Get this Lamp's type.
-    @rtype: int
-    """
-
-  def setType(type):
-    """
-    Set this Lamp's type.
-    @type type: string
-    @param type: The Lamp type: 'Lamp', 'Sun', 'Spot', 'Hemi', 'Area', or 'Photon'
-    """
-
-  def getMode():
-    """
-    Get this Lamp's mode flags.
-    @rtype: int
-    @return: B{OR'ed value}. Use the Modes dictionary to check which flags
-        are 'on'.
-
-        Example::
-          flags = mylamp.getMode()
-          if flags & mylamp.Modes['Shadows']:
-            print "This lamp produces shadows"
-          else:
-            print "The 'Shadows' flag is off"
-    """
-
-  def setMode(m = None, m2 = None, m3 = None, m4 = None,
-              m5 = None, m6 = None, m7 = None, m8 = None):
-    """
-    Set this Lamp's mode flags. Mode strings given are turned 'on'.
-    Those not provided are turned 'off', so lamp.setMode() -- without 
-    arguments -- turns off all mode flags for Lamp lamp.
-    @type m: string
-    @param m: A mode flag. From 1 to 8 can be set at the same time.
-    """
-
-  def getSamples():
-    """
-    Get this lamp's samples value.
-    @rtype: int
-    """
-
-  def setSamples(samples):
-    """
-    Set the samples value.
-    @type samples: int
-    @param samples: The new samples value.
-    """
-
-  def getRaySamplesX():
-    """
-    Get this lamp's raytracing sample value on the X axis.
-    This value is only used for area lamps.
-    @rtype: int
-    """
-
-  def setRaySamplesX():
-    """
-    Set the lamp's raytracing sample value on the X axis, between 1 and 16.
-    This value is only used for area lamps.
-    @rtype: int
-    """
-
-  def getRaySamplesY():
-    """
-    Get this lamp's raytracing sample value on the Y axis.
-    This value is only used for rectangle area lamps.
-    @rtype: int
-    """
-
-  def setRaySamplesY():
-    """
-    Set the lamp's raytracing sample value on the Y axis, between 1 and 16.
-    This value is only used for rectangle area lamps.
-    @rtype: int
-    """
-
-  def getAreaSizeX():
-    """
-    Get this lamp's size on the X axis.
-    This value is only used for area lamps.
-    @rtype: int
-    """
-
-  def setAreaSizeX():
-    """
-    Set this lamp's size on the X axis.
-    This value is only used for area lamps.
-    @rtype: int
-    """
-
-  def getAreaSizeY():
-    """
-    Get this lamp's size on the Y axis.
-    This value is only used for rectangle area lamps.
-    @rtype: int
-    """
-
-  def setAreaSizeY():
-    """
-    Set this lamp's size on the Y axis.
-    This value is only used for rectangle area lamps.
-    @rtype: int
-    """
-
-  def getBufferSize():
-    """
-    Get this lamp's buffer size.
-    @rtype: int
-    """
-
-  def setBufferSize(bufsize):
-    """
-    Set the buffer size value.
-    @type bufsize: int
-    @param bufsize: The new buffer size value.
-    """
-
-  def getHaloStep():
-    """
-    Get this lamp's halo step value.
-    @rtype: int
-    """
-
-  def setHaloStep(hastep):
-    """
-    Set the halo step value.
-    @type hastep: int
-    @param hastep: The new halo step value.
-    """
-
-  def getEnergy():
-    """
-    Get this lamp's energy intensity value.
-    @rtype: float
-    """
-
-  def setEnergy(energy):
-    """
-    Set the energy intensity value.
-    @type energy: float
-    @param energy: The new energy value.
-    """
-
-  def getDist():
-    """
-    Get this lamp's distance value.
-    @rtype: float
-    """
-
-  def setDist(distance):
-    """
-    Set the distance value.
-    @type distance: float
-    @param distance: The new distance value.
-    """
-
-  def getSpotSize():
-    """
-    Get this lamp's spot size value.
-    @rtype: float
-    """
-
-  def setSpotSize(spotsize):
-    """
-    Set the spot size value.
-    @type spotsize: float
-    @param spotsize: The new spot size value.
-    """
-
-  def getSpotBlend():
-    """
-    Get this lamp's spot blend value.
-    @rtype: float
-    """
-
-  def setSpotBlend(spotblend):
-    """
-    Set the spot blend value.
-    @type spotblend: float
-    @param spotblend: The new spot blend value.
-    """
-
-  def getClipStart():
-    """
-    Get this lamp's clip start value.
-    @rtype: float
-    """
-
-  def setClipStart(clipstart):
-    """
-    Set the clip start value.
-    @type clipstart: float
-    @param clipstart: The new clip start value.
-    """
-
-  def getClipEnd():
-    """
-    Get this lamp's clip end value.
-    @rtype: float
-    """
-
-  def setClipEnd(clipend):
-    """
-    Set the clip end value.
-    @type clipend: float
-    @param clipend: The new clip end value.
-    """ 
-
-  def getBias():
-    """
-    Get this lamp's bias value.
-    @rtype: float
-    """
-
-  def setBias(bias):
-    """
-    Set the bias value.
-    @type bias: float
-    @param bias: The new bias value.
-    """ 
-
-  def getSoftness():
-    """
-    Get this lamp's softness value.
-    @rtype: float
-    """
-
-  def setSoftness(softness):
-    """
-    Set the softness value.
-    @type softness: float
-    @param softness: The new softness value.
-    """ 
-
-  def getHaloInt():
-    """
-    Get this lamp's halo intensity value.
-    @rtype: float
-    """
-
-  def setHaloInt(haloint):
-    """
-    Set the halo intensity value.
-    @type haloint: float
-    @param haloint: The new halo intensity value.
-    """ 
-
-  def getQuad1():
-    """
-    Get this lamp's quad 1 value.
-    @rtype: float
-    @warning: this only applies to Lamps with the 'Quad' flag on.
-    """
-
-  def setQuad1(quad1):
-    """
-    Set the quad 1 value.
-    @type quad1: float
-    @warning: this only applies to Lamps with the 'Quad' flag on.
-    """ 
-
-  def getQuad2():
-    """
-    Get this lamp's quad 2 value.
-    @rtype: float
-    @warning: this only applies to Lamps with the 'Quad' flag on.
-    """
-
-  def setQuad2(quad2):
-    """
-    Set the quad 2 value.
-    @type quad2: float
-    @param quad2: The new quad 2 value.
-    @warning: this only applies to Lamps with the 'Quad' flag on.
-    """ 
-
-  def getScriptLinks (event):
-    """
-    Get a list with this Lamp's script links of type 'event'.
-    @type event: string
-    @param event: "FrameChanged", "Redraw" or "Render".
-    @rtype: list
-    @return: a list with Blender L{Text} names (the script links of the given
-        'event' type) or None if there are no script links at all.
-    """
-
-  def clearScriptLinks (links = None):
-    """
-    Delete script links from this Lamp.  If no list is specified, all
-    script links are deleted.
-    @type links: list of strings
-    @param links: None (default) or a list of Blender L{Text} names.
-    """
-
-  def addScriptLink (text, event):
-    """
-    Add a new script link to this Lamp.
-    @type text: string
-    @param text: the name of an existing Blender L{Text}.
-    @type event: string
-    @param event: "FrameChanged", "Redraw" or "Render".
-    """
-
-  def getIpo():
-    """
-    Get the Ipo associated with this Lamp object, if any.
-    @rtype: Ipo
-    @return: the wrapped ipo or None.
-    """
-
-  def setIpo(ipo):
-    """
-    Link an ipo to this Lamp object.
-    @type ipo: Blender Ipo
-    @param ipo: a "lamp data" ipo.
-    """
-
-  def clearIpo():
-    """
-    Unlink the ipo from this Lamp object.
-    @return: True if there was an ipo linked or False otherwise.
-    """
-    
-  def insertIpoKey(keytype):
-    """
-    Inserts keytype values in lamp ipo at curframe. Uses module constants.
-    @type keytype: Integer
-    @param keytype:
-           -RGB
-           -ENERGY
-           -SPOTSIZE
-           -OFFSET
-           -SIZE
-    @return: py_none
-    """    
-
-  def __copy__ ():
-    """
-    Make a copy of this lamp
-    @rtype: Lamp
-    @return:  a copy of this lamp
-    """
\ No newline at end of file
+       """
+       The Lamp Data object
+       ====================
+               This object gives access to Lamp-specific data in Blender.
+
+       @ivar B:  Lamp color blue component.
+       Value is clamped to the range [0.0,1.0].
+       @type B:  float
+       @ivar G:  Lamp color green component.
+       Value is clamped to the range [0.0,1.0].
+       @type G:  float
+       @ivar R:  Lamp color red component.
+       Value is clamped to the range [0.0,1.0].
+       @type R:  float
+       @ivar bias:  Lamp shadow map sampling bias.
+       Value is clamped to the range [0.01,5.0].
+       @type bias:  float
+       @ivar bufferSize:  Lamp shadow buffer size.
+       Value is clamped to the range [512,5120].
+       @type bufferSize:  int
+       @ivar clipEnd:  Lamp shadow map clip end.
+       Value is clamped to the range [1.0,5000.0].
+       @type clipEnd:  float
+       @ivar clipStart:  Lamp shadow map clip start.
+       Value is clamped to the range [0.1,1000.0].
+       @type clipStart:  float
+       @ivar col:  Lamp RGB color triplet.
+       Components are clamped to the range [0.0,1.0].
+       @type col:  RGB tuple
+       @ivar dist:  Lamp clipping distance.
+       Value is clamped to the range [0.1,5000.0].
+       @type dist:  float
+       @ivar energy:  Lamp light intensity.
+       Value is clamped to the range [0.0,10.0].
+       @type energy:  float
+       @ivar haloInt:  Lamp spotlight halo intensity.
+       Value is clamped to the range [0.0,5.0].
+       @type haloInt:  float
+       @ivar haloStep:  Lamp volumetric halo sampling frequency.
+       Value is clamped to the range [0,12].
+       @type haloStep:  int
+       @ivar ipo:  Lamp Ipo.
+       Contains the Ipo if one is assigned to the object, B{None} otherwise.  Setting to B{None} clears the current Ipo..
+       @type ipo:  Blender Ipo
+       @ivar mode:  Lamp mode bitfield.  See L{Modes} for values.
+       @type mode:  int
+       @ivar quad1:  Quad lamp linear distance attenuation.
+       Value is clamped to the range [0.0,1.0].
+       @type quad1:  float
+       @ivar quad2:  Quad lamp quadratic distance attenuation.
+       Value is clamped to the range [0.0,1.0].
+       @type quad2:  float
+       @ivar samples:  Lamp shadow map samples.
+       Value is clamped to the range [1,16].
+       @type samples:  int
+       @ivar raySamplesX:  Lamp raytracing X samples (X is used for the Y axis with square area lamps).
+       Value is clamped to the range [1,16].
+       @type raySamplesX:  int
+       @ivar raySamplesY:  Lamp raytracing Y samples (Y is only used for rectangle area lamps).
+       Value is clamped to the range [1,16].
+       @type raySamplesY:  int
+       @ivar areaSizeX:  Lamp X size (X is used for the Y axis with square area lamps)
+       Value is clamped to the range [0.01,100.0].
+       @type areaSizeX:  float
+       @ivar areaSizeY:  Lamp Y size (Y is only used for rectangle area lamps).
+       Value is clamped to the range [0.01,100.0].
+       @type areaSizeY:  float
+       @ivar softness:  Lamp shadow sample area size.
+       Value is clamped to the range [1.0,100.0].
+       @type softness:  float
+       @ivar spotBlend:  Lamp spotlight edge softness.
+       Value is clamped to the range [0.0,1.0].
+       @type spotBlend:  float
+       @ivar spotSize:  Lamp spotlight beam angle (in degrees).
+       Value is clamped to the range [1.0,180.0].
+       @type spotSize:  float
+       @ivar type:  Lamp type.  See L{Types} for values.
+       @type type:  int
+
+       @warning: Most member variables assume values in some [Min, Max] interval.
+               When trying to set them, the given parameter will be clamped to lie in
+               that range: if val < Min, then val = Min, if val > Max, then val = Max.
+       """
+
+       def getName():
+               """
+               Get the name of this Lamp Data object.
+               @rtype: string
+               """
+
+       def setName(name):
+               """
+               Set the name of this Lamp Data object.
+               @type name: string
+               @param name: The new name.
+               """
+
+       def getType():
+               """
+               Get this Lamp's type.
+               @rtype: int
+               """
+
+       def setType(type):
+               """
+               Set this Lamp's type.
+               @type type: string
+               @param type: The Lamp type: 'Lamp', 'Sun', 'Spot', 'Hemi', 'Area', or 'Photon'
+               """
+
+       def getMode():
+               """
+               Get this Lamp's mode flags.
+               @rtype: int
+               @return: B{OR'ed value}. Use the Modes dictionary to check which flags
+                               are 'on'.
+
+                               Example::
+                                       flags = mylamp.getMode()
+                                       if flags & mylamp.Modes['Shadows']:
+                                               print "This lamp produces shadows"
+                                       else:
+                                               print "The 'Shadows' flag is off"
+               """
+
+       def setMode(m = None, m2 = None, m3 = None, m4 = None,
+                                                       m5 = None, m6 = None, m7 = None, m8 = None):
+               """
+               Set this Lamp's mode flags. Mode strings given are turned 'on'.
+               Those not provided are turned 'off', so lamp.setMode() -- without 
+               arguments -- turns off all mode flags for Lamp lamp.
+               @type m: string
+               @param m: A mode flag. From 1 to 8 can be set at the same time.
+               """
+
+       def getSamples():
+               """
+               Get this lamp's samples value.
+               @rtype: int
+               """
+
+       def setSamples(samples):
+               """
+               Set the samples value.
+               @type samples: int
+               @param samples: The new samples value.
+               """
+
+       def getRaySamplesX():
+               """
+               Get this lamp's raytracing sample value on the X axis.
+               This value is only used for area lamps.
+               @rtype: int
+               """
+
+       def setRaySamplesX():
+               """
+               Set the lamp's raytracing sample value on the X axis, between 1 and 16.
+               This value is only used for area lamps.
+               @rtype: int
+               """
+
+       def getRaySamplesY():
+               """
+               Get this lamp's raytracing sample value on the Y axis.
+               This value is only used for rectangle area lamps.
+               @rtype: int
+               """
+
+       def setRaySamplesY():
+               """
+               Set the lamp's raytracing sample value on the Y axis, between 1 and 16.
+               This value is only used for rectangle area lamps.
+               @rtype: int
+               """
+
+       def getAreaSizeX():
+               """
+               Get this lamp's size on the X axis.
+               This value is only used for area lamps.
+               @rtype: int
+               """
+
+       def setAreaSizeX():
+               """
+               Set this lamp's size on the X axis.
+               This value is only used for area lamps.
+               @rtype: int
+               """
+
+       def getAreaSizeY():
+               """
+               Get this lamp's size on the Y axis.
+               This value is only used for rectangle area lamps.
+               @rtype: int
+               """
+
+       def setAreaSizeY():
+               """
+               Set this lamp's size on the Y axis.
+               This value is only used for rectangle area lamps.
+               @rtype: int
+               """
+
+       def getBufferSize():
+               """
+               Get this lamp's buffer size.
+               @rtype: int
+               """
+
+       def setBufferSize(bufsize):
+               """
+               Set the buffer size value.
+               @type bufsize: int
+               @param bufsize: The new buffer size value.
+               """
+
+       def getHaloStep():
+               """
+               Get this lamp's halo step value.
+               @rtype: int
+               """
+
+       def setHaloStep(hastep):
+               """
+               Set the halo step value.
+               @type hastep: int
+               @param hastep: The new halo step value.
+               """
+
+       def getEnergy():
+               """
+               Get this lamp's energy intensity value.
+               @rtype: float
+               """
+
+       def setEnergy(energy):
+               """
+               Set the energy intensity value.
+               @type energy: float
+               @param energy: The new energy value.
+               """
+
+       def getDist():
+               """
+               Get this lamp's distance value.
+               @rtype: float
+               """
+
+       def setDist(distance):
+               """
+               Set the distance value.
+               @type distance: float
+               @param distance: The new distance value.
+               """
+
+       def getSpotSize():
+               """
+               Get this lamp's spot size value.
+               @rtype: float
+               """
+
+       def setSpotSize(spotsize):
+               """
+               Set the spot size value.
+               @type spotsize: float
+               @param spotsize: The new spot size value.
+               """
+
+       def getSpotBlend():
+               """
+               Get this lamp's spot blend value.
+               @rtype: float
+               """
+
+       def setSpotBlend(spotblend):
+               """
+               Set the spot blend value.
+               @type spotblend: float
+               @param spotblend: The new spot blend value.
+               """
+
+       def getClipStart():
+               """
+               Get this lamp's clip start value.
+               @rtype: float
+               """
+
+       def setClipStart(clipstart):
+               """
+               Set the clip start value.
+               @type clipstart: float
+               @param clipstart: The new clip start value.
+               """
+
+       def getClipEnd():
+               """
+               Get this lamp's clip end value.
+               @rtype: float
+               """
+
+       def setClipEnd(clipend):
+               """
+               Set the clip end value.
+               @type clipend: float
+               @param clipend: The new clip end value.
+               """ 
+
+       def getBias():
+               """
+               Get this lamp's bias value.
+               @rtype: float
+               """
+
+       def setBias(bias):
+               """
+               Set the bias value.
+               @type bias: float
+               @param bias: The new bias value.
+               """ 
+
+       def getSoftness():
+               """
+               Get this lamp's softness value.
+               @rtype: float
+               """
+
+       def setSoftness(softness):
+               """
+               Set the softness value.
+               @type softness: float
+               @param softness: The new softness value.
+               """ 
+
+       def getHaloInt():
+               """
+               Get this lamp's halo intensity value.
+               @rtype: float
+               """
+
+       def setHaloInt(haloint):
+               """
+               Set the halo intensity value.
+               @type haloint: float
+               @param haloint: The new halo intensity value.
+               """ 
+
+       def getQuad1():
+               """
+               Get this lamp's quad 1 value.
+               @rtype: float
+               @warning: this only applies to Lamps with the 'Quad' flag on.
+               """
+
+       def setQuad1(quad1):
+               """
+               Set the quad 1 value.
+               @type quad1: float
+               @warning: this only applies to Lamps with the 'Quad' flag on.
+               """ 
+
+       def getQuad2():
+               """
+               Get this lamp's quad 2 value.
+               @rtype: float
+               @warning: this only applies to Lamps with the 'Quad' flag on.
+               """
+
+       def setQuad2(quad2):
+               """
+               Set the quad 2 value.
+               @type quad2: float
+               @param quad2: The new quad 2 value.
+               @warning: this only applies to Lamps with the 'Quad' flag on.
+               """ 
+
+       def getScriptLinks (event):
+               """
+               Get a list with this Lamp's script links of type 'event'.
+               @type event: string
+               @param event: "FrameChanged", "Redraw" or "Render".
+               @rtype: list
+               @return: a list with Blender L{Text} names (the script links of the given
+                               'event' type) or None if there are no script links at all.
+               """
+
+       def clearScriptLinks (links = None):
+               """
+               Delete script links from this Lamp.  If no list is specified, all
+               script links are deleted.
+               @type links: list of strings
+               @param links: None (default) or a list of Blender L{Text} names.
+               """
+
+       def addScriptLink (text, event):
+               """
+               Add a new script link to this Lamp.
+               @type text: string
+               @param text: the name of an existing Blender L{Text}.
+               @type event: string
+               @param event: "FrameChanged", "Redraw" or "Render".
+               """
+
+       def getIpo():
+               """
+               Get the Ipo associated with this Lamp object, if any.
+               @rtype: Ipo
+               @return: the wrapped ipo or None.
+               """
+
+       def setIpo(ipo):
+               """
+               Link an ipo to this Lamp object.
+               @type ipo: Blender Ipo
+               @param ipo: a "lamp data" ipo.
+               """
+
+       def clearIpo():
+               """
+               Unlink the ipo from this Lamp object.
+               @return: True if there was an ipo linked or False otherwise.
+               """
+               
+       def insertIpoKey(keytype):
+               """
+               Inserts keytype values in lamp ipo at curframe. Uses module constants.
+               @type keytype: Integer
+               @param keytype:
+                       -RGB
+                       -ENERGY
+                       -SPOTSIZE
+                       -OFFSET
+                       -SIZE
+               @return: None
+               """    
+
+       def __copy__ ():
+               """
+               Make a copy of this lamp
+               @rtype: Lamp
+               @return:  a copy of this lamp
+               """
+
+import id_generics
+Lamp.__doc__ += id_generics.attributes
index 00412b349702763a0df95da51bbb58bf3e16152b..8666254ec0d73d3a3b64e6301315770aa431ca6c 100644 (file)
@@ -41,169 +41,169 @@ Example::
 """
 
 def New (name = None):
-  """
-  Create a new Lattice object.
-  Passing a name to this function will name the Lattice
-  datablock, otherwise the Lattice data will be given a 
-  default name.
-  @type name: string
-  @param name: The Lattice name.
-  @rtype: Blender Lattice
-  @return: The created Lattice Data object.
-  """
+       """
+       Create a new Lattice object.
+       Passing a name to this function will name the Lattice
+       datablock, otherwise the Lattice data will be given a 
+       default name.
+       @type name: string
+       @param name: The Lattice name.
+       @rtype: Blender Lattice
+       @return: The created Lattice Data object.
+       """
 
 def Get (name = None):
-  """
-  Get the Lattice object(s) from Blender.
-  @type name: string
-  @param name: The name of the Lattice object.
-  @rtype: Blender Lattice or a list of Blender Lattices
-  @return: It depends on the 'name' parameter:
-      - (name): The Lattice object with the given name;
-      - ():     A list with all Lattice objects in the current scene.
-  """
+       """
+       Get the Lattice object(s) from Blender.
+       @type name: string
+       @param name: The name of the Lattice object.
+       @rtype: Blender Lattice or a list of Blender Lattices
+       @return: It depends on the 'name' parameter:
+                       - (name): The Lattice object with the given name;
+                       - ():     A list with all Lattice objects in the current scene.
+       """
 
 class Lattice:
-  """
-  The Lattice object
-  ==================
-    This object gives access to Lattices in Blender.
-  @ivar name: The Lattice name.
-  @ivar width: The number of x dimension partitions.
-  @ivar height: The number of y dimension partitions.
-  @ivar depth: The number of z dimension partitions.
-  @ivar widthType: The x dimension key type.
-  @ivar heightType: The y dimension key type.
-  @ivar depthType: The z dimension key type.
-  @ivar mode: The current mode of the Lattice.
-  @ivar latSize: The number of points in this Lattice.
-  @cvar key: The L{Key.Key} object associated with this Lattice or None.
-  """
-
-  def getName():
-    """
-    Get the name of this Lattice datablock.
-    @rtype: string
-    @return: The name of the Lattice datablock.
-    """
-
-  def setName(name):
-    """
-    Set the name of this Lattice datablock.
-    @type name: string
-    @param name: The new name.
-    """
-
-  def getPartitions():
-    """
-    Gets the number of 'walls' or partitions that the Lattice has 
-    in the x, y, and z dimensions.
-    @rtype: list of ints
-    @return: A list corresponding to the number of partitions: [x,y,z]
-    """
-
-  def setPartitions(x,y,z):
-    """
-    Set the number of 'walls' or partitions that the 
-    Lattice will be created with in the x, y, and z dimensions.
-    @type x: int
-    @param x: The number of partitions in the x dimension of the Lattice.
-    @type y: int
-    @param y: The number of partitions in the y dimension of the Lattice.
-    @type z: int
-    @param z: The number of partitions in the z dimension of the Lattice.
-    """
-
-  def getKeyTypes():
-    """
-    Returns the deformation key types for the x, y, and z dimensions of the
-    Lattice.
-    @rtype: list of strings
-    @return: A list corresponding to the key types will be returned: [x,y,z]
-    """
-
-  def setKeyTypes(xType,yType,zType):
-    """
-    Sets the deformation key types for the x, y, and z dimensions of the
-    Lattice.
-    There are three key types possible:
-      -  Lattice.CARDINAL
-      -  Lattice.LINEAR
-      -  Lattice.BSPLINE
-    @type xType: enum constant
-    @param xType: the deformation key type for the x dimension of the Lattice
-    @type yType: enum constant
-    @param yType: the deformation key type for the y dimension of the Lattice
-    @type zType: enum constant
-    @param zType: the deformation key type for the z dimension of the Lattice
-    """
-
-  def getMode():
-    """
-    Returns the current Lattice mode
-    @rtype: string
-    @return: A string representing the current Lattice mode
-    """
-
-  def setMode(modeType):
-    """
-    Sets the current Lattice mode
-    There are two Lattice modes possible:
-      -  Lattice.GRID
-      -  Lattice.OUTSIDE
-    @type modeType: enum constant
-    @param modeType: the Lattice mode
-    """
-
-  def getPoint(index):
-    """
-    Returns the coordinates of a point in the Lattice by index.
-    @type index: int
-    @param index: The index of the point on the Lattice you want returned
-    @rtype: list of floats
-    @return: The x,y,z coordiates of the Lattice point : [x,y,z]
-    """
-
-  def setPoint(index, position):
-    """
-    Sets the coordinates of a point in the Lattice by index.
-    @type index: int
-    @param index: The index of the point on the Lattice you want set
-    @type position: list of floats
-    @param position: The x,y,z coordinates that you want the point to be: [x,y,z]
-    """
-
-  def getKey():
-    """
-    Returns the L{Key.Key} object associated with this Lattice.
-    @rtype: L{Key.Key}
-    @return: A key object representing the keyframes of the lattice or None.
-    """
-
-  def insertKey(frame):
-    """
-    Inserts the current state of the Lattice as a new absolute keyframe
-
-    B{Example}::
-      for z in range(5):
-        for y in range(125):
-          vec = myLat.getPoint(y)
-          co1 = vec[0] + vec[2]
-          co2 = vec[1] - vec[2]
-          co3 = vec[2] + vec[1]
-          myLat.setPoint(y,[co1,co2,co3])
-        w = (z + 1) * 10
-        myLat.insertKey(w)
-
-    @type frame: int
-    @param frame: the frame at which the Lattice will be set as a keyframe
-    """
-
-  def __copy__ ():
-    """
-    Make a copy of this lattice
-    @rtype: Lattice
-    @return:  a copy of this lattice
-    """
-
-
+       """
+       The Lattice object
+       ==================
+               This object gives access to Lattices in Blender.
+       @ivar width: The number of x dimension partitions.
+       @ivar height: The number of y dimension partitions.
+       @ivar depth: The number of z dimension partitions.
+       @ivar widthType: The x dimension key type.
+       @ivar heightType: The y dimension key type.
+       @ivar depthType: The z dimension key type.
+       @ivar mode: The current mode of the Lattice.
+       @ivar latSize: The number of points in this Lattice (width*height*depth).
+       @cvar key: The L{Key.Key} object associated with this Lattice or None.
+       """
+
+       def getName():
+               """
+               Get the name of this Lattice datablock.
+               @rtype: string
+               @return: The name of the Lattice datablock.
+               """
+
+       def setName(name):
+               """
+               Set the name of this Lattice datablock.
+               @type name: string
+               @param name: The new name.
+               """
+
+       def getPartitions():
+               """
+               Gets the number of 'walls' or partitions that the Lattice has 
+               in the x, y, and z dimensions.
+               @rtype: list of ints
+               @return: A list corresponding to the number of partitions: [x,y,z]
+               """
+
+       def setPartitions(x,y,z):
+               """
+               Set the number of 'walls' or partitions that the 
+               Lattice will be created with in the x, y, and z dimensions.
+               @type x: int
+               @param x: The number of partitions in the x dimension of the Lattice.
+               @type y: int
+               @param y: The number of partitions in the y dimension of the Lattice.
+               @type z: int
+               @param z: The number of partitions in the z dimension of the Lattice.
+               """
+
+       def getKeyTypes():
+               """
+               Returns the deformation key types for the x, y, and z dimensions of the
+               Lattice.
+               @rtype: list of strings
+               @return: A list corresponding to the key types will be returned: [x,y,z]
+               """
+
+       def setKeyTypes(xType,yType,zType):
+               """
+               Sets the deformation key types for the x, y, and z dimensions of the
+               Lattice.
+               There are three key types possible:
+                       -  Lattice.CARDINAL
+                       -  Lattice.LINEAR
+                       -  Lattice.BSPLINE
+               @type xType: enum constant
+               @param xType: the deformation key type for the x dimension of the Lattice
+               @type yType: enum constant
+               @param yType: the deformation key type for the y dimension of the Lattice
+               @type zType: enum constant
+               @param zType: the deformation key type for the z dimension of the Lattice
+               """
+
+       def getMode():
+               """
+               Returns the current Lattice mode
+               @rtype: string
+               @return: A string representing the current Lattice mode
+               """
+
+       def setMode(modeType):
+               """
+               Sets the current Lattice mode
+               There are two Lattice modes possible:
+                       -  Lattice.GRID
+                       -  Lattice.OUTSIDE
+               @type modeType: enum constant
+               @param modeType: the Lattice mode
+               """
+
+       def getPoint(index):
+               """
+               Returns the coordinates of a point in the Lattice by index.
+               @type index: int
+               @param index: The index of the point on the Lattice you want returned
+               @rtype: list of floats
+               @return: The x,y,z coordiates of the Lattice point : [x,y,z]
+               """
+
+       def setPoint(index, position):
+               """
+               Sets the coordinates of a point in the Lattice by index.
+               @type index: int
+               @param index: The index of the point on the Lattice you want set
+               @type position: list of floats
+               @param position: The x,y,z coordinates that you want the point to be: [x,y,z]
+               """
+
+       def getKey():
+               """
+               Returns the L{Key.Key} object associated with this Lattice.
+               @rtype: L{Key.Key}
+               @return: A key object representing the keyframes of the lattice or None.
+               """
+
+       def insertKey(frame):
+               """
+               Inserts the current state of the Lattice as a new absolute keyframe
+
+               B{Example}::
+                       for z in range(5):
+                               for y in range(125):
+                                       vec = myLat.getPoint(y)
+                                       co1 = vec[0] + vec[2]
+                                       co2 = vec[1] - vec[2]
+                                       co3 = vec[2] + vec[1]
+                                       myLat.setPoint(y,[co1,co2,co3])
+                               w = (z + 1) * 10
+                               myLat.insertKey(w)
+
+               @type frame: int
+               @param frame: the frame at which the Lattice will be set as a keyframe
+               """
+
+       def __copy__ ():
+               """
+               Make a copy of this lattice
+               @rtype: Lattice
+               @return:  a copy of this lattice
+               """
+
+import id_generics
+Lattice.__doc__ += id_generics.attributes
index a487fd5e062014e3065039eb46042dbb1b82e2a1..5eb47271934ff46fb676e74bcd04c79aa40223f0 100644 (file)
@@ -11,994 +11,988 @@ Material
 This module provides access to B{Material} objects in Blender.
 
 Example::
-  import Blender
-  from Blender import Material
-  mat = Material.New('newMat')          # create a new Material called 'newMat'
-  print mat.rgbCol                      # print its rgb color triplet sequence
-  mat.rgbCol = [0.8, 0.2, 0.2]          # change its color
-  mat.setAlpha(0.2)                     # mat.alpha = 0.2 -- almost transparent
-  mat.emit = 0.7                        # equivalent to mat.setEmit(0.8)
-  mat.mode |= Material.Modes.ZTRANSP    # turn on Z-Buffer transparency
-  mat.setName('RedBansheeSkin')         # change its name
-  mat.setAdd(0.8)                       # make it glow
-  mat.setMode('Halo')                   # turn 'Halo' "on" and all others "off"
+       import Blender
+       from Blender import Material
+       mat = Material.New('newMat')          # create a new Material called 'newMat'
+       print mat.rgbCol                      # print its rgb color triplet sequence
+       mat.rgbCol = [0.8, 0.2, 0.2]          # change its color
+       mat.setAlpha(0.2)                     # mat.alpha = 0.2 -- almost transparent
+       mat.emit = 0.7                        # equivalent to mat.setEmit(0.8)
+       mat.mode |= Material.Modes.ZTRANSP    # turn on Z-Buffer transparency
+       mat.setName('RedBansheeSkin')         # change its name
+       mat.setAdd(0.8)                       # make it glow
+       mat.setMode('Halo')                   # turn 'Halo' "on" and all others "off"
 
 @type Modes: readonly dictionary
 @var Modes: The available Material Modes.
 
-  B{Note}: Some Modes are only available when the 'Halo' mode is I{off} and
-  others only when it is I{on}.  But these two subsets of modes share the same
-  numerical values in their Blender C #defines. So, for example, if 'Halo' is
-  on, then 'NoMist' is actually interpreted as 'HaloShaded'.  We marked all
-  such possibilities in the Modes dict below: each halo-related mode that
-  uses an already taken value is preceded by "+" and appear below the normal
-  mode which also uses that value.
-
-    - TRACEABLE    - Make Material visible for shadow lamps.
-    - SHADOW       - Enable Material for shadows.
-    - SHADOWBUF    - Enable Material to cast shadows with shadow buffers.
-    - SHADELESS    - Make Material insensitive to light or shadow.
-    - WIRE         - Render only the edges of faces.
-    - VCOL_LIGHT   - Add vertex colors as extra light.
-    - VCOL_PAINT   - Replace basic colors with vertex colors.
-    - HALO         - Render as a halo.
-    - ZTRANSP      - Z-buffer transparent faces.
-    - ZINVERT      - Render with inverted Z-buffer.
-    - + HALORINGS  - Render rings over the basic halo.
-    - ENV          - Do not render Material.
-    - + HALOLINES  - Render star shaped lines over the basic halo.
-    - ONLYSHADOW   - Let alpha be determined on the degree of shadow.
-    - + HALOXALPHA - Use extreme alpha.
-    - TEXFACE      - UV-Editor assigned texture gives color and texture info for faces.
-    - + HALOSTAR   - Render halo as a star.
-    - NOMIST       - Set the Material insensitive to mist.
-    - + HALOSHADED - Let halo receive light.
-    - HALOTEX      - Give halo a texture.
-    - HALOPUNO     - Use the vertex normal to specify the dimension of the halo.
-    - HALOFLARE    - Render halo as a lens flare.
-    - RAYMIRROR    - Enables raytracing for mirror reflection rendering.
-    - RAYTRANSP    - Enables raytracing for transparency rendering.
-    - RAYBIAS      - Prevent ray traced shadow errors with Phong interpolated normals.
-    - RAMPCOL      - Status of colorband ramp for Material's diffuse color.  This is a read-only bit.
-    - RAMPSPEC     - Status of colorband ramp for Material's specular color.  This is a read-only bit.
-    - TANGENTSTR   - Uses direction of strands as normal for tangent-shading.
-    - TRANSPSHADOW - Lets Material receive transparent shadows based on material color and alpha.
-    - FULLOSA      - Force rendering of all OSA samples.
-    - TANGENT_V    - Use the tangent vector in V direction for shading
-    - NMAP_TS      - Tangent space normal mapping.
-    - GROUP_EXCLUSIVE  - Light from this group even if the lights are on a hidden Layer.
+       B{Note}: Some Modes are only available when the 'Halo' mode is I{off} and
+       others only when it is I{on}.  But these two subsets of modes share the same
+       numerical values in their Blender C #defines. So, for example, if 'Halo' is
+       on, then 'NoMist' is actually interpreted as 'HaloShaded'.  We marked all
+       such possibilities in the Modes dict below: each halo-related mode that
+       uses an already taken value is preceded by "+" and appear below the normal
+       mode which also uses that value.
+
+               - TRACEABLE    - Make Material visible for shadow lamps.
+               - SHADOW       - Enable Material for shadows.
+               - SHADOWBUF    - Enable Material to cast shadows with shadow buffers.
+               - SHADELESS    - Make Material insensitive to light or shadow.
+               - WIRE         - Render only the edges of faces.
+               - VCOL_LIGHT   - Add vertex colors as extra light.
+               - VCOL_PAINT   - Replace basic colors with vertex colors.
+               - HALO         - Render as a halo.
+               - ZTRANSP      - Z-buffer transparent faces.
+               - ZINVERT      - Render with inverted Z-buffer.
+               - + HALORINGS  - Render rings over the basic halo.
+               - ENV          - Do not render Material.
+               - + HALOLINES  - Render star shaped lines over the basic halo.
+               - ONLYSHADOW   - Let alpha be determined on the degree of shadow.
+               - + HALOXALPHA - Use extreme alpha.
+               - TEXFACE      - UV-Editor assigned texture gives color and texture info for faces.
+               - + HALOSTAR   - Render halo as a star.
+               - NOMIST       - Set the Material insensitive to mist.
+               - + HALOSHADED - Let halo receive light.
+               - HALOTEX      - Give halo a texture.
+               - HALOPUNO     - Use the vertex normal to specify the dimension of the halo.
+               - HALOFLARE    - Render halo as a lens flare.
+               - RAYMIRROR    - Enables raytracing for mirror reflection rendering.
+               - RAYTRANSP    - Enables raytracing for transparency rendering.
+               - RAYBIAS      - Prevent ray traced shadow errors with Phong interpolated normals.
+               - RAMPCOL      - Status of colorband ramp for Material's diffuse color.  This is a read-only bit.
+               - RAMPSPEC     - Status of colorband ramp for Material's specular color.  This is a read-only bit.
+               - TANGENTSTR   - Uses direction of strands as normal for tangent-shading.
+               - TRANSPSHADOW - Lets Material receive transparent shadows based on material color and alpha.
+               - FULLOSA      - Force rendering of all OSA samples.
+               - TANGENT_V    - Use the tangent vector in V direction for shading
+               - NMAP_TS      - Tangent space normal mapping.
+               - GROUP_EXCLUSIVE       - Light from this group even if the lights are on a hidden Layer.
 
 @type Shaders: readonly dictionary
 @var Shaders: The available Material Shaders.
-    - DIFFUSE_LAMBERT    - Make Material use the lambert diffuse shader.
-    - DIFFUSE_ORENNAYAR       - Make Material use the Oren-Nayer diffuse shader.
-    - DIFFUSE_TOON    - Make Material use the toon diffuse shader.
-    - DIFFUSE_MINNAERT  - Make Material use the minnaert diffuse shader.
-    - SPEC_COOKTORR   - Make Material use the Cook-Torr specular shader.
-    - SPEC_PHONG   - Make Material use the Phong specular shader.
-    - SPEC_BLINN         - Make Material use the Blinn specular shader.
-    - SPEC_TOON      - Make Material use the toon specular shader.
-    - SPEC_WARDISO      - Make Material use the Ward-iso specular shader.
+               - DIFFUSE_LAMBERT    - Make Material use the lambert diffuse shader.
+               - DIFFUSE_ORENNAYAR       - Make Material use the Oren-Nayer diffuse shader.
+               - DIFFUSE_TOON    - Make Material use the toon diffuse shader.
+               - DIFFUSE_MINNAERT  - Make Material use the minnaert diffuse shader.
+               - SPEC_COOKTORR   - Make Material use the Cook-Torr specular shader.
+               - SPEC_PHONG   - Make Material use the Phong specular shader.
+               - SPEC_BLINN         - Make Material use the Blinn specular shader.
+               - SPEC_TOON      - Make Material use the toon specular shader.
+               - SPEC_WARDISO      - Make Material use the Ward-iso specular shader.
 """
 
 def New (name = 'Mat'):
-  """
-  Create a new Material object.
-  @type name: string
-  @param name: The Material name.
-  @rtype: Blender Material
-  @return: The created Material object.
-  """
+       """
+       Create a new Material object.
+       @type name: string
+       @param name: The Material name.
+       @rtype: Blender Material
+       @return: The created Material object.
+       """
 
 def Get (name = None):
-  """
-  Get the Material object(s) from Blender.
-  @type name: string
-  @param name: The name of the Material.
-  @rtype: Blender Material or a list of Blender Materials
-  @return: It depends on the 'name' parameter:
-    - (name): The Material object with the given name;
-    - ():   A list with all Material objects in the current scene.
-  """
+       """
+       Get the Material object(s) from Blender.
+       @type name: string
+       @param name: The name of the Material.
+       @rtype: Blender Material or a list of Blender Materials
+       @return: It depends on the 'name' parameter:
+               - (name): The Material object with the given name;
+               - ():   A list with all Material objects in the current scene.
+       """
 
 class Material:
-  """
-  The Material object
-  ===================
-   This object gives access to Materials in Blender.
-  @ivar properties: Returns an L{IDGroup<IDProp.IDGroup>} reference to this 
-  material's ID Properties.
-  @ivar B:  Diffuse color (L{rgbCol}) blue component.
-  Value is clamped to the range [0.0,1.0].
-  @type B:  float
-  @ivar G:  Diffuse color (L{rgbCol}) green component.
-  Value is clamped to the range [0.0,1.0].
-  @type G:  float
-  @ivar IOR:  Angular index of refraction for raytrace.
-  Value is clamped to the range [1.0,3.0].
-  @type IOR:  float
-  @ivar R:  Diffuse color (L{rgbCol}) red component.
-  Value is clamped to the range [0.0,1.0].
-  @type R:  float
-  @ivar add:  Strength of the add effect.
-  Value is clamped to the range [0.0,1.0].
-  @type add:  float
-  @ivar alpha:  Alpha (translucency) component of the material.
-  Value is clamped to the range [0.0,1.0].
-  @type alpha:  float
-  @ivar shadAlpha:  Shadow Alpha for irregular shadow buffer.
-  Value is clamped to the range [0.0,1.0].
-  @type shadAlpha:  float
-  @ivar amb:  Amount of global ambient color material receives.
-  Value is clamped to the range [0.0,1.0].
-  @type amb:  float
-  @ivar diffuseDarkness:  Material's diffuse darkness ("Minnaert" diffuse shader only).
-  Value is clamped to the range [0.0,2.0].
-  @type diffuseDarkness:  float
-  @ivar diffuseShader:  Diffuse shader type (see L{Shaders}).
-  Value must be in the range [0,3].
-  @type diffuseShader:  int
-  @ivar diffuseSize:  Material's diffuse area size ("Toon" diffuse shader only).
-  Value is clamped to the range [0.0,3.14].
-  @type diffuseSize:  float
-  @ivar diffuseSmooth:  Material's diffuse area smoothing ("Toon" diffuse shader only).
-  Value is clamped to the range [0.0,1.0].
-  @type diffuseSmooth:  float
-  @ivar emit:  Amount of light the material emits.
-  Value is clamped to the range [0.0,1.0].
-  @type emit:  float
-  @ivar filter:  Amount of filtering when transparent raytrace is enabled.
-  Value is clamped to the range [0.0,1.0].
-  @type filter:  float
-  @ivar flareBoost:  Flare's extra strength.
-  Value is clamped to the range [0.1,1.0].
-  @type flareBoost:  float
-  @ivar flareSeed:  Offset in the flare seed table.
-  Value is clamped to the range [1,255].
-  @type flareSeed:  int
-  @ivar flareSize:  Ratio of flare size to halo size.
-  Value is clamped to the range [0.1,25.0].
-  @type flareSize:  float
-  @ivar fresnelDepth:  Power of Fresnel for mirror reflection.
-  Value is clamped to the range [0.0,5.0].
-  @type fresnelDepth:  float
-  @ivar fresnelDepthFac:  Blending factor for Fresnel mirror.
-  Value is clamped to the range [1.0,5.0].
-  @type fresnelDepthFac:  float
-  @ivar fresnelTrans:  Power of Fresnel for transparency.
-  Value is clamped to the range [0.0,5.0].
-  @type fresnelTrans:  float
-  @ivar fresnelTransFac:  Blending factor for Fresnel transparency.
-  Value is clamped to the range [1.0,5.0].
-  @type fresnelTransFac:  float
-  @ivar rbFriction:  Rigid Body Friction coefficient.
-  Value is clamped to the range [0.0,100.0].
-  @type rbFriction:  float
-  @ivar rbRestitution:  Rigid Body Friction restitution.
-  Value is clamped to the range [0.0,1.0].
-  @type rbRestitution:  float
-  @ivar haloSeed:  Randomizes halo ring dimension and line location.
-  Value is clamped to the range [1,255].
-  @type haloSeed:  int
-  @ivar haloSize:  Dimension of the halo.
-  Value is clamped to the range [0.0,100.0].
-  @type haloSize:  float
-  @ivar hard:  Hardness of the specularity.
-  Value is clamped to the range [1,255].
-  @type hard:  int
-  @ivar ipo:  Material Ipo data.
-  Contains the Ipo if one is assigned to the object, None otherwise.  Setting to None clears the current Ipo.
-  @type ipo:  Blender Ipo
-  @ivar mirB:  Mirror color (L{mirCol}) blue component.
-  Value is clamped to the range [0.0,1.0].
-  @type mirB:  float
-  @ivar mirCol:  Mirror RGB color triplet.
-  Components are clamped to the range [0.0,1.0].
-  @type mirCol:  list of 3 floats
-  @ivar mirG:  Mirror color (L{mirCol}) green component.
-  Value is clamped to the range [0.0,1.0].
-  @type mirG:  float
-  @ivar mirR:  Mirror color (L{mirCol}) red component.
-  Value is clamped to the range [0.0,1.0].
-  @type mirR:  float
-  @ivar mode:  Mode mode bitfield.  See L{the Modes dictionary<Modes>} keys and descriptions.
-  @type mode:  int
-  @ivar nFlares:  Number of subflares with halo.
-  Value is clamped to the range [1,32].
-  @type nFlares:  int
-  @ivar nLines:  Number of star-shaped lines with halo.
-  Value is clamped to the range [0,250].
-  @type nLines:  int
-  @ivar nRings:  Number of rings with halo.
-  Value is clamped to the range [0,24].
-  @type nRings:  int
-  @ivar nStars:  Number of star points with halo.
-  Value is clamped to the range [3,50].
-  @type nStars:  int
-  @ivar name:  Material data name.
-  @type name:  str
-  @ivar oopsLoc: Material OOPs location.  Returns None if material not found in list.
-  @type oopsLoc:  list of 2 floats
-  @ivar oopsSel:  Material OOPs selection flag.
-  Value must be in the range [0,1].
-  @type oopsSel:  int
-  @ivar rayMirr:  Mirror reflection amount for raytrace.
-  Value is clamped to the range [0.0,1.0].
-  @type rayMirr:  float
-  @ivar rayMirrDepth:  Amount of raytrace inter-reflections.
-  Value is clamped to the range [0,10].
-  @type rayMirrDepth:  int
-  @ivar ref:   Amount of reflections (for shader).
-  Value is clamped to the range [0.0,1.0].
-  @type ref:  float
-  @ivar refracIndex:  Material's Index of Refraction (applies to the "Blinn" Specular Shader only.
-  Value is clamped to the range [1.0,10.0].
-  @type refracIndex:  float
-  @ivar rgbCol:  Diffuse RGB color triplet.
-  Components are clamped to the range [0.0,1.0].
-  @type rgbCol:  list of 3 floats
-  @ivar rms: Material's surface slope standard deviation ("WardIso" specular shader only).
-  Value is clamped to the range [0.0,0.4].
-  @type rms:  float
-  @ivar roughness:  Material's roughness ("Oren Nayar" diffuse shader only).
-  Value is clamped to the range [0.0,3.14].
-  @type roughness:  float
-  @ivar spec:  Degree of specularity.
-  Value is clamped to the range [0.0,2.0].
-  @type spec:  float
-  @ivar specB:  Specular color (L{specCol}) blue component.
-  Value is clamped to the range [0.0,1.0].
-  @type specB:  float
-  @ivar specCol:  Specular RGB color triplet.
-  Components are clamped to the range [0.0,1.0].
-  @type specCol:  list of 3 floats
-  @ivar specG:  Specular color (L{specCol}) green component.
-  Value is clamped to the range [0.0,1.0].
-  @type specG:  float
-  @ivar specR:  Specular color (L{specCol}) red component.
-  Value is clamped to the range [0.0,1.0].
-  @type specR:  float
-  @ivar specShader: Specular shader type.  See L{Shaders}.
-  Value must be in the range [0,4].
-  @type specShader:  int
-  @ivar specSize:  Material's specular area size ("Toon" specular shader only).
-  Value is clamped to the range [0.0,1.53].
-  @type specSize:  float
-  @ivar specSmooth:  Sets the smoothness of specular toon area.
-  Value is clamped to the range [0.0,1.0].
-  @type specSmooth:  float
-  @ivar specTransp:  Makes specular areas opaque on transparent materials.
-  Value is clamped to the range [0.0,1.0].
-  @type specTransp:  float
-  @ivar subSize:   Dimension of subflares, dots and circles.
-  Value is clamped to the range [0.1,25.0].
-  @type subSize:  float
-  @ivar transDepth:  calculated maximal.  Amount of refractions for raytrace.
-  Value is clamped to the range [0,10].
-  @type transDepth:  int
-  @ivar translucency:  Amount of diffuse shading of the back side.
-  Value is clamped to the range [0.0,1.0].
-  @type translucency:  float
-  @ivar users:  Number of material users.
-  @type users:  int
-  @ivar fakeUser: The fake user status.
-    enabling this will keep it in the blend even if there are no users.
-  @type fakeUser: bool
-  @ivar zOffset:  Artificial offset in the Z buffer (for Ztransp option).
-  Value is clamped to the range [0.0,10.0].
-  @type zOffset:  float
-  @ivar lightGroup:  Limits lights that affect this material to a group.
-  @type lightGroup:  Group or None
-  @ivar uvlayer:  The uv layer name to use, when UV mapping is enabled.
-  @type uvlayer:  string
-  @warning: Most member variables assume values in some [Min, Max] interval.
-   When trying to set them, the given parameter will be clamped to lie in
-   that range: if val < Min, then val = Min, if val > Max, then val = Max.
-  """
-
-  def getName():
-    """
-    Get the name of this Material object.
-    @rtype: string
-    """
-
-  def setName(name):
-    """
-    Set the name of this Material object.
-    @type name: string
-    @param name: The new name.
-    """
-
-  def getIpo():
-    """
-    Get the Ipo associated with this material, if any.
-    @rtype: Ipo
-    @return: the wrapped ipo or None.
-    """
-
-  def setIpo(ipo):
-    """
-    Link an ipo to this material.
-    @type ipo: Blender Ipo
-    @param ipo: a material type ipo.
-    """
-
-  def clearIpo():
-    """
-    Unlink the ipo from this material.
-    @return: True if there was an ipo linked or False otherwise.
-    """
-
-  def insertIpoKey(keytype):
-    """
-    Inserts keytype values in material ipo at curframe. Uses module constants.
-    @type keytype: Integer
-    @param keytype:
-           -RGB
-           -ALPHA
-           -HALOSIZE
-           -MODE
-           -ALLCOLOR
-           -ALLMIRROR
-           -OFS
-           -SIZE
-           -ALLMAPPING
-    @return: py_none
-    """
-
-  def getMode():
-    """
-    Get this Material's mode flags.
-    @rtype: int
-    @return: B{OR'ed value}. Use the Modes dictionary to check which flags
-        are 'on'.
-
-        Example::
-          import Blender
-          from Blender import Material
-          flags = mymat.getMode()
-          if flags & Material.Modes['HALO']:
-            print "This material is rendered as a halo"
-          else:
-            print "Not a halo"
-    """
-
-  def setMode(param, stringN=None):
-    """
-    Set this Material's mode flags. Up to 22 mode strings can be given
-    and specify the modes which are turned 'on'.  Those not provided are 
-    turned 'off', so mat.setMode() -- without arguments -- turns off all 
-    mode flags for Material mat.  Valid mode strings are "Traceable", 
-    "Shadow", "Shadeless", "Wire", "VColLight", "VColPaint", "Halo",
-    "ZTransp", "ZInvert", "HaloRings", "HaloLines", "OnlyShadow",
-    "HaloXAlpha", "HaloStar", "TexFace", "HaloTex", "HaloPuno", "NoMist",
-    "HaloShaded", "HaloFlare", "Radio", "RayMirr", "ZTransp", "RayTransp",
-    "Env"
-
-    An integer can also be given, which directly sets the mode flag.  The
-    Modes dictionary keys can (and should) be added or ORed to specify
-    which modes to turn 'on'.  The value returned from getMode() can
-    also be modified and input to this method.
-
-    @type param: string, None or int
-    @param param: A mode value (int) or flag (string).  Can also be None.
-    @type stringN: string
-    @param stringN: A mode flag. Up to 22 flags can be set at the same time.
-    """
-
-  def getRGBCol():
-    """
-    Get the rgb color triplet sequence.
-    @rtype: list of 3 floats
-    @return: [r, g, b]
-    """
-
-  def setRGBCol(rgb = None):
-    """
-    Set the rgb color triplet sequence.  If B{rgb} is None, set the color to black.
-    @type rgb: three floats or a list of three floats
-    @param rgb: The rgb color values in [0.0, 1.0] as:
-        - a list of three floats: setRGBCol ([r, g, b]) B{or}
-        - three floats as separate parameters: setRGBCol (r,g,b).
-    """
+       """
+       The Material object
+       ===================
+        This object gives access to Materials in Blender.
+       @ivar B:  Diffuse color (L{rgbCol}) blue component.
+       Value is clamped to the range [0.0,1.0].
+       @type B:  float
+       @ivar G:  Diffuse color (L{rgbCol}) green component.
+       Value is clamped to the range [0.0,1.0].
+       @type G:  float
+       @ivar IOR:  Angular index of refraction for raytrace.
+       Value is clamped to the range [1.0,3.0].
+       @type IOR:  float
+       @ivar R:  Diffuse color (L{rgbCol}) red component.
+       Value is clamped to the range [0.0,1.0].
+       @type R:  float
+       @ivar add:  Strength of the add effect.
+       Value is clamped to the range [0.0,1.0].
+       @type add:  float
+       @ivar alpha:  Alpha (translucency) component of the material.
+       Value is clamped to the range [0.0,1.0].
+       @type alpha:  float
+       @ivar shadAlpha:  Shadow Alpha for irregular shadow buffer.
+       Value is clamped to the range [0.0,1.0].
+       @type shadAlpha:  float
+       @ivar amb:  Amount of global ambient color material receives.
+       Value is clamped to the range [0.0,1.0].
+       @type amb:  float
+       @ivar diffuseDarkness:  Material's diffuse darkness ("Minnaert" diffuse shader only).
+       Value is clamped to the range [0.0,2.0].
+       @type diffuseDarkness:  float
+       @ivar diffuseShader:  Diffuse shader type (see L{Shaders}).
+       Value must be in the range [0,3].
+       @type diffuseShader:  int
+       @ivar diffuseSize:  Material's diffuse area size ("Toon" diffuse shader only).
+       Value is clamped to the range [0.0,3.14].
+       @type diffuseSize:  float
+       @ivar diffuseSmooth:  Material's diffuse area smoothing ("Toon" diffuse shader only).
+       Value is clamped to the range [0.0,1.0].
+       @type diffuseSmooth:  float
+       @ivar emit:  Amount of light the material emits.
+       Value is clamped to the range [0.0,1.0].
+       @type emit:  float
+       @ivar filter:  Amount of filtering when transparent raytrace is enabled.
+       Value is clamped to the range [0.0,1.0].
+       @type filter:  float
+       @ivar flareBoost:  Flare's extra strength.
+       Value is clamped to the range [0.1,1.0].
+       @type flareBoost:  float
+       @ivar flareSeed:  Offset in the flare seed table.
+       Value is clamped to the range [1,255].
+       @type flareSeed:  int
+       @ivar flareSize:  Ratio of flare size to halo size.
+       Value is clamped to the range [0.1,25.0].
+       @type flareSize:  float
+       @ivar fresnelDepth:  Power of Fresnel for mirror reflection.
+       Value is clamped to the range [0.0,5.0].
+       @type fresnelDepth:  float
+       @ivar fresnelDepthFac:  Blending factor for Fresnel mirror.
+       Value is clamped to the range [1.0,5.0].
+       @type fresnelDepthFac:  float
+       @ivar fresnelTrans:  Power of Fresnel for transparency.
+       Value is clamped to the range [0.0,5.0].
+       @type fresnelTrans:  float
+       @ivar fresnelTransFac:  Blending factor for Fresnel transparency.
+       Value is clamped to the range [1.0,5.0].
+       @type fresnelTransFac:  float
+       @ivar rbFriction:  Rigid Body Friction coefficient.
+       Value is clamped to the range [0.0,100.0].
+       @type rbFriction:  float
+       @ivar rbRestitution:  Rigid Body Friction restitution.
+       Value is clamped to the range [0.0,1.0].
+       @type rbRestitution:  float
+       @ivar haloSeed:  Randomizes halo ring dimension and line location.
+       Value is clamped to the range [1,255].
+       @type haloSeed:  int
+       @ivar haloSize:  Dimension of the halo.
+       Value is clamped to the range [0.0,100.0].
+       @type haloSize:  float
+       @ivar hard:  Hardness of the specularity.
+       Value is clamped to the range [1,255].
+       @type hard:  int
+       @ivar ipo:  Material Ipo data.
+       Contains the Ipo if one is assigned to the object, None otherwise.  Setting to None clears the current Ipo.
+       @type ipo:  Blender Ipo
+       @ivar mirB:  Mirror color (L{mirCol}) blue component.
+       Value is clamped to the range [0.0,1.0].
+       @type mirB:  float
+       @ivar mirCol:  Mirror RGB color triplet.
+       Components are clamped to the range [0.0,1.0].
+       @type mirCol:  list of 3 floats
+       @ivar mirG:  Mirror color (L{mirCol}) green component.
+       Value is clamped to the range [0.0,1.0].
+       @type mirG:  float
+       @ivar mirR:  Mirror color (L{mirCol}) red component.
+       Value is clamped to the range [0.0,1.0].
+       @type mirR:  float
+       @ivar mode:  Mode mode bitfield.  See L{the Modes dictionary<Modes>} keys and descriptions.
+       @type mode:  int
+       @ivar nFlares:  Number of subflares with halo.
+       Value is clamped to the range [1,32].
+       @type nFlares:  int
+       @ivar nLines:  Number of star-shaped lines with halo.
+       Value is clamped to the range [0,250].
+       @type nLines:  int
+       @ivar nRings:  Number of rings with halo.
+       Value is clamped to the range [0,24].
+       @type nRings:  int
+       @ivar nStars:  Number of star points with halo.
+       Value is clamped to the range [3,50].
+       @type nStars:  int
+       @ivar oopsLoc: Material OOPs location.  Returns None if material not found in list.
+       @type oopsLoc:  list of 2 floats
+       @ivar oopsSel:  Material OOPs selection flag.
+       Value must be in the range [0,1].
+       @type oopsSel:  int
+       @ivar rayMirr:  Mirror reflection amount for raytrace.
+       Value is clamped to the range [0.0,1.0].
+       @type rayMirr:  float
+       @ivar rayMirrDepth:  Amount of raytrace inter-reflections.
+       Value is clamped to the range [0,10].
+       @type rayMirrDepth:  int
+       @ivar ref:   Amount of reflections (for shader).
+       Value is clamped to the range [0.0,1.0].
+       @type ref:  float
+       @ivar refracIndex:  Material's Index of Refraction (applies to the "Blinn" Specular Shader only.
+       Value is clamped to the range [1.0,10.0].
+       @type refracIndex:  float
+       @ivar rgbCol:  Diffuse RGB color triplet.
+       Components are clamped to the range [0.0,1.0].
+       @type rgbCol:  list of 3 floats
+       @ivar rms: Material's surface slope standard deviation ("WardIso" specular shader only).
+       Value is clamped to the range [0.0,0.4].
+       @type rms:  float
+       @ivar roughness:  Material's roughness ("Oren Nayar" diffuse shader only).
+       Value is clamped to the range [0.0,3.14].
+       @type roughness:  float
+       @ivar spec:  Degree of specularity.
+       Value is clamped to the range [0.0,2.0].
+       @type spec:  float
+       @ivar specB:  Specular color (L{specCol}) blue component.
+       Value is clamped to the range [0.0,1.0].
+       @type specB:  float
+       @ivar specCol:  Specular RGB color triplet.
+       Components are clamped to the range [0.0,1.0].
+       @type specCol:  list of 3 floats
+       @ivar specG:  Specular color (L{specCol}) green component.
+       Value is clamped to the range [0.0,1.0].
+       @type specG:  float
+       @ivar specR:  Specular color (L{specCol}) red component.
+       Value is clamped to the range [0.0,1.0].
+       @type specR:  float
+       @ivar specShader: Specular shader type.  See L{Shaders}.
+       Value must be in the range [0,4].
+       @type specShader:  int
+       @ivar specSize:  Material's specular area size ("Toon" specular shader only).
+       Value is clamped to the range [0.0,1.53].
+       @type specSize:  float
+       @ivar specSmooth:  Sets the smoothness of specular toon area.
+       Value is clamped to the range [0.0,1.0].
+       @type specSmooth:  float
+       @ivar specTransp:  Makes specular areas opaque on transparent materials.
+       Value is clamped to the range [0.0,1.0].
+       @type specTransp:  float
+       @ivar subSize:   Dimension of subflares, dots and circles.
+       Value is clamped to the range [0.1,25.0].
+       @type subSize:  float
+       @ivar transDepth:  calculated maximal.  Amount of refractions for raytrace.
+       Value is clamped to the range [0,10].
+       @type transDepth:  int
+       @ivar translucency:  Amount of diffuse shading of the back side.
+       Value is clamped to the range [0.0,1.0].
+       @type translucency:  float
+       @ivar zOffset:  Artificial offset in the Z buffer (for Ztransp option).
+       Value is clamped to the range [0.0,10.0].
+       @type zOffset:  float
+       @ivar lightGroup:  Limits lights that affect this material to a group.
+       @type lightGroup:  Group or None
+       @ivar uvlayer:  The uv layer name to use, when UV mapping is enabled.
+       @type uvlayer:  string
+       @warning: Most member variables assume values in some [Min, Max] interval.
+        When trying to set them, the given parameter will be clamped to lie in
+        that range: if val < Min, then val = Min, if val > Max, then val = Max.
+       """
+
+       def getName():
+               """
+               Get the name of this Material object.
+               @rtype: string
+               """
+
+       def setName(name):
+               """
+               Set the name of this Material object.
+               @type name: string
+               @param name: The new name.
+               """
+
+       def getIpo():
+               """
+               Get the Ipo associated with this material, if any.
+               @rtype: Ipo
+               @return: the wrapped ipo or None.
+               """
+
+       def setIpo(ipo):
+               """
+               Link an ipo to this material.
+               @type ipo: Blender Ipo
+               @param ipo: a material type ipo.
+               """
+
+       def clearIpo():
+               """
+               Unlink the ipo from this material.
+               @return: True if there was an ipo linked or False otherwise.
+               """
+
+       def insertIpoKey(keytype):
+               """
+               Inserts keytype values in material ipo at curframe. Uses module constants.
+               @type keytype: Integer
+               @param keytype:
+                                        -RGB
+                                        -ALPHA
+                                        -HALOSIZE
+                                        -MODE
+                                        -ALLCOLOR
+                                        -ALLMIRROR
+                                        -OFS
+                                        -SIZE
+                                        -ALLMAPPING
+               @return: py_none
+               """
+
+       def getMode():
+               """
+               Get this Material's mode flags.
+               @rtype: int
+               @return: B{OR'ed value}. Use the Modes dictionary to check which flags
+                               are 'on'.
+
+                               Example::
+                                       import Blender
+                                       from Blender import Material
+                                       flags = mymat.getMode()
+                                       if flags & Material.Modes['HALO']:
+                                               print "This material is rendered as a halo"
+                                       else:
+                                               print "Not a halo"
+               """
+
+       def setMode(param, stringN=None):
+               """
+               Set this Material's mode flags. Up to 22 mode strings can be given
+               and specify the modes which are turned 'on'.  Those not provided are 
+               turned 'off', so mat.setMode() -- without arguments -- turns off all 
+               mode flags for Material mat.  Valid mode strings are "Traceable", 
+               "Shadow", "Shadeless", "Wire", "VColLight", "VColPaint", "Halo",
+               "ZTransp", "ZInvert", "HaloRings", "HaloLines", "OnlyShadow",
+               "HaloXAlpha", "HaloStar", "TexFace", "HaloTex", "HaloPuno", "NoMist",
+               "HaloShaded", "HaloFlare", "Radio", "RayMirr", "ZTransp", "RayTransp",
+               "Env"
+
+               An integer can also be given, which directly sets the mode flag.  The
+               Modes dictionary keys can (and should) be added or ORed to specify
+               which modes to turn 'on'.  The value returned from getMode() can
+               also be modified and input to this method.
+
+               @type param: string, None or int
+               @param param: A mode value (int) or flag (string).  Can also be None.
+               @type stringN: string
+               @param stringN: A mode flag. Up to 22 flags can be set at the same time.
+               """
+
+       def getRGBCol():
+               """
+               Get the rgb color triplet sequence.
+               @rtype: list of 3 floats
+               @return: [r, g, b]
+               """
+
+       def setRGBCol(rgb = None):
+               """
+               Set the rgb color triplet sequence.  If B{rgb} is None, set the color to black.
+               @type rgb: three floats or a list of three floats
+               @param rgb: The rgb color values in [0.0, 1.0] as:
+                               - a list of three floats: setRGBCol ([r, g, b]) B{or}
+                               - three floats as separate parameters: setRGBCol (r,g,b).
+               """
  
-  def getSpecCol():
-    """
-    Get the specular color triplet sequence.
-    @rtype: list of 3 floats
-    @return: [specR, specG, specB]
-    """
-
-  def setSpecCol(rgb = None):
-    """
-    Set the specular color triplet sequence.  If B{rgb} is None, set the color to black.
-    @type rgb: three floats or a list of three floats
-    @param rgb: The rgb color values in [0.0, 1.0] as:
-        - a list of three floats: setSpecCol ([r, g, b]) B{or}
-        - three floats as separate parameters: setSpecCol (r,g,b).
-    """
-
-  def getMirCol():
-    """
-    Get the mirror color triplet sequence.
-    @rtype: list of 3 floats
-    @return: [mirR, mirG, mirb]
-    """
-
-  def setMirCol(rgb = None):
-    """
-    Set the mirror color triplet sequence.  If B{rgb} is None, set the color to black.
-    @type rgb: three floats or a list of three floats
-    @param rgb: The rgb color values in [0.0, 1.0] as:
-        - a list of three floats: setMirCol ([r, g, b]) B{or}
-        - three floats as separate parameters: setMirCol (r,g,b).
-    """
-
-  def getAlpha():
-    """
-    Get the alpha (transparency) value.
-    @rtype: float
-    """
-
-  def setAlpha(alpha):
-    """
-    Set the alpha (transparency) value.
-    @type alpha: float
-    @param alpha: The new value in [0.0, 1.0].
-    """
-
-  def getAmb():
-    """
-    Get the ambient color blend factor.
-    @rtype: float
-    """
-
-  def setAmb(amb):
-    """
-    Set the ambient color blend factor.
-    @type amb: float
-    @param amb:  The new value in [0.0, 1.0].
-    """
-
-  def getEmit():
-    """
-    Get the emitting light intensity.
-    @rtype: float
-    """
-
-  def setEmit(emit):
-    """
-    Set the emitting light intensity.
-    @type emit: float
-    @param emit: The new value in [0.0, 1.0].
-    """
-
-  def getRef():
-    """
-    Get the reflectivity value.
-    @rtype: float
-    """
-
-  def setRef(ref):
-    """
-    Set the reflectivity value.
-    @type ref: float
-    @param ref: The new value in [0.0, 1.0].
-    """
-
-  def getSpec():
-    """
-    Get the specularity value.
-    @rtype: float
-    """
-
-  def setSpec(spec):
-    """
-    Set the specularity value.
-    @type spec: float
-    @param spec: The new value in [0.0, 2.0].
-    """
-
-  def getSpecTransp():
-    """
-    Get the specular transparency.
-    @rtype: float
-    """
-
-  def setSpecTransp(spectransp):
-    """
-    Set the specular transparency.
-    @type spectransp: float
-    @param spectransp: The new value in [0.0, 1.0].
-    """
-
-  def setSpecShader(specShader):
-    """
-    Set the material's specular shader from one of the shaders in Material.Shaders dict.
-    @type specShader: int
-    @param specShader: The new value in [0, 4].
-    """
-
-  def getSpecShader(specShader):
-    """
-    Get the material's specular shader from one of the shaders in Material.Shaders dict.
-    @rtype: int
-    """
-
-  def setDiffuseShader(diffuseShader):
-    """
-    Set the material's diffuse shader from one of the shaders in Material.Shaders dict.
-    @type diffuseShader: int
-    @param diffuseShader: The new value in [0, 3].
-    """
-
-  def getDiffuseShader():
-    """
-    Get the material's diffuse shader from one of the shaders in Material.Shaders dict.
-    @rtype: int
-    """
-
-  def setRoughness(roughness):
-    """
-    Set the material's roughness (applies to the \"Oren Nayar\" Diffuse Shader only)
-    @type roughness: float
-    @param roughness: The new value in [0.0, 3.14].
-    """
-
-  def getRoughness():
-    """
-    Get the material's roughness (applies to the \"Oren Nayar\" Diffuse Shader only)
-    @rtype: float
-    """
-
-  def setSpecSize(specSize):
-    """
-    Set the material's size of specular area (applies to the \"Toon\" Specular Shader only)
-    @type specSize: float
-    @param specSize: The new value in [0.0, 1.53].
-    """
-
-  def getSpecSize():
-    """
-    Get the material's size of specular area (applies to the \"Toon\" Specular Shader only)
-    @rtype specSize: float
-    """
-
-  def setSpecSize(diffuseSize):
-    """
-    Set the material's size of diffuse area (applies to the \"Toon\" Diffuse Shader only)
-    @type diffuseSize: float
-    @param diffuseSize: The new value in [0.0, 3.14].
-    """
-
-  def getSpecSize():
-    """
-    Get the material's size of diffuse area (applies to the \"Toon\" Diffuse Shader only)
-    @rtype: float
-    """
-
-  def setSpecSmooth(specSmooth):
-    """
-    Set the material's smoothing of specular area (applies to the \"Toon\" Specular Shader only)
-    @type specSmooth: float
-    @param specSmooth: The new value in [0.0, 1.0].
-    """
-
-  def getSpecSmooth():
-    """
-    Get the material's smoothing of specular area (applies to the \"Toon\" Specular Shader only)
-    @rtype: float
-    """
-
-  def setDiffuseSmooth(diffuseSmooth):
-    """
-    Set the material's smoothing of diffuse area (applies to the \"Toon\" Diffuse Shader only)
-    @type diffuseSmooth: float
-    @param diffuseSmooth: The new value in [0.0, 1.0].
-    """
-
-  def getDiffuseSmooth():
-    """
-    Get the material's smoothing of diffuse area (applies to the \"Toon\" Diffuse Shader only)
-    @rtype: float
-    """
-
-  def setDiffuseDarkness(diffuseDarkness):
-    """
-    Set the material's diffuse darkness (applies to the \"Minnaert\" Diffuse Shader only)
-    @type diffuseDarkness: float
-    @param diffuseDarkness: The new value in [0.0, 2.0].
-    """
-
-  def getDiffuseDarkness():
-    """
-    Get the material's diffuse darkness (applies to the \"Minnaert\" Diffuse Shader only)
-    @rtype: float
-    """
-
-  def setRefracIndex(refracIndex):
-    """
-    Set the material's Index of Refraction (applies to the \"Blinn\" Specular Shader only)
-    @type refracIndex: float
-    @param refracIndex: The new value in [1.0, 10.0].
-    """
-
-  def getRefracIndex():
-    """
-    Get the material's Index of Refraction (applies to the \"Blinn\" Specular Shader only)
-    @rtype: float
-    """
-
-  def setRms(rms):
-    """
-    Set the material's standard deviation of surface slope (applies to the \"WardIso\" Specular Shader only)
-    @type rms: float
-    @param rms: The new value in [0.0, 0.4].
-    """
-
-  def getRms():
-    """
-    Get the material's standard deviation of surface slope (applies to the \"WardIso\" Specular Shader only)
-    @rtype: float
-    """
-
-  def setFilter(filter):
-    """
-    Set the material's amount of filtering when transparent raytrace is enabled
-    @type filter: float
-    @param filter: The new value in [0.0, 1.0].
-    """
-
-  def getFilter():
-    """
-    Get the material's amount of filtering when transparent raytrace is enabled
-    @rtype: float
-    """
-
<