Index: trunk/src/lib/coord/p_node.cc
===================================================================
--- trunk/src/lib/coord/p_node.cc	(revision 5090)
+++ trunk/src/lib/coord/p_node.cc	(revision 5091)
@@ -147,5 +147,5 @@
     while (element != NULL)
     {
-      LoadParam<PNode>(root, "parent", this, &PNode::addChild, true)
+      LoadParam<PNode>(element, "parent", this, &PNode::addChild, true)
           .describe("adds a new Child to the current Node.");
 
@@ -210,11 +210,5 @@
 /**
  * @param absCoord set absolute coordinate
-
-   it is very importand, that you use this function, if you want to update the
-   absCoordinates. If you don't use this, the PNode won't recognize, that something
-   has changed and won't update the children Nodes.
-
-@todo check if this does what it should
-*/
+ */
 void PNode::setAbsCoor (const Vector& absCoord)
 {
@@ -251,5 +245,5 @@
 
 /**
- *  shift coordinate (abs and rel)
+ *  shift coordinate relative
  * @param shift shift vector
 
@@ -269,7 +263,4 @@
    yea right... shorter...
  *
- * @todo this is ambiguous, from the outside one does not know it absCoor has been changed
- * this might lead to strange artefacts !!
-
 */
 void PNode::shiftCoor (const Vector& shift)
@@ -282,9 +273,5 @@
  *  set relative direction
  * @param relDir to its parent
-
-   it is very importand, that you use this function, if you want to update the
-   relDirection. If you don't use this, the PNode won't recognize, that something
-   has changed and won't update the children Nodes.
-*/
+ */
 void PNode::setRelDir (const Quaternion& relDir)
 {
@@ -335,11 +322,7 @@
 
 /**
- *  sets the absolute direction (0,0,1)
+ *  sets the absolute direction
  * @param absDir absolute coordinates
- *
- * it is very importand, that you use this function, if you want to update the
- * absDirection. If you don't use this, the PNode won't recognize, that something
- * has changed and won't update the children Nodes.
-*/
+ */
 void PNode::setAbsDir (const Quaternion& absDir)
 {
@@ -366,8 +349,7 @@
 
 /**
- *  shift coordinate (abs and rel)
- * @param shift vector
- * @todo implement this
-*/
+ * shift Direction
+ * @param shift the direction around which to shift.
+ */
 void PNode::shiftDir (const Quaternion& shift)
 {
@@ -378,5 +360,5 @@
 /**
  *  adds a child and makes this node to a parent
- * @param pNode child reference
+ * @param child child reference
  * @param parentMode on which changes the child should also change ist state
  *
@@ -397,5 +379,5 @@
 
 /**
- * @see PNode::addChild(PNode* parent);
+ * @see PNode::addChild(PNode* child);
  * @param childName the name of the child to add to this PNode
  */
@@ -409,5 +391,5 @@
 /**
  *  removes a child from the node
- * @param pNode the child to remove from this pNode.
+ * @param child the child to remove from this pNode.
  *
  * Children from pNode will not be lost, they are referenced to NullPointer
@@ -423,5 +405,5 @@
  *  remove this pnode from the tree and adds all following to NullParent
 
-   this can be the case, if an entity in the world is been destroyed.
+   this can be the case, if an entity in the world is being destroyed.
 */
 void PNode::remove()
@@ -623,5 +605,5 @@
  *  displays some information about this pNode
  * @param depth The deph into which to debug the children of this PNode to.
-  (0: all children will be debugged, 1: only this PNode, 2: this and direct children...)
+ * (0: all children will be debugged, 1: only this PNode, 2: this and direct children...)
  * @param level The n-th level of the Node we draw (this is internal and only for nice output)
 */
Index: trunk/src/lib/graphics/render2D/element_2d.cc
===================================================================
--- trunk/src/lib/graphics/render2D/element_2d.cc	(revision 5090)
+++ trunk/src/lib/graphics/render2D/element_2d.cc	(revision 5091)
@@ -119,7 +119,36 @@
       .describe("if the Element is visible or not");
 
-//   LoadParam<Element2D>(root, "2d-position", this, &Element2D::setPosition2D)
-//       .describe("the _relative_ position (away from alignment) this 2d-element shows");
-
+
+  // PNode-style:
+  LoadParam<Element2D>(root, "rel-coor", this, &Element2D::setRelCoor2D)
+      .describe("Sets The relative position of the Node to its parent.");
+
+  LoadParam<Element2D>(root, "abs-coor", this, &Element2D::setAbsCoor2D)
+      .describe("Sets The absolute Position of the Node.");
+
+  LoadParam<Element2D>(root, "rel-dir", this, &Element2D::setRelDir2D)
+      .describe("Sets The relative rotation of the Node to its parent.");
+
+  LoadParam<Element2D>(root, "abs-dir", this, &Element2D::setAbsDir2D)
+      .describe("Sets The absolute rotation of the Node.");
+
+  LoadParam<Element2D>(root, "parent", this, &Element2D::setParent2D)
+      .describe("the Name of the Parent of this Element2D");
+
+  LoadParam<Element2D>(root, "parent-mode", this, &Element2D::setParentMode2D)
+      .describe("the mode to connect this node to its parent ()");
+
+  // cycling properties
+  if (root != NULL)
+  {
+    const TiXmlElement* element = root->FirstChildElement();
+    while (element != NULL)
+    {
+      LoadParam<Element2D>(root, "parent", this, &Element2D::addChild2D, true)
+          .describe("adds a new Child to the current Node.");
+
+      element = element->NextSiblingElement();
+    }
+  }
 }
 
@@ -179,5 +208,8 @@
 }
 
-
+/**
+ * sets the relative coordinate of the Element2D to its parent
+ * @param relCoord the relative coordinate to the parent
+ */
 void Element2D::setRelCoor2D (const Vector& relCoord)
 {
@@ -187,4 +219,10 @@
 
 
+/**
+ * sets the relative coordinate of the Element2D to its Parent
+ * @param x the x coordinate
+ * @param y the y coordinate
+ * @param z the z coordinate
+ */
 void Element2D::setRelCoor2D (float x, float y, float z)
 {
@@ -192,4 +230,9 @@
 }
 
+/**
+ * sets the Relative coordinate to the parent in Pixels
+ * @param x the relCoord X
+ * @param y the relCoord Y
+ */
 void Element2D::setRelCoor2Dpx (int x, int y)
 {
@@ -200,5 +243,9 @@
 }
 
-
+/**
+ * sets a new relative position smoothely
+ * @param relCoordSoft the new Position to iterate to
+ * @param bias how fast to iterate to this position
+ */
 void Element2D::setRelCoorSoft2D(const Vector& relCoordSoft, float bias)
 {
@@ -210,4 +257,10 @@
 }
 
+/**
+ * sets a new relative position smoothely
+ * @param x the new x-coordinate in Pixels of the Position to iterate to
+ * @param y the new y-coordinate in Pixels of the Position to iterate to
+ * @param bias how fast to iterate to this position
+ */
 void Element2D::setRelCoorSoft2Dpx (int x, int y, float bias)
 {
@@ -218,5 +271,11 @@
 }
 
-
+/**
+ * set relative coordinates smoothely
+ * @param x x-relative coordinates to its parent
+ * @param y y-relative coordinates to its parent
+ * @param z z-relative coordinates to its parent
+ * @see  void PNode::setRelCoorSoft (const Vector&, float)
+ */
 void Element2D::setRelCoorSoft2D(float x, float y, float depth, float bias)
 {
@@ -224,4 +283,7 @@
 }
 
+/**
+ * @param absCoord set absolute coordinate
+ */
 void Element2D::setAbsCoor2D (const Vector& absCoord)
 {
@@ -245,4 +307,10 @@
 }
 
+/**
+ * @param x x-coordinate.
+ * @param y y-coordinate.
+ * @param z z-coordinate.
+ * @see void PNode::setAbsCoor (const Vector& absCoord)
+ */
 void Element2D::setAbsCoor2D (float x, float y, float depth)
 {
@@ -250,5 +318,9 @@
 }
 
-
+/**
+ * @param x x-coordinate in Pixels
+ * @param y y-coordinate in Pixels
+ * @see void PNode::setAbsCoor (const Vector& absCoord)
+ */
 void Element2D::setAbsCoor2Dpx (int x, int y)
 {
@@ -259,4 +331,10 @@
 }
 
+/**
+ *  shift coordinate ralative
+ * @param shift shift vector
+ *
+ * This simply adds the shift-Vector to the relative Coordinate
+ */
 void Element2D::shiftCoor2D (const Vector& shift)
 {
@@ -266,5 +344,9 @@
 }
 
-
+/**
+ * shifts in PixelSpace
+ * @param x the pixels to shift in X
+ * @param y the pixels to shift in Y
+ */
 void Element2D::shiftCoor2Dpx (int x, int y)
 {
@@ -274,5 +356,8 @@
 }
 
-
+/**
+ *  set relative direction
+ * @param relDir to its parent
+ */
 void Element2D::setRelDir2D (float relDir)
 {
@@ -281,4 +366,9 @@
 }
 
+/**
+ * sets the Relative Direction of this node to its parent in a Smoothed way
+ * @param relDirSoft the direction to iterate to smoothely.
+ * @param bias how fast to iterate to the new Direction
+ */
 void Element2D::setRelDirSoft2D(float relDirSoft, float bias)
 {
@@ -290,4 +380,8 @@
 }
 
+/**
+ *  sets the absolute direction
+ * @param absDir absolute coordinates
+ */
 void Element2D::setAbsDir2D (float absDir)
 {
@@ -300,4 +394,8 @@
 }
 
+/**
+ * shift Direction
+ * @param shift the direction around which to shift.
+ */
 void Element2D::shiftDir2D (float shiftDir)
 {
@@ -306,5 +404,11 @@
 }
 
-
+/**
+ *  adds a child and makes this node to a parent
+ * @param child child reference
+ * @param parentMode on which changes the child should also change ist state
+ *
+ * use this to add a child to this node.
+ */
 void Element2D::addChild2D (Element2D* child, int parentingMod)
 {
@@ -320,4 +424,8 @@
 }
 
+/**
+ * @see Element2D::addChild(Element2D* child);
+ * @param childName the name of the child to add to this PNode
+ */
 void Element2D::addChild2D (const char* childName)
 {
@@ -327,4 +435,10 @@
 }
 
+/**
+ * removes a child from the node
+ * @param child the child to remove from this Node..
+ *
+ * Children from nodes will not be lost, they are referenced to NullPointer
+ */
 void Element2D::removeChild2D (Element2D* child)
 {
@@ -334,4 +448,9 @@
 }
 
+/**
+ * remove this pnode from the tree and adds all following to NullParent
+ *
+ * this can be the case, if an entity in the world is being destroyed.
+ */
 void Element2D::remove2D()
 {
@@ -348,5 +467,8 @@
 }
 
-
+/**
+ * sets the parent of this Element2D
+ * @param parent the Parent to set
+ */
 void Element2D::setParent2D (Element2D* parent)
 {
@@ -354,4 +476,8 @@
 }
 
+/**
+ * @see Element2D::setParent(Element2D* parent);
+ * @param parentName the name of the Parent to set to this Element2D
+ */
 void Element2D::setParent2D (const char* parentName)
 {
@@ -362,5 +488,9 @@
 }
 
-
+/**
+ * does the reparenting in a very smooth way
+ * @param parentNode the new Node to connect this node to.
+ * @param bias the speed to iterate to this new Positions
+ */
 void Element2D::softReparent2D(Element2D* parentNode, float bias)
 {
@@ -394,4 +524,9 @@
 }
 
+/**
+ * does the reparenting in a very smooth way
+ * @param parentName the name of the Parent to reconnect to
+ * @param bias the speed to iterate to this new Positions
+ */
 void Element2D::softReparent2D(const char* parentName, float bias)
 {
@@ -401,5 +536,8 @@
 }
 
-
+/**
+ *  sets the mode of this parent manually
+ * @param parentMode a String representing this parentingMode
+ */
 void Element2D::setParentMode2D (const char* parentingMode)
 {
@@ -407,5 +545,12 @@
 }
 
-
+/**
+ *  updates the absCoordinate/absDirection
+ * @param dt The time passed since the last update
+
+   this is used to go through the parent-tree to update all the absolute coordinates
+   and directions. this update should be done by the engine, so you don't have to
+   worry, normaly...
+ */
 void Element2D::update2D (float dt)
 {
@@ -541,5 +686,10 @@
 }
 
-
+/**
+ *  displays some information about this pNode
+ * @param depth The deph into which to debug the children of this Element2D to.
+ * (0: all children will be debugged, 1: only this Element2D, 2: this and direct children...)
+ * @param level The n-th level of the Node we draw (this is internal and only for nice output)
+ */
 void Element2D::debug (unsigned int depth, unsigned int level) const
 {
@@ -578,4 +728,7 @@
 #include "color.h"
 
+/**
+ * displays the Element2D at its position with its rotation as a Plane.
+ */
 void Element2D::debugDraw2D(unsigned int depth, float size, Vector color) const
 {
@@ -585,4 +738,9 @@
 
 // helper functions //
+/**
+ * converts a parentingMode into a string that is the name of it
+ * @param parentingMode the ParentingMode to convert
+ * @return the converted string
+ */
 const char* Element2D::parentingModeToChar2D(int parentingMode)
 {
@@ -599,4 +757,9 @@
 }
 
+/**
+ * converts a parenting-mode-string into a int
+ * @param parentingMode the string naming the parentingMode
+ * @return the int corresponding to the named parentingMode
+ */
 E2D_PARENT_MODE Element2D::charToParentingMode2D(const char* parentingMode)
 {
