Index: trunk/src/lib/graphics/render2D/billboard.cc
===================================================================
--- trunk/src/lib/graphics/render2D/billboard.cc	(revision 7199)
+++ trunk/src/lib/graphics/render2D/billboard.cc	(revision 7221)
@@ -78,5 +78,5 @@
 void Billboard::loadParams(const TiXmlElement* root)
 {
-  LoadParam(root, "texture", this, Billboard, setTexture)
+  LoadParam(root, "texture", this->material, Material, setDiffuseMap)
       .describe("the texture-file to load onto the Billboard");
 
@@ -100,5 +100,5 @@
  * @param textureFile The texture-file to load onto the crosshair
  */
-void Billboard::setTexture(const char* textureFile)
+void Billboard::setTexture(const std::string& textureFile)
 {
   this->material->setDiffuseMap(textureFile);
Index: trunk/src/lib/graphics/render2D/billboard.h
===================================================================
--- trunk/src/lib/graphics/render2D/billboard.h	(revision 7199)
+++ trunk/src/lib/graphics/render2D/billboard.h	(revision 7221)
@@ -30,5 +30,5 @@
 
     void setSize(float sizeX, float sizeY);
-    void setTexture(const char* textureFile);
+    void setTexture(const std::string& textureFile);
     void attachTo(PNode* pnode);
 
Index: trunk/src/lib/graphics/render2D/element_2d.cc
===================================================================
--- trunk/src/lib/graphics/render2D/element_2d.cc	(revision 7199)
+++ trunk/src/lib/graphics/render2D/element_2d.cc	(revision 7221)
@@ -180,13 +180,13 @@
  * @param alignment the alignment @see loadParams
 */
-void Element2D::setAlignment(const char* alignment)
-{
-  if (!strcmp(alignment, "center"))
+void Element2D::setAlignment(const std::string& alignment)
+{
+  if (alignment == "center")
     this->setAlignment(E2D_ALIGN_CENTER);
-  else if (!strcmp(alignment, "left"))
+  else if (alignment == "left")
     this->setAlignment(E2D_ALIGN_LEFT);
-  else if (!strcmp(alignment, "right"))
+  else if (alignment == "right")
     this->setAlignment(E2D_ALIGN_RIGHT);
-  else if (!strcmp(alignment, "screen-center"))
+  else if (alignment == "screen-center")
     this->setAlignment(E2D_ALIGN_SCREEN_CENTER);
 }
@@ -213,7 +213,7 @@
 /**
  * sets the layer onto which this 2D-element is projected to.
- * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const char* layer)
- */
-void Element2D::setLayer(const char* layer)
+ * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const std::string& layer)
+ */
+void Element2D::setLayer(const std::string& layer)
 {
   this->setLayer(Element2D::charToLayer2D(layer));
@@ -235,5 +235,5 @@
  * @param bindNode the name of the Node (should be existing)
  */
-void Element2D::setBindNode(const char* bindNode)
+void Element2D::setBindNode(const std::string& bindNode)
 {
   const PNode* tmpBindNode = dynamic_cast<const PNode*>(ClassList::getObject(bindNode, CL_PARENT_NODE));
@@ -572,5 +572,5 @@
  * @param childName the name of the child to add to this PNode
  */
-void Element2D::addChild2D (const char* childName)
+void Element2D::addChild2D (const std::string& childName)
 {
   Element2D* childNode = dynamic_cast<Element2D*>(ClassList::getObject(childName, CL_ELEMENT_2D));
@@ -651,5 +651,5 @@
  * @param parentName the name of the Parent to set to this Element2D
  */
-void Element2D::setParent2D (const char* parentName)
+void Element2D::setParent2D (const std::string& parentName)
 {
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
@@ -658,5 +658,5 @@
   else
     PRINTF(2)("Not Found Element2D's (%s::%s) new Parent by Name: %s\n",
-                this->getClassName(), this->getName(), parentName);
+                this->getClassName(), this->getName(), parentName.c_str());
 }
 
@@ -704,5 +704,5 @@
  * @param bias the speed to iterate to this new Positions
  */
-void Element2D::setParentSoft2D(const char* parentName, float bias)
+void Element2D::setParentSoft2D(const std::string& parentName, float bias)
 {
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
@@ -724,7 +724,7 @@
  * @param parentMode a String representing this parentingMode
  */
-void Element2D::setParentMode2D (const char* parentingMode)
-{
-  this->setParentMode2D(Element2D::charToParentingMode2D(parentingMode));
+void Element2D::setParentMode2D (const std::string& parentingMode)
+{
+  this->setParentMode2D(Element2D::stringToParentingMode2D(parentingMode));
 }
 
@@ -952,5 +952,5 @@
             this->relCoordinate.y,
             this->getAbsDir2D(),
-            Element2D::parentingModeToChar2D(parentMode),
+            Element2D::parentingModeToString2D(parentMode),
             Element2D::layer2DToChar(this->layer));
 
@@ -1074,5 +1074,5 @@
  * @return the converted string
  */
-const char* Element2D::parentingModeToChar2D(int parentingMode)
+const char* Element2D::parentingModeToString2D(int parentingMode)
 {
   if (parentingMode == E2D_PARENT_LOCAL_ROTATE)
@@ -1093,15 +1093,15 @@
  * @return the int corresponding to the named parentingMode
  */
-E2D_PARENT_MODE Element2D::charToParentingMode2D(const char* parentingMode)
-{
-  if (!strcmp(parentingMode, "local-rotate"))
+E2D_PARENT_MODE Element2D::stringToParentingMode2D(const std::string& parentingMode)
+{
+  if (parentingMode == "local-rotate")
     return (E2D_PARENT_LOCAL_ROTATE);
-  else  if (!strcmp(parentingMode, "rotate-movement"))
+  else  if (parentingMode == "rotate-movement")
     return (E2D_PARENT_ROTATE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "movement"))
+  else  if (parentingMode == "movement")
     return (E2D_PARENT_MOVEMENT);
-  else  if (!strcmp(parentingMode, "all"))
+  else  if (parentingMode == "all")
     return (E2D_PARENT_ALL);
-  else  if (!strcmp(parentingMode, "rotate-and-move"))
+  else  if (parentingMode == "rotate-and-move")
     return (E2D_PARENT_ROTATE_AND_MOVE);
 }
@@ -1139,13 +1139,13 @@
  * @returns the E2D_LAYER on success, E2D_DEFAULT_LAYER on error.
  */
-E2D_LAYER Element2D::charToLayer2D(const char* layer)
-{
-  if (!strcmp(layer, "top"))
+E2D_LAYER Element2D::charToLayer2D(const std::string& layer)
+{
+  if (layer =="top")
     return (E2D_LAYER_TOP);
-  else  if (!strcmp(layer, "medium"))
+  else  if (layer == "medium")
     return (E2D_LAYER_MEDIUM);
-  else  if (!strcmp(layer, "bottom"))
+  else  if (layer == "bottom")
     return (E2D_LAYER_BOTTOM);
-  else  if (!strcmp(layer, "below-all"))
+  else  if (layer == "below-all")
     return (E2D_LAYER_BELOW_ALL);
   else
Index: trunk/src/lib/graphics/render2D/element_2d.h
===================================================================
--- trunk/src/lib/graphics/render2D/element_2d.h	(revision 7199)
+++ trunk/src/lib/graphics/render2D/element_2d.h	(revision 7221)
@@ -102,10 +102,10 @@
     /** @param alignment the new Alignment of the 2D-Element */
     inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
-    void setAlignment(const char* alignment);
+    void setAlignment(const std::string& alignment);
     inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
 
     // LAYERING //
     void setLayer(E2D_LAYER layer);
-    void setLayer(const char* layer);
+    void setLayer(const std::string& layer);
     /** @returns the Layer this Element is drawn to */
     inline E2D_LAYER getLayer() const { return this->layer; };
@@ -121,5 +121,5 @@
     /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
     inline void setBindNode(const PNode* bindNode) { this->bindNode = bindNode; };
-    void setBindNode(const char* bindNode);
+    void setBindNode(const std::string& bindNode);
     inline const PNode* getBindNode() const { return this->bindNode; };
 
@@ -181,5 +181,5 @@
 
     void addChild2D (Element2D* child);
-    void addChild2D (const char* childName);
+    void addChild2D (const std::string& childName);
     void removeChild2D (Element2D* child);
     void remove2D();
@@ -187,5 +187,5 @@
     /** @param parent the new parent of this Element2D */
     void setParent2D (Element2D* parent) { parent->addChild2D(this); };
-    void setParent2D (const char* parentName);
+    void setParent2D (const std::string& parentName);
     /** @returns the parent of this Element2D */
     inline Element2D* getParent2D () const { return this->parent; };
@@ -194,8 +194,8 @@
 
     void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
-    void setParentSoft2D(const char* parentName, float bias = 1.0);
+    void setParentSoft2D(const std::string& parentName, float bias = 1.0);
 
     void setParentMode2D (E2D_PARENT_MODE parentMode);
-    void setParentMode2D (const char* parentingMode);
+    void setParentMode2D (const std::string& parentingMode);
     /** @returns the Parenting mode of this node */
     int getParentMode2D() const { return this->parentMode; };
@@ -212,9 +212,9 @@
 
     // helper functions //
-    static const char* parentingModeToChar2D(int parentingMode);
-    static E2D_PARENT_MODE charToParentingMode2D(const char* parentingMode);
+    static const char* parentingModeToString2D(int parentingMode);
+    static E2D_PARENT_MODE stringToParentingMode2D(const std::string& parentingMode);
 
     static const char* layer2DToChar(E2D_LAYER layer);
-    static E2D_LAYER charToLayer2D(const char* layer);
+    static E2D_LAYER charToLayer2D(const std::string& layer);
 
   private:
