class elements:
  elements.__init__  
  elements.init_colors  
  elements.set_color  
  elements.reset_color  
  elements.get_color  
  elements.toggle_help  
  elements.set_info  
  elements.messagebox_show  
  elements.messagebox_hide  
  elements.screenshot  
  elements.screencast_start  
  elements.screencast_stop  
  elements.screencast_encode_callback  
  elements.save_surface  
  elements.clear  
  elements.flipy  
  elements.vec2df  
  elements.autoset_screen_size  
  elements.is_inside  
  elements.update  
  elements.draw  
  elements.draw_shape  
  elements.add_wall  
  elements.add_ball  
  elements.add_square  
  elements.add_poly  
  elements.apply_impulse  
  elements.get_element_count  

=== elements.__init__ ===
 elements.__init__ (gravity= (0.0,-900.0))
    - Init function: init pymunk, get screen size, init space, ...
    - Parameter: gravity == (int(x), int(y))
    - Returns: Elements()


=== elements.init_colors ===
 elements.init_colors ()
    - Init self.colors with a fix set of hex colors
    - Returns: -


=== elements.set_color ===
 elements.set_color (clr)
    - Set a color for all future Elements, until reset_color() is called
    - Parameter: clr == (Hex or RGB)
    - Returns: -


=== elements.reset_color ===
 elements.reset_color ()
    - All Elements from now on will be drawn in random colors
    - Returns: -


=== elements.get_color ===
 elements.get_color ()
    - Get a color - either the fixed one or the next from self.colors
    - Returns: clr = ((R), (G), (B))


=== elements.toggle_help ===
 elements.toggle_help ()
    - Toggle Help on and off
    - Returns: -


=== elements.set_info ===
 elements.set_info (txt)
    - Create the Surface for the Infotext at the Upper Left Corner
    - Parameter: txt == str()
    - Returns: -


=== elements.messagebox_show ===
 elements.messagebox_show (txt, delay=None)
    - Add a message box at the center on drawing
    - Parameter: txt == str()
    - Optional: delay (in seconds, until box disappears)
    - Returns: -


=== elements.messagebox_hide ===
 elements.messagebox_hide ()
    - Hide the message box
    - Returns: -


=== elements.screenshot ===
 elements.screenshot (filename='elements.screenshot', ext='tga')
    - Make a Screenshot in .tga format, if there is no screencast running
    - Optional: filename == str() (no extension), ext == str() (does not work -- always saves as .tga)
    - Returns: -


=== elements.screencast_start ===
 elements.screencast_start (fn='screencast')
    - Starts saving one image per frame in snapshots/ (as .tga), for encoding with mencoder
    - Optional: fn == str() (filename without extension)
    - Returns: -


=== elements.screencast_stop ===
 elements.screencast_stop ()
    - Stop the image saving and start encoding (mencoder) the images to a .avi video
    - Returns: -


=== elements.screencast_encode_callback ===
 elements.screencast_encode_callback ()
    - Callback function when encoding is done -> remove info & resume physics
    - Returns: -


=== elements.save_surface ===
 elements.save_surface (surface, fn='surface', ext='tga')
    - Saves a surface to a local file
    - Parameter: surface == pygame.Surface()
    - Optional: fn == str(fn_without_ext), ext == str()
    - Returns: fullname == str(full_name_of_file)


=== elements.clear ===
 elements.clear ()
    - Clear & Reset the Physic Space (Remove all Elements)
    - Returns: -


=== elements.flipy ===
 elements.flipy (y)
    - Convert pygame y-coordinate to chipmunk's
    - Parameter: y == int()
    - Returns: int(y_new)


=== elements.vec2df ===
 elements.vec2df (pos)
    - pos -> vec2d (with flipped y)
    - Parameter: pos == (int(x), int(pygame_y))
    - Returns: vec2d(int(x), int(chipmunk_y))


=== elements.autoset_screen_size ===
 elements.autoset_screen_size (size=None)
    - Get the current PyGame Screen Size, or sets it manually
    - Optional: size == (int(width), int(height))
    - Returns: -


=== elements.is_inside ===
 elements.is_inside (pos, tolerance=3000)
    - Check if pos is inside screen + tolerance
    - Parameter: pos == (int(x), int(y))
    - Optional: tolerance == int(pixels)
    - Returns: True if inside, False if outside


=== elements.update ===
 elements.update (fps=50.0, steps=5)
    - Update the Physics Space
    - Optional: fps == int(fps), steps == int(space_steps_per_udate)
    - Returns: -


=== elements.draw ===
 elements.draw (surface, addtext=True)
    - Draw All Shapes, and removes the ones outside
    - Parameter: surface == pygame.Surface()
    - Optional: addtext == True/False (if True, also add Info-Text to surface)
    - Returns: -


=== elements.draw_shape ===
 elements.draw_shape (surface, shape)
    - Draw a shape (can be either Circle, Segment or Poly).
    - Parameter: surface == pygame.Surface(), shape == pymunk.Shape()
    - Returns: True if shape is inside screen, else False (for removal)


=== elements.add_wall ===
 elements.add_wall (p1, p2, friction=1.0, elasticity=0.1, mass=inf, inertia=inf)
    - Adds a fixed Wall pos = (int(x), int(y))
    - Parameter: p1 == pos(startpoint), p2 == pos(endpoint)
    - Optional: See #physical_parameters
    - Returns: pymunk.Shape() (=> .Segment())


=== elements.add_ball ===
 elements.add_ball (pos, radius=15, density=0.1, inertia=1000, friction=0.5, elasticity=0.3)
    - Adds a Ball
    - Parameter: pos == (int(x), int(y))
    - Optional: See #physical_parameters
    - Returns: pymunk.Shape() (=> .Circle())


=== elements.add_square ===
 elements.add_square (pos, a=18, density=0.1, friction=0.2, elasticity=0.3)
    - Adding a Square | Note that a is actually half a side, due to vector easyness :)
    - Parameter: pos == (int(x), int(y))
    - Optional: a == (sidelen/2) | #physical_parameters
    - Returns: pymunk.Shape() (=> .Poly())


=== elements.add_poly ===
 elements.add_poly (points, density=0.1, friction=2.0, elasticity=0.3)
    - Mass will be calculated out of mass = A * density
    - Parameter: points == [(int(x), int(y)), (int(x), int(y)), ...]
    - Optional: See #physical_parameters
    - Returns: pymunk.Shape() (=> .Poly())


=== elements.apply_impulse ===
 elements.apply_impulse (shape, impulse_vector)
    - Apply an Impulse to a given Shape
    - Parameter: shape == pymunk.Shape(), impulse_vector == (int(x), int(y))
    - Returns: -


=== elements.get_element_count ===
 elements.get_element_count ()
    - Get the current (approx.) element count
    - Returns: int(element_count)


