Changeset 4746 for orxonox/trunk/src/lib – Orxonox

orxonox/trunk/src/lib/collision_detection/cd_engine.h

-                      r4710
+                      r4746
  public:
   virtual ~CDEngine(void);
+  virtual ~CDEngine();
   /** \returns a Pointer to the only object of this Class */
   static CDEngine* getInstance(void) { if (!singletonRef) singletonRef = new CDEngine(); return singletonRef; }
+  static CDEngine* getInstance() { if (!singletonRef) singletonRef = new CDEngine(); return singletonRef; }
   void init();
 …
  private:
   CDEngine(void);
+  CDEngine();
   static CDEngine* singletonRef;

orxonox/trunk/src/lib/collision_detection/lin_alg.h

-                      r4674
+                      r4746
   private:
     void ComputeEigenpair(int);
     void matrixUpdate(void);
     void getP(void);
     void printMatrix(void);
+    void matrixUpdate();
+    void getP();
+    void printMatrix();
   private:
 …
+}
 //
 void EVJacobi::printMatrix(void)
+void EVJacobi::printMatrix()
+{
   for (int i=1; i<=ndim; ++i)
 …
+}
 //
 void EVJacobi::matrixUpdate(void)
+void EVJacobi::matrixUpdate()
+{
   double a_new[NDIM][NDIM], vec_new[NDIM][NDIM];
 …
 //      ev[1] <= ev[2] <= ... <= ev[ndim].
 //
 void EVJacobi::getP(void)
+void EVJacobi::getP()
+{
   for (int i=1; i<=ndim; ++i) p[i] = i;

orxonox/trunk/src/lib/collision_detection/obb_tree_node.cc

r4718	r4746
998	998
999	999
1000		void OBBTreeNode::debug(~~void~~) const
	1000	void OBBTreeNode::debug() const
1001	1001	{
1002	1002

orxonox/trunk/src/lib/collision_detection/obb_tree_node.h

r4702	r4746
38	38	virtual void drawBV(int depth, int drawMode);
39	39
40		void debug(~~void~~) const;
	40	void debug() const;
41	41
42	42	private:

orxonox/trunk/src/lib/coord/p_node.h

r4610	r4746
104	104	inline void parentDirChanged () { this->bRelDirChanged = true; }
105	105	/** \returns the last calculated coordinate */
106		inline Vector getLastAbsCoor(~~void~~) {return this->lastAbsCoordinate;}
	106	inline Vector getLastAbsCoor() {return this->lastAbsCoordinate;}
107	107
108	108

orxonox/trunk/src/lib/event/event_handler.h

-                      r4519
+                      r4746
  public:
   virtual ~EventHandler(void);
+  virtual ~EventHandler();
   /** \returns a Pointer to the only object of this Class */
   inline static EventHandler* getInstance(void) { if (!singletonRef) singletonRef = new EventHandler();  return singletonRef; };
+  inline static EventHandler* getInstance() { if (!singletonRef) singletonRef = new EventHandler();  return singletonRef; };
   void init();
 …
  private:
   EventHandler(void);
+  EventHandler();

orxonox/trunk/src/lib/graphics/graphics_engine.cc

-                      r4739
+                      r4746
    \brief Sets the GL-attributes
 */
 int GraphicsEngine::setGLattribs(void)
+int GraphicsEngine::setGLattribs()
+{
   // Set video mode
 …
    this is a GL-Projection-mode, that is orthogonal, for placing the font in fron of everything else
 */
 void GraphicsEngine::enter2DMode(void)
+void GraphicsEngine::enter2DMode()
+{
   GraphicsEngine::storeMatrices();
 …
 /**
    \brief leaves the 2DMode again also \see Font::enter2DMode(void)
 */
 void GraphicsEngine::leave2DMode(void)
+   \brief leaves the 2DMode again also \see Font::enter2DMode()
+*/
+void GraphicsEngine::leave2DMode()
+{
   glMatrixMode(GL_MODELVIEW);
 …
    \brief stores the GL_matrices
 */
 void GraphicsEngine::storeMatrices(void)
+void GraphicsEngine::storeMatrices()
+{
   glGetDoublev(GL_PROJECTION_MATRIX, GraphicsEngine::projMat);
 …
    \brief outputs all the Fullscreen modes.
 */
 void GraphicsEngine::listModes(void)
+void GraphicsEngine::listModes()
+{
   /* Get available fullscreen/hardware modes */

orxonox/trunk/src/lib/graphics/graphics_engine.h

-                      r4681
+                      r4746
     virtual ~GraphicsEngine();
     /** \returns a Pointer to the only object of this Class */
     inline static GraphicsEngine* getInstance(void) { if (!singletonRef) singletonRef = new GraphicsEngine();  return singletonRef; };
+    inline static GraphicsEngine* getInstance() { if (!singletonRef) singletonRef = new GraphicsEngine();  return singletonRef; };
     int initVideo();
     void setWindowName(const char* windowName, const char* icon);
     int setGLattribs(void);
+    int setGLattribs();
     int setResolution(int width, int height, int bpp);
     void setFullscreen(bool fullscreen = false);
 …
     /** \returns the x resolution */
     inline int getResolutionX(void) const { return this->resolutionX; };
+    inline int getResolutionX() const { return this->resolutionX; };
     /** \returns the y resolution */
     inline int getResolutionY(void) const { return this->resolutionY; };
+    inline int getResolutionY() const { return this->resolutionY; };
     /** \returns the Bits Per Pixel */
     inline int getbbp(void) const { return this->bitsPerPixel; };
+    inline int getbbp() const { return this->bitsPerPixel; };
     int resolutionChanged(SDL_ResizeEvent* resizeInfo);
     static void enter2DMode(void);
     static void leave2DMode(void);
+    static void enter2DMode();
+    static void leave2DMode();
     static void storeMatrices(void);
+    static void storeMatrices();
     static GLdouble modMat[16];
     static GLdouble projMat[16];
 …
     void displayFPS(bool display);
     void listModes(void);
+    void listModes();
     /** \brief swaps the GL_BUFFERS */
     static void swapBuffers(void) { SDL_GL_SwapBuffers(); };
+    static void swapBuffers() { SDL_GL_SwapBuffers(); };
   public:

orxonox/trunk/src/lib/graphics/importer/array.h

-                      r4580
+                      r4746
     ~Array();
     void finalizeArray (void);
+    void finalizeArray ();
     void addEntry (T entry);
     void addEntry(T entry0, T entry1, T entry2);
 …
     inline const T* getArray () const { return this->array; };
     /**   \returns The Count of entries in the Array*/
     inline unsigned int getCount(void)const { return this->entryCount; };
     void debug(void) const ;
+    inline unsigned int getCount()const { return this->entryCount; };
+    void debug() const ;
   private:
 …
 */
 template<class T>
 void Array<T>::finalizeArray (void)
+void Array<T>::finalizeArray ()
+{
   PRINTF(4)("Finalizing array. Length: %i\n", entryCount);
 …
 */
 template<class T>
 void Array<T>::debug (void) const
+void Array<T>::debug () const
+{
   PRINT(0)("entryCount=%i, address=%p\n", this->entryCount, this->array);

orxonox/trunk/src/lib/graphics/importer/material.cc

r4584	r4746
64	64	\brief sets the material with which the following Faces will be painted
65	65	*/
66		bool Material::select (~~void~~)
	66	bool Material::select ()
67	67	{
68	68	// setting diffuse color

orxonox/trunk/src/lib/graphics/importer/material.h

r4584	r4746
28	28	~Material ();
29	29
30		bool select (~~void~~);
	30	bool select ();
31	31
32	32	void setIllum (int illum);

orxonox/trunk/src/lib/graphics/importer/model.cc

-                      r4677
+                      r4746
    actually does the same as the delete Operator, but does not delete the predecessing group
 */
 void ModelGroup::cleanup(void)
+void ModelGroup::cleanup()
+{
   PRINTF(5)("Cleaning up group\n");
 …
    Looks if any from model allocated space is still in use, and if so deleted it.
 */
 Model::~Model(void)
+Model::~Model()
+{
   PRINTF(4)("Deleting Model ");
 …
    \brief Finalizes an Object. This can be done outside of the Class.
 */
 void Model::finalize(void)
+void Model::finalize()
+{
   // this creates the display List.
 …
    It does this by just calling the Lists that must have been created earlier.
 */
 void Model::draw (void) const
+void Model::draw () const
+{
   PRINTF(4)("drawing the 3D-Models\n");
 …
    \brief deletes all the arrays
 */
 bool Model::deleteArrays(void)
+bool Model::deleteArrays()
+{
   if (this->vertices)
 …
    This funcion is needed, to delete all the Lists, and arrays that are no more needed because they are already imported into openGL. This will be applied at the end of the importing Process.
 */
 bool Model::cleanup(void)
+bool Model::cleanup()
+{
   PRINTF(4)("cleaning up the 3D-Model to save Memory.\n");
 …
    \brief reads and includes the Faces/Materials into the openGL state Machine
 */
 bool Model::importToDisplayList(void)
+bool Model::importToDisplayList()
+{
   // finalize the Arrays
 …
    \brief reads and includes the Faces/Materials into the openGL state Machine
 */
 bool Model::importToVertexArray(void)
+bool Model::importToVertexArray()
+{
   // finalize the Arrays
 …
    This will inject a Cube, because this is the most basic model.
 */
 void Model::cubeModel(void)
+void Model::cubeModel()
+{
   this->addVertex (-0.5, -0.5, 0.5);

orxonox/trunk/src/lib/graphics/importer/model.h

-                      r4678
+                      r4746
  public:
   Model(const char* modelName = NULL, MODEL_TYPE type = MODEL_DISPLAY_LIST);
   virtual ~Model(void);
+  virtual ~Model();
   void draw(void) const;
+  void draw() const;
   void draw(int groupNumber) const;
   void draw(char* groupName) const;
   /** \returns Count of the Models (Groups) in this File */
   inline int getGroupCount(void) const { return this->groupCount; };
+  inline int getGroupCount() const { return this->groupCount; };
   /** \returns a Pointer to the Vertex-Array, if it was deleted it returns NULL */
   inline const GLfloat* getVertexArray(void) const { return this->vertices->getArray(); };
+  inline const GLfloat* getVertexArray() const { return this->vertices->getArray(); };
   /** \returns the VertexCount of this Model */
   inline unsigned int getVertexCount(void) const { return this->vertexCount; };
+  inline unsigned int getVertexCount() const { return this->vertexCount; };
   /** \returns a Pointer to the Normals-Array, if it was deleted it returns NULL */
   inline const GLfloat* getNormalsArray(void) const { return this->normals->getArray(); };
+  inline const GLfloat* getNormalsArray() const { return this->normals->getArray(); };
   /** \returns the NormalsCount of this Model */
   inline unsigned int getNormalsCount(void) const { return this->normalCount; };
+  inline unsigned int getNormalsCount() const { return this->normalCount; };
   /** \returns a Pointer to the TexCoord-Array, if it was deleted it returns NULL */
   inline const GLfloat* getTexCoordArray(void) const { return this->vTexture->getArray(); };
+  inline const GLfloat* getTexCoordArray() const { return this->vTexture->getArray(); };
   /** \returns the TexCoord-Count of this Model */
   inline unsigned int getTexCoordCount(void) const { return this->texCoordCount; };
+  inline unsigned int getTexCoordCount() const { return this->texCoordCount; };
   /** \returns the Count of Faces of this Model */
 …
   bool setMaterial(const char* mtlString);
   bool setMaterial(Material* mtl);
   void finalize(void);
+  void finalize();
  protected:
   void cubeModel(void);
+  void cubeModel();
   Material* findMaterialByName(const char* materialName);
 …
  private:
   bool buildVertexNormals(void);
+  bool buildVertexNormals();
   bool importToDisplayList(void);
+  bool importToDisplayList();
   bool addGLElement(ModelFaceElement* elem);
   bool importToVertexArray(void);
+  bool importToVertexArray();
   bool deleteArrays(void);
   bool cleanup(void);
+  bool deleteArrays();
+  bool cleanup();
  private:

orxonox/trunk/src/lib/graphics/importer/texture.cc

r4662	r4746
43	43	Frees Data, and deletes the textures from GL
44	44	*/
45		Texture::~Texture(~~void~~)
	45	Texture::~Texture()
46	46	{
47	47	if (this->texture)

orxonox/trunk/src/lib/graphics/importer/texture.h

-                      r4466
+                      r4746
   //  Texture(TEXTURE_TYPE type, int resolution);
   ~Texture(void);
+  ~Texture();
   /** \returns The textureID of this texture.  */
   inline GLuint getTexture(void) {return this->texture;}
+  inline GLuint getTexture() {return this->texture;}
   GLuint loadTexToGL (SDL_Surface* surface);
   /** \returns true if texture has alpha, false otherwise */
   inline bool hasAlpha(void) const {return bAlpha;}
+  inline bool hasAlpha() const {return bAlpha;}
   bool loadImage(const char* imageName);

orxonox/trunk/src/lib/graphics/light.cc

-                      r4739
+                      r4746
    \brief destroys a Light
 */
 Light::~Light(void)
+Light::~Light()
+{
   glDisable(lightsV[this->lightNumber]);
 …
    \brief draws this Light. Being a World-entity the possibility to do this lies at hand.
 */
 void Light::draw(void) const
+void Light::draw() const
+{
   float pos[4] = {this->getAbsCoor().x, this->getAbsCoor().y, this->getAbsCoor().z, 1.0};
 …
    \brief Prints out some nice formated debug information about the Light
 */
 void Light::debug(void) const
+void Light::debug() const
+{
   PRINT(0)(":: %d ::  -- reference %p\n", this->lightNumber, this);
 …
    \brief outputs debug information about the Class and its lights
 */
 void LightManager::debug(void) const
+void LightManager::debug() const
+{
   PRINT(0)("=================================\n");

orxonox/trunk/src/lib/graphics/light.h

-                      r4738
+                      r4746
  public:
   Light(const TiXmlElement* root = NULL);
   virtual ~Light(void);
+  virtual ~Light();
   void loadParams(const TiXmlElement* root);
 …
   /** \returns the lightNumber*/
   int getLightNumber(void) const {return this->lightNumber;}
+  int getLightNumber() const {return this->lightNumber;}
   virtual void draw() const;
   void debug(void) const;
+  void debug() const;
   // attributes
 …
    for some nice output just use:
    \li void debug(void) const; (either on LightManager for a resume or on any Light for single information.)
+   \li void debug() const; (either on LightManager for a resume or on any Light for single information.)
 */
 class LightManager : public BaseObject
 …
  public:
   virtual ~LightManager(void);
+  virtual ~LightManager();
   /** \returns a Pointer to the only object of this Class */
   inline static LightManager* getInstance(void) { if (!singletonRef) singletonRef = new LightManager();  return singletonRef; };
+  inline static LightManager* getInstance() { if (!singletonRef) singletonRef = new LightManager();  return singletonRef; };
   void loadParams(const TiXmlElement* root);
 …
   void draw() const;
   void debug(void) const;
+  void debug() const;
  private:
   LightManager(void);
+  LightManager();
   int  registerLight(Light* light);

orxonox/trunk/src/lib/graphics/text_engine.cc

-                      r4709
+                      r4746
    This also ereases the text from the textList of the TextEngine
 */
 Text::~Text(void)
+Text::~Text()
+{
   TextEngine::getInstance()->deleteText(this);
 …
    this is only for TEXT_STATIC-mode
 */
 void Text::createTexture(void)
+void Text::createTexture()
+{
   SDL_Surface* tmpSurf;
 …
    \brief draws the Font
 */
 void Text::draw(void) const
+void Text::draw() const
+{
   // setting the Position of this Text.
 …
    \brief prints out some nice debug information about this text
 */
 void Text::debug(void) const
+void Text::debug() const
+{
   PRINT(0)("=== TEXT: %s ===\n", this->text);
 …
    \brief destructs a font
 */
 Font::~Font(void)
+Font::~Font()
+{
   // deleting the List of all Texts
 …
    \returns the maximum height of the Font, if the font was initialized, 0 otherwise
 */
 int Font::getMaxHeight(void)
+int Font::getMaxHeight()
+{
   if (likely (this->font != NULL))
 …
    the ascent is the pixels of the font above the baseline
 */
 int Font::getMaxAscent(void)
+int Font::getMaxAscent()
+{
   if (likely(this->font != NULL))
 …
    the descent is the pixels of the font below the baseline
 */
 int Font::getMaxDescent(void)
+int Font::getMaxDescent()
+{
   if (likely(this->font != NULL))
 …
+}
 GLuint Font::createFastTexture(void)
+GLuint Font::createFastTexture()
+{
   /* interesting GLYPHS:
 …
    openGL-version < 1.2 compatibility ( and because it is realy easy like this :))
 */
 int Font::findOptimalFastTextureSize(void)
+int Font::findOptimalFastTextureSize()
+{
   int i;
 …
    \brief a simple function to get some interesting information about this class
 */
 void Font::debug(void)
+void Font::debug()
+{
   // print the loaded font's style
 …
    \brief function to enable TTF_Fonts
 */
 void TextEngine::enableFonts(void)
+void TextEngine::enableFonts()
+{
   if (!TTF_WasInit())
 …
    \brief function to disable TTF_fonts
 */
 void TextEngine::disableFonts(void)
+void TextEngine::disableFonts()
+{
   if (TTF_WasInit())
 …
    \brief deletes all the Text, and tries to delete all allocated fonts
 */
 void TextEngine::flush(void)
+void TextEngine::flush()
+{
   tIterator<Text>* textIterator = textList->getIterator();
 …
    \brief draws all the Texts that have been initialized
 */
 void TextEngine::draw(void) const
+void TextEngine::draw() const
+{
   // entering 3D-mode
 …
    \todo there should also be something outputted about Font
 */
 void TextEngine::debug(void) const
+void TextEngine::debug() const
+{
   PRINT(0)("+-------------------------------+\n");
 …
    \returns true if match, false otherwise
 */
 bool TextEngine::checkVersion(void)
+bool TextEngine::checkVersion()
+{
   SDL_version compile_version;

orxonox/trunk/src/lib/graphics/text_engine.h

-                      r4662
+                      r4746
   friend class TextEngine;
  public:
   ~Text(void);
+  ~Text();
   void setBindNode(PNode* bindNode);
 …
   void createTexture();
   void draw(void) const;
   void debug(void) const;
+  void draw() const;
+  void debug() const;
  private:
 …
   /** \returns a Pointer to the Array of Glyphs */
   inline Glyph** getGlyphArray(void) const {return glyphArray;}
+  inline Glyph** getGlyphArray() const {return glyphArray;}
   /** \returns the texture to the fast-texture */
   inline GLuint getFastTextureID(void) const {return fastTextureID;}
  private:
   int getMaxHeight(void);
   int getMaxAscent(void);
   int getMaxDescent(void);
+  inline GLuint getFastTextureID() const {return fastTextureID;}
+ private:
+  int getMaxHeight();
+  int getMaxAscent();
+  int getMaxDescent();
   Glyph* getGlyphMetrics(Uint16 character);
 …
   void initGlyphs(Uint16 from, Uint16 count);
   int findOptimalFastTextureSize(void);
   void debug(void);
+  int findOptimalFastTextureSize();
+  void debug();
  private:
 …
+{
  public:
   virtual ~TextEngine(void);
+  virtual ~TextEngine();
   /** \returns a Pointer to the only object of this Class */
   inline static TextEngine* getInstance(void) { if (!singletonRef) singletonRef = new TextEngine();  return singletonRef; };
+  inline static TextEngine* getInstance() { if (!singletonRef) singletonRef = new TextEngine();  return singletonRef; };
   Text* createText(const char* fontFile,
 …
   void deleteText(Text* text);
   void flush(void);
   void draw(void) const;
   void debug(void) const;
  private:
   TextEngine(void);
+  void flush();
+  void draw() const;
+  void debug() const;
+ private:
+  TextEngine();
   static TextEngine* singletonRef;
   // general
   static void enableFonts(void);
   static void disableFonts(void);
   static bool checkVersion(void);
+  static void enableFonts();
+  static void disableFonts();
+  static bool checkVersion();
  private:

orxonox/trunk/src/lib/gui/gui.cc

-                      r4427
+                      r4746
    \brief starts the OrxonoxGUI
 */
 void Gui::startGui(void)
+void Gui::startGui()
+{
   mainloopGUI();
 …
    \brief Destructor.
 */
 Gui::~Gui(void)
+Gui::~Gui()
+{
   delete video;

orxonox/trunk/src/lib/gui/gui.h

-                      r4427
+                      r4746
  public:
   Gui(int argc, char *argv[]);
   ~Gui(void);
+  ~Gui();
   void startGui(void);
   void printHelp(void);
+  void startGui();
+  void printHelp();
   static bool startOrxonox;

orxonox/trunk/src/lib/gui/gui_audio.cc

-                      r4427
+                      r4746
    \brief Creates an Audio-Frame
 */
 GuiAudio::GuiAudio(void)
+GuiAudio::GuiAudio()
+{
   Frame* audioFrame;        //!< The Frame that holds the audio Options.
 …
     \brief Destructs the Audio-Stuff
 */
 GuiAudio::~GuiAudio(void)
+GuiAudio::~GuiAudio()
+{
   // nothing to do here.

orxonox/trunk/src/lib/gui/gui_audio.h

-                      r4427
+                      r4746
+{
  public:
   GuiAudio(void);
   ~GuiAudio(void);
+  GuiAudio();
+  ~GuiAudio();
 };
 #endif /* _GUI_AUDIO_H */

orxonox/trunk/src/lib/gui/gui_banner.cc

-                      r4427
+                      r4746
    \brief Creates a new BannerEventBox and its content.
 */
 GuiBanner::GuiBanner(void)
+GuiBanner::GuiBanner()
+{
   // the banner Frame
 …
    \brief Destructs it.
 */
 GuiBanner::~GuiBanner(void)
+GuiBanner::~GuiBanner()
+{
   // nothing to do here

orxonox/trunk/src/lib/gui/gui_banner.h

-                      r4427
+                      r4746
+{
  public:
   GuiBanner(void);
   ~GuiBanner(void);
+  GuiBanner();
+  ~GuiBanner();
 };

orxonox/trunk/src/lib/gui/gui_element.h

r4427	r4746
18	18
19	19	/** \returns the main Widget of this GuiElement. */
20		Widget* getWidget(~~void~~) {return this->mainWidget;}
	20	Widget* getWidget() {return this->mainWidget;}
21	21	protected:
22	22	void setMainWidget(Widget* widget);

orxonox/trunk/src/lib/gui/gui_exec.cc

-                      r4427
+                      r4746
     \brief Creates the Exec-Frame
 */
 GuiExec::GuiExec(void)
+GuiExec::GuiExec()
+{
   Frame* execFrame;            //!< The Frame that holds the ExecutionOptions.
 …
    \brief Destructs the Execution-stuff
 */
 GuiExec::~GuiExec(void)
+GuiExec::~GuiExec()
+{
   if(this->confFile)
 …
    \returns The name of the Configuration-File
 */
 const char* GuiExec::getConfigFile(void) const
+const char* GuiExec::getConfigFile() const
+{
   return this->confFile;

orxonox/trunk/src/lib/gui/gui_exec.h

-                      r4427
+                      r4746
  public:
   GuiExec(void);
   ~GuiExec(void);
+  GuiExec();
+  ~GuiExec();
   void setConfDir(const char* confDir);
   void setConfFile(const char* confFile);
   const char* getConfigFile(void) const;
   int shouldsave(void);
+  const char* getConfigFile() const;
+  int shouldsave();
   void writeToFile(Widget* widget);
   void writeFileText(Widget* widget, int depth);

orxonox/trunk/src/lib/gui/gui_flags.cc

-                      r4427
+                      r4746
    \brief Creates the Flags-Frame
 */
 GuiFlags::GuiFlags(void)
+GuiFlags::GuiFlags()
+{
   this->flagsFrame = new Frame("Orxonox-Startup-Flags:");
 …
    \brief Destructs the Flags-stuff
 */
 GuiFlags::~GuiFlags(void)
+GuiFlags::~GuiFlags()
+{
   // nothing to do here

orxonox/trunk/src/lib/gui/gui_flags.h

-                      r4427
+                      r4746
  public:
   GuiFlags(void);
   ~GuiFlags(void);
+  GuiFlags();
+  ~GuiFlags();
   void setTextFromFlags(Widget* widget);

orxonox/trunk/src/lib/gui/gui_gtk.cc

-                      r4427
+                      r4746
    \brief enters the GUI's main-loop
 */
 bool mainloopGUI(void)
+bool mainloopGUI()
+{
 #ifdef HAVE_GTK2
 …
    \brief constructs a Widget
 */
 Widget::Widget(void)
+Widget::Widget()
+{
   next = NULL;
 …
    This is still pretty crappy.
 */
 Widget::~Widget(void)
+Widget::~Widget()
+{
   if (this->title)
 …
    \brief makes the widget visible.
 */
 void Widget::show(void)
+void Widget::show()
+{
 #ifdef HAVE_GTK2
 …
    \brief hides the widget.
 */
 void Widget::hide(void)
+void Widget::hide()
+{
 #ifdef HAVE_GTK2
 …
    \brief Constructs a Packer
 */
 Packer::Packer(void)
+Packer::Packer()
+{
   this->down = NULL;
 …
    \brief Destroys a Packer.
 */
 Packer::~Packer(void)
+Packer::~Packer()
+{
   PRINTF(5)("deleting the Packer part.\n");
 …
    sets the Container-Specific defaults.
 */
 Container::Container(void)
+Container::Container()
+{
   this->optionType = GUI_CONTAINER;
 …
    \brief Destroys a Container.
 */
 Container::~Container(void)
+Container::~Container()
+{
   PRINTF(5)("deleting the Container part.\n");
 …
    \brief Destructs a Window.
 */
 Window::~Window(void)
+Window::~Window()
+{
   PRINTF(5)("deleting the Window: %s\n", this->title);
 …
    \brief Shows all Widgets that are included within this->widget.
 */
 void Window::showall(void)
+void Window::showall()
+{
 #ifdef HAVE_GTK2
 …
    \brief opens up a Window and fixes the Focus to it
 */
 void Window::open(void)
+void Window::open()
+{
   if (this != mainWindow)
 …
    \brief closes up a Window and removes the Focus from it
 */
 void Window::close(void)
+void Window::close()
+{
   if (this != mainWindow)
 …
    \brief destrcucts a Frame
 */
 Frame::~Frame(void)
+Frame::~Frame()
+{
   PRINTF(5)("deleting the Frame: %s\n", this->title);
 …
    \brief destructs an EventBox.
 */
 EventBox::~EventBox(void)
+EventBox::~EventBox()
+{
   PRINTF(5)("deleting the EventBox: %s\n", this->title);
 …
    \brief destructs a Box.
 */
 Box::~Box(void)
+Box::~Box()
+{
   PRINTF(5)("deleting the Box: %s\n", this->title);
 …
    sets all Option-Specific-Values to their defaults.
 */
 Option::Option(void)
+Option::Option()
+{
   this->value = 0;
 …
    \brief Destroys an Option.
 */
 Option::~Option(void)
+Option::~Option()
+{
   PRINTF(5)("deleting the Option Part.\n");
 …
    this is a default Option save
 */
 char* Option::save(void)
+char* Option::save()
+{
   char* value = new char [30];
 …
    \returns The saveable-state.
 */
 bool Option::isSaveable(void)
+bool Option::isSaveable()
+{
   return this->saveable;
 …
    \brief destructs a Button.
 */
 Button::~Button(void)
+Button::~Button()
+{
   PRINTF(5)("deleting the Label: %s\n", this->title);
 …
    \todo not implemented yet
 */
 void Button::redraw(void)
+void Button::redraw()
+{
+}
 …
    \todo Actions for non-GTK-mode
 */
 void Button::changeOption(void)
+void Button::changeOption()
+{
   // This will possibly be used for ACTIONS !
 …
    \brief destructs a CheckButton.
 */
 CheckButton::~CheckButton(void)
+CheckButton::~CheckButton()
+{
   if (this->title)
 …
    \returns the Active state of the checkButton
 */
 bool CheckButton::isActive(void)
+bool CheckButton::isActive()
+{
 #ifdef HAVE_GTK2
 …
    \brief Changed the Option, call this Function
 */
 void CheckButton::changeOption(void)
+void CheckButton::changeOption()
+{
 #ifdef HAVE_GTK2
 …
    Example: if new settings are loaded the Button must be redrawn for the GUI to display that Change
 */
 void CheckButton::redraw(void)
+void CheckButton::redraw()
+{
 #ifdef HAVE_GTK2
 …
    \brief destructs a Slider.
 */
 Slider::~Slider(void)
+Slider::~Slider()
+{
   PRINTF(5)("deleting the Slider: %s\n", this->title);
 …
 /**
    \brief Redraws the widget
    Example: see void CheckButton::redraw(void)
 */
 void Slider::redraw(void)
+   Example: see void CheckButton::redraw()
+*/
+void Slider::redraw()
+{
 #ifdef HAVE_GTK2
 …
    \brief Changed the Option, call this Function
 */
 void Slider::changeOption(void)
+void Slider::changeOption()
+{
 #ifdef HAVE_GTK2
 …
+}
 char* Slider::save(void)
+char* Slider::save()
+{
   char* value = new char [30];
 …
    \brief destructs a Menu.
 */
 Menu::~Menu(void)
+Menu::~Menu()
+{
   PRINTF(5)("deleting the Menu: %s\n", this->title);
 …
    \brief Initializes a new Menu with no items
 */
 void Menu::init(void)
+void Menu::init()
+{
   this->optionType = GUI_INT;
 …
    \returns the name of the selected Menu-Item
 */
 char* Menu::save(void)
+char* Menu::save()
+{
   MenuItem* tmpItem = this->firstItem;
 …
 /**
    \brief Redraws the widget
    Example: see void CheckButton::redraw(void)
 */
 void Menu::redraw(void)
+   Example: see void CheckButton::redraw()
+*/
+void Menu::redraw()
+{
 #ifdef HAVE_GTK2
 …
    \brief Changed the Option, call this Function
 */
 void Menu::changeOption(void)
+void Menu::changeOption()
+{
 #ifdef HAVE_GTK2
 …
    \brief destructs an OptionLabel.
 */
 OptionLabel::~OptionLabel(void)
+OptionLabel::~OptionLabel()
+{
   PRINTF(5)("deleting the OptionLabel: %s\n", this->title);
 …
    \brief Redraws an OptionLabel(not implemented yet, but it works).
 */
 void OptionLabel::redraw(void)
+void OptionLabel::redraw()
+{
 #ifdef HAVE_GTK2
 …
    \brief Changed the Option, call this Function
 */
 void OptionLabel::changeOption(void)
+void OptionLabel::changeOption()
+{
 #ifdef HAVE_GTK2
 …
    \returns the String to save.
 */
 char* OptionLabel::save(void)
+char* OptionLabel::save()
+{
   return cValue;
 …
    \brief destructs a Label.
 */
 Label::~Label(void)
+Label::~Label()
+{
   PRINTF(5)("deleting the Label: %s\n", this->title);
 …
    \brief ereases the Text of a Label
 */
 void Label::ereaseText(void)
+void Label::ereaseText()
+{
   this->setTitle("");
 …
    \return The Text the Label holds.
 */
 const char* Label::getText(void)
+const char* Label::getText()
+{
   return this->title;
 …
    \brief destructs a ProgressBar
 */
 ProgressBar::~ProgressBar(void)
+ProgressBar::~ProgressBar()
+{
   PRINTF(5)("deleting the ProgressBar: %s\n", this->title);
 …
     \brief returns the Progress Status
 */
 double ProgressBar::getProgress(void)
+double ProgressBar::getProgress()
+{
   return this->progress;
 …
    \brief destructs an Image.
 */
 Image::~Image(void)
+Image::~Image()
+{
   PRINTF(5)("deleting the Image: %s\n", this->title);
 …
    \brief destructs a FileDialog
 */
 FileDialog::~FileDialog(void)
+FileDialog::~FileDialog()
+{
   PRINTF(5)("deleting FileDialog %s\n", this->title);
 …
    \brief disables the File Operator Buttons
 */
 void FileDialog::disableFileOpts(void)
+void FileDialog::disableFileOpts()
+{
 #ifdef HAVE_GTK2
 …
    \brief The ok-button has been pressed
 */
 void FileDialog::okEvent(void)
+void FileDialog::okEvent()
+{
   if (this->okFunc)
 …
    \biref opens up the FileDialog-Window
 */
 void FileDialog::open(void)
+void FileDialog::open()
+{
   isOpen = true;
 …
    \closes the FileDialog-Window
 */
 void FileDialog::close(void)
+void FileDialog::close()
+{
   this->isOpen = false;

orxonox/trunk/src/lib/gui/gui_gtk.h

-                      r4427
+                      r4746
 bool initGUI(int argc, char* argv[]);
 bool mainloopGUI(void);
+bool mainloopGUI();
 //! This is the topmost object that can be displayed all others are derived from it.
 …
  public:
   Widget(void);
   virtual ~Widget(void);
   void show(void);
   void hide(void);
+  Widget();
+  virtual ~Widget();
+  void show();
+  void hide();
   void setSize(int width, int height);
   virtual void setTitle(const char* title);  //!< An abstract Function, that sets the title of Widgets.
   virtual const char* getTitle(void) const { return this->title; };
+  virtual const char* getTitle() const { return this->title; };
   Widget* findWidgetByName(char* name, unsigned int depth);
 …
+{
  public:
   Packer(void);
   virtual ~Packer(void);
+  Packer();
+  virtual ~Packer();
   Widget* down;                      //!< this points to the Widget below this.
 …
   void setGroupName(const char* name);
   /** \returns the GroupName if existent NULL otherwise */
   inline const char* getGroupName(void) const {return this->groupName;}
+  inline const char* getGroupName() const {return this->groupName;}
 …
  public:
   Container(void);
   virtual ~Container(void);
+  Container();
+  virtual ~Container();
   void setBorderWidth(int borderwidth);
 …
   Window(const char* windowName = NULL);
   virtual ~Window(void);
+  virtual ~Window();
   virtual void setTitle(const char* title);
   void showall(void);
   void open(void);
   void close(void);
+  void showall();
+  void open();
+  void close();
 #ifdef HAVE_GTK2
 …
  public:
   Frame(const char* frameName = NULL);
   virtual ~Frame(void);
+  virtual ~Frame();
   virtual void setTitle(const char* title);
 …
  public:
   EventBox(const char* eventBoxName = NULL);
   virtual ~EventBox(void);
+  virtual ~EventBox();
 };
 …
  public:
   Box(char boxtype = 'h');
   virtual ~Box(void);
+  virtual ~Box();
   virtual void fill(Widget* lowerWidget);
 …
  public:
   Option(void);
   virtual ~Option(void);
+  Option();
+  virtual ~Option();
   int value;                  //!< every option has a value either true or false(0,1) or something else like 25 for 25% of the volume
 …
   void saveability(bool isSaveable = true);
   virtual char* save(void);
+  virtual char* save();
   virtual void load(char* loadString);
   bool isSaveable(void);
+  bool isSaveable();
   void setDefaultValue(int defaultValue);
   void setFlagName(const char* flagname, int defaultvalue);
 …
   void setDescription(const char* shortDescription, const char* longDescription = NULL);
   virtual void redraw(void) = 0;       //!< A Option must be able to redraw itself.
   virtual void changeOption(void) = 0; //!< What to do, if an Option is Changed. eacht option decides for itself.
+  virtual void redraw() = 0;       //!< A Option must be able to redraw itself.
+  virtual void changeOption() = 0; //!< What to do, if an Option is Changed. eacht option decides for itself.
 #ifdef HAVE_GTK2
     // Signals
 …
  public:
   Button(const char* buttonName = NULL);
   virtual ~Button(void);
+  virtual ~Button();
   virtual void setTitle(const char* title);
   virtual void redraw(void);
   virtual void changeOption(void);
+  virtual void redraw();
+  virtual void changeOption();
 };
 …
  public:
   CheckButton(const char* buttonName = NULL);
   virtual ~CheckButton(void);
   bool isActive(void);
+  virtual ~CheckButton();
+  bool isActive();
   virtual void setTitle(const char* title);
   virtual void redraw(void);
   virtual void changeOption(void);
+  virtual void redraw();
+  virtual void changeOption();
 };
 …
  public:
   Slider(const char* slidername, float start, float end);
   virtual ~Slider(void);
+  virtual ~Slider();
   void setExactness(int exactness);
   void setValue(float value);
   virtual void redraw(void);
   virtual void changeOption(void);
   virtual char* save(void);
+  virtual void redraw();
+  virtual void changeOption();
+  virtual char* save();
   virtual void load(char* loadString);
 };
 …
   Menu(const char* menuName);
   Menu(char* menuname, ...);
   virtual ~Menu(void);
   void init(void);
   virtual char* save(void);
+  virtual ~Menu();
+  void init();
+  virtual char* save();
   virtual void load(char* loadString);
   void addItem(char* itemName);
   virtual void redraw(void);
   virtual void changeOption(void);
+  virtual void redraw();
+  virtual void changeOption();
 };
 …
  public:
   OptionLabel(const char* label, const char* value);
   virtual ~OptionLabel(void);
+  virtual ~OptionLabel();
   void setValue(const char* newValue);
   virtual char* save(void);
+  virtual char* save();
   virtual void load(char* loadString);
   virtual void redraw(void);
   virtual void changeOption(void);
+  virtual void redraw();
+  virtual void changeOption();
   char* cValue;                          //!< The Value the Label will have. \todo make private
 …
  public:
   EntryField(const char* name = NULL);
   virtual ~EntryField(void);
+  virtual ~EntryField();
   void setValue(const char* newValue);
   virtual char* save(void);
+  virtual char* save();
   virtual void load(char* loadString);
   virtual void redraw(void);
   virtual void changeOption(void);
+  virtual void redraw();
+  virtual void changeOption();
 };
 …
  public:
   Label(const char* text = NULL);
   virtual ~Label(void);
+  virtual ~Label();
   virtual void setTitle(const char* text);
   void ereaseText(void);
+  void ereaseText();
   void appendText(char* textToAppend);
   void appendInt(int intToAppend);
   const char* getText(void);
+  const char* getText();
 };
 …
  public:
   ProgressBar(const char* label = NULL);
   virtual ~ProgressBar(void);
+  virtual ~ProgressBar();
   void setProgress(double progress);
   void setTotalSize(double totalSize);
   double getProgress(void);
+  double getProgress();
  private:
 …
   Image(const char* imgaeName);
   Image(char** imageData);
   virtual ~Image(void);
+  virtual ~Image();
   void init(const char* name);
 };
 …
  public:
   FileDialog(const char* fileDialogName);
   virtual ~FileDialog(void);
+  virtual ~FileDialog();
   void setChangeOption(OptionLabel* changeOption);
 …
   void setDefaultFileName(const char* defaultFileName);
   void setMask(const char* mask);
   void disableFileOpts(void);
+  void disableFileOpts();
   void okEvent();

orxonox/trunk/src/lib/gui/gui_keys.cc

-                      r4427
+                      r4746
    \brief Creates an Keyboard-Frame
 */
 GuiKeys::GuiKeys(void)
+GuiKeys::GuiKeys()
+{
   Frame* keysFrame;      //!< The Frame that holds the keyOptions.
 …
    \brief Destructs the Keys-stuff
 */
 GuiKeys::~GuiKeys(void)
+GuiKeys::~GuiKeys()
+{
   // nothing to do here.
 …
    \returns the OpenButton of a Player
 */
 Button* PlayerKeys::getOpenButton(void)
+Button* PlayerKeys::getOpenButton()
+{
   return this->openButton;
 …
    \returns the OpenButton of a Misc
 */
 Button* MiscKeys::getOpenButton(void)
+Button* MiscKeys::getOpenButton()
+{
   return this->openButton;

orxonox/trunk/src/lib/gui/gui_keys.h

-                      r4427
+                      r4746
+{
  public:
   GuiKeys(void);
   ~GuiKeys(void);
+  GuiKeys();
+  ~GuiKeys();
   static Window* inputWindow; //!< A Window that gets keyboard clicks. Static, because only one needed.
 …
   PlayerKeys(char* player);
   Button* getOpenButton(void);
+  Button* getOpenButton();
 };
 …
   MiscKeys();
   Button* getOpenButton(void);
+  Button* getOpenButton();
 };

orxonox/trunk/src/lib/gui/gui_update.cc

-                      r4427
+                      r4746
    \brief Creates an Update-Frame
 */
 GuiUpdate::GuiUpdate(void)
+GuiUpdate::GuiUpdate()
+{
   FileDialog* dataDirDialog;   //!< A FileDialog for the selection of the DataRepos
 …
    \brief Destructs the Update-stuff
 */
 GuiUpdate::~GuiUpdate(void)
+GuiUpdate::~GuiUpdate()
+{
 …
     \brief Look what info we can get from this system
 */
 bool GuiUpdate::getSystemInfo(void)
+bool GuiUpdate::getSystemInfo()
+{
   PRINTF(5)("Grabbing system information\n");
 …
 #ifdef HAVE_CURL
 bool* GuiUpdate::checkForUpdates(void)
+bool* GuiUpdate::checkForUpdates()
+{
   PRINTF(4)("checking for new version of orxonox\n");
 …
    \brief Creates a window, and all it contains for the Data-update.
 */
 void GuiUpdate::updateDataWindowCreate(void)
+void GuiUpdate::updateDataWindowCreate()
+{
   this->updateDataWindow = new Window("update orxonox::Data");
 …
    \returns A Pointer to the Button of the UpdaterDataWindow
 */
 Button* GuiUpdate::updateDataWindowGetButton(void)
+Button* GuiUpdate::updateDataWindowGetButton()
+{
   return this->updateDataWindowButton;
 …
    \brief Creates a window, and all it contains for the Source-update.
 */
 void GuiUpdate::updateSourceWindowCreate(void)
+void GuiUpdate::updateSourceWindowCreate()
+{
   // the button, that opens this Window.
 …
    \returns A Pointer to the Button of the UpdaterSourceWindow
 */
 Button* GuiUpdate::updateSourceWindowGetButton(void)
+Button* GuiUpdate::updateSourceWindowGetButton()
+{
   return this->updateSourceWindowButton;

orxonox/trunk/src/lib/gui/gui_update.h

-                      r4427
+                      r4746
   char* userName;                       //!< The user logged in.
   bool getSystemInfo(void);
+  bool getSystemInfo();
   // Window creation.
 …
  public:
   GuiUpdate(void);
   ~GuiUpdate(void);
+  GuiUpdate();
+  ~GuiUpdate();
 #ifdef HAVE_CURL
   void updateDataWindowCreate(void);
   Button* updateDataWindowGetButton(void);
+  void updateDataWindowCreate();
+  Button* updateDataWindowGetButton();
   void updateSourceWindowCreate(void);
   Button* updateSourceWindowGetButton(void);
+  void updateSourceWindowCreate();
+  Button* updateSourceWindowGetButton();
   bool* checkForUpdates(void);
+  bool* checkForUpdates();
 #endif /* HAVE_CURL */

orxonox/trunk/src/lib/gui/gui_video.cc

-                      r4427
+                      r4746
    \brief Creates the Video-Option-Frame
 */
 GuiVideo::GuiVideo(void)
+GuiVideo::GuiVideo()
+{
   Frame* videoFrame;        //!< The Frame that holds the video options.
 …
    \brief Destructs the Video-stuff
 */
 GuiVideo::~GuiVideo(void)
+GuiVideo::~GuiVideo()
+{
   // nothing to do here.
 …
    \brief Creates a window, and all it contains for the Source-update.
 */
 Widget* GuiVideo::advancedWindowCreate(void)
+Widget* GuiVideo::advancedWindowCreate()
+{
   // advanced-Performance-Options

orxonox/trunk/src/lib/gui/gui_video.h

-                      r4427
+                      r4746
+{
  private:
   //  Button* advancedWindowGetButton(void);
+  //  Button* advancedWindowGetButton();
  public:
   GuiVideo(void);
   ~GuiVideo(void);
+  GuiVideo();
+  ~GuiVideo();
  private:
   void getResolutions(Menu* menu);
   Widget* advancedWindowCreate(void);
+  Widget* advancedWindowCreate();
 };
 #endif /* _GUI_VIDEO_H */

orxonox/trunk/src/lib/lang/base_object.cc

r4744	r4746
114	114	* @brief displays everything this class is
115	115	*/
116		void BaseObject::whatIs(~~void~~) const
	116	void BaseObject::whatIs() const
117	117	{
118	118	PRINT(0)("object %s of class %s: ", this->getName(), this->getClassName());

orxonox/trunk/src/lib/lang/base_object.h

-                      r4744
+                      r4746
   void setName (const char* newName);
   /** \brief returns the Name of this Object */
   inline const char* getName (void)const { return this->objectName; };
+  inline const char* getName ()const { return this->objectName; };
   /** \returns the className of the corresponding Object */
   inline const char* getClassName(void) const { return this->className; };
+  inline const char* getClassName() const { return this->className; };
   /** \returns the classID of the corresponding Object */
   inline int getClassID(void) const { return this->classID; }
+  inline int getClassID() const { return this->classID; }
   bool isA (ClassID classID) const;
   void whatIs(void) const;
+  void whatIs() const;
   /** \returns if the object is finalized */
 …
   /** \brief this finalizes an object and makes it ready to be garbage collected */
   void finalize(void) { this->finalized = true; };
+  void finalize() { this->finalized = true; };
   private:

orxonox/trunk/src/lib/math/curve.cc

-                      r4472
+                      r4746
     \brief default constructor for a Curve
 */
 Curve::Curve(void)
+Curve::Curve()
+{
   nodeCount = 0;
 …
    \brief Outputs information about the state of this Curve
 */
 void Curve::debug(void)
+void Curve::debug()
+{
   printf("<<-------------------------------\n");
 …
    \brief Creates a new BezierCurve
 */
 BezierCurve::BezierCurve (void)
+BezierCurve::BezierCurve ()
+{
   this->derivation = 0;
 …
    It does this by freeing all the space taken over from the nodes
 */
 BezierCurve::~BezierCurve(void)
+BezierCurve::~BezierCurve()
+{
   PathNode* tmpNode;
 …
    \brief Rebuilds a Curve
 */
 void BezierCurve::rebuild(void)
+void BezierCurve::rebuild()
+{
   PathNode* tmpNode = firstNode;
 …
   \return a Vector to the calculated position
 */
 Vector BezierCurve::getPos(void) const
+Vector BezierCurve::getPos() const
+{
   return curvePoint;

orxonox/trunk/src/lib/math/curve.h

-                      r4597
+                      r4746
  public:
   Curve(void);
+  Curve();
   void addNode(const Vector& newNode);
 …
   Vector getNode(unsigned int nodeToFind);
   /** \returns the count of nodes in this curve */
   inline int getNodeCount(void) const { return this->nodeCount; };
+  inline int getNodeCount() const { return this->nodeCount; };
   /** \returns the directional Curve */
   Curve* getDirCurve(void) const { return this->dirCurve; };
+  Curve* getDirCurve() const { return this->dirCurve; };
   /** \param t the value on the curve [0-1] \returns Vector to the position */
 …
   // DEBUG
   void debug(void);
+  void debug();
  private:
   /** \brief rebuilds the curve */
   virtual void rebuild(void) = 0;
+  virtual void rebuild() = 0;
  protected:
 …
+{
  public:
   BezierCurve(void);
+  BezierCurve();
   BezierCurve(int derivation);
   virtual ~BezierCurve(void);
+  virtual ~BezierCurve();
   virtual Vector calcPos(float t);
 …
   Vector getPos(void) const;
+  Vector getPos() const;
  private:
   void rebuild(void);
+  void rebuild();
 };

orxonox/trunk/src/lib/math/vector.cc

-                      r4611
+                      r4746
    \brief Outputs the values of the Vector
 */
 void Vector::debug(void) const
+void Vector::debug() const
+{
   PRINT(0)("Vector Debug information\n");
 …
    \brief outputs some nice formated debug information about this quaternion
 */
 void Quaternion::debug(void)
+void Quaternion::debug()
+{
   PRINT(0)("Quaternion Debug Information\n");

orxonox/trunk/src/lib/particles/particle_emitter.cc

r4726	r4746
159	159	}
160	160
161		const char* ParticleEmitter::getTypeC(~~void~~) const
	161	const char* ParticleEmitter::getTypeC() const
162	162	{
163	163	if (this->type == EMITTER_PLANE)
…	…
310	310	\brief outputs some nice debug information
311	311	*/
312		void ParticleEmitter::debug(~~void~~) const
	312	void ParticleEmitter::debug() const
313	313	{
314	314	PRINT(0)(" Emitter %s\n", this->getName());

orxonox/trunk/src/lib/particles/particle_emitter.h

-                      r4726
+                      r4746
                   float emissionRate = 1.0, float velocity = 1.0);
   ParticleEmitter(const TiXmlElement* root);
   virtual ~ParticleEmitter(void);
+  virtual ~ParticleEmitter();
   void init();
 …
   /** \returns the type of the emitter */
   inline EMITTER_TYPE getType(void) const { return this->type; };
+  inline EMITTER_TYPE getType() const { return this->type; };
   /** \returns the Type as a const char * */
   const char* getTypeC(void) const;
+  const char* getTypeC() const;
   /** \returns the Size of the emitter */
   inline float getSize(void) const { return this->emitterSize; };
+  inline float getSize() const { return this->emitterSize; };
   /** \returns the emissionRate */
   inline float getEmissionRate(void) const { return this->emissionRate; };
+  inline float getEmissionRate() const { return this->emissionRate; };
   /** \returns the inherit-speed-factor */
   inline float getInheritSpeed(void) const { return this->inheritSpeed; };
+  inline float getInheritSpeed() const { return this->inheritSpeed; };
   /** \returns the SpreadAngle of the emitter */
   inline float getSpread(void) const { return this->angle; };
+  inline float getSpread() const { return this->angle; };
   /** \returns the EmissionVelocity of the emitter */
   inline float getEmissionVelocity(void) const { return this->velocity; };
+  inline float getEmissionVelocity() const { return this->velocity; };
   /** \returns the EmissionMomentum of this emitter */
   inline float getEmissionMomentum(void) const { return this->momentum; };
+  inline float getEmissionMomentum() const { return this->momentum; };
   void debug(void) const;
+  void debug() const;
  private:

orxonox/trunk/src/lib/particles/particle_engine.cc

r4726	r4746
389	389	\brief outputs some nice debug information
390	390	*/
391		void ParticleEngine::debug(~~void~~)
	391	void ParticleEngine::debug()
392	392	{
393	393	PRINT(0)("+-----------------------------------+\n");

orxonox/trunk/src/lib/particles/particle_engine.h

-                      r4726
+                      r4746
  public:
   virtual ~ParticleEngine(void);
+  virtual ~ParticleEngine();
   /** \returns a Pointer to the only object of this Class */
   inline static ParticleEngine* getInstance(void) { if (!singletonRef) singletonRef = new ParticleEngine();  return singletonRef; };
+  inline static ParticleEngine* getInstance() { if (!singletonRef) singletonRef = new ParticleEngine();  return singletonRef; };
   void loadParams(const TiXmlElement* root);
   void tick(float dt);
   void draw(void) const;
+  void draw() const;
   void addSystem(ParticleSystem* system);
 …
  private:
   ParticleEngine(void);
+  ParticleEngine();
   static ParticleEngine* singletonRef;        //!< The reference to the engine.

orxonox/trunk/src/lib/particles/particle_system.cc

-                      r4732
+                      r4746
   \brief initializes the ParticleSystem with default values
 */
 void ParticleSystem::init(void)
+void ParticleSystem::init()
+{
   this->setClassID(CL_PARTICLE_SYSTEM, "ParticleSystem");
 …
  * \returns the count of Faces of this ParticleSystem
  */
 unsigned int ParticleSystem::getFaceCount(void) const
+unsigned int ParticleSystem::getFaceCount() const
+{
   switch (this->particleType)
 …
    This is just the fastest Way to do this, but will most likely be changed in the future.
  */
 void ParticleSystem::draw(void) const
+void ParticleSystem::draw() const
+{
   glPushAttrib(GL_ENABLE_BIT);
 …
    \brief outputs some nice debug information
 */
 void ParticleSystem::debug(void) const
+void ParticleSystem::debug() const
+{
   PRINT(0)("  ParticleSystem %s, type: ", this->getName());

orxonox/trunk/src/lib/particles/particle_system.h

-                      r4727
+                      r4746
   virtual ~ParticleSystem();
   void init(void);
+  void init();
   void loadParams(const TiXmlElement* root);
 …
   /** \returns the Type of the particles */
   inline PARTICLE_TYPE getType(void) const { return this->particleType; };
+  inline PARTICLE_TYPE getType() const { return this->particleType; };
   /** \returns the Material that lies on this particles */
   inline const Material* getMaterial(void) const { return this->material; };
+  inline const Material* getMaterial() const { return this->material; };
   /** \returns the lifespan of the particles */
   inline float getLifeSpan(void) const { return this->lifeSpan; };
+  inline float getLifeSpan() const { return this->lifeSpan; };
   /** \returns the starting-radius of the particles */
   inline float getStartRadius(void) { return this->radiusAnim.getValue(0.0); };
+  inline float getStartRadius() { return this->radiusAnim.getValue(0.0); };
   /** \returns the end-radius of the particles */
   inline float getEndRadius(void) { return this->radiusAnim.getValue(1.0); };
+  inline float getEndRadius() { return this->radiusAnim.getValue(1.0); };
   /** \returns the conserve-factor of the particles */
   inline float getConserve(void) const { return this->conserve; };
+  inline float getConserve() const { return this->conserve; };
   /** \returns the initial mass of the particles */
   inline float getMass(void) const { return this->initialMass; };
+  inline float getMass() const { return this->initialMass; };
   virtual unsigned int getFaceCount(void) const;
+  virtual unsigned int getFaceCount() const;
 …
   virtual void tick(float dt);
   virtual void draw(void) const;
+  virtual void draw() const;
   void debug(void) const;
+  void debug() const;
  private:

orxonox/trunk/src/lib/particles/quick_animation.cc

-                      r4657
+                      r4746
    \brief standard constructor
 */
 QuickAnimation::QuickAnimation (void)
+QuickAnimation::QuickAnimation ()
+{
    this->setClassID(CL_QUICK_ANIMATION, "QuickAnimation");
 …
    \brief deletes all the deconstructor stuff
 */
 QuickAnimation::~QuickAnimation (void)
+QuickAnimation::~QuickAnimation ()
+{
   this->current = this->first;
 …
    \brief outputs some nice information about this class
 */
 void QuickAnimation::debug(void)
+void QuickAnimation::debug()
+{
   this->current = this->first;

orxonox/trunk/src/lib/particles/quick_animation.h

r4657	r4746
49	49	float getValue(float position);
50	50
51		void debug(~~void~~);
	51	void debug();
52	52
53	53	private:

orxonox/trunk/src/lib/physics/fields/field.cc

r4730	r4746
44	44	\brief initializes a Field
45	45	*/
46		void Field::init(~~void~~)
	46	void Field::init()
47	47	{
48	48	this->setClassID(CL_FIELD, "Field");

orxonox/trunk/src/lib/physics/fields/field.h

-                      r4730
+                      r4746
   virtual ~Field();
   void init(void);
+  void init();
   void loadParams(const TiXmlElement* root);
 …
   void setMagnitude(float magnitude);
   /** \returns The Magnitude of the Field */
   inline const float& getMagnitude(void) const {return this->magnitude;}
+  inline const float& getMagnitude() const {return this->magnitude;}
   void setAttenuation(float attenuation);
   /** \returns The Attenuation of the Fiels */
   inline const float& getAttenuation(void) const {return this->attenuation;}
+  inline const float& getAttenuation() const {return this->attenuation;}
  private:

orxonox/trunk/src/lib/physics/physics_connection.cc

r4731	r4746
101	101	\brief applies the Force to some Object.
102	102	*/
103		void PhysicsConnection::apply(~~void~~) const
	103	void PhysicsConnection::apply() const
104	104	{
105	105	if (likely(this->type == PCON_PhysIField && this->field->getMagnitude() != 0.0

orxonox/trunk/src/lib/physics/physics_connection.h

r4731	r4746
37	37	void setField(const char* fieldName);
38	38
39		void apply(~~void~~) const;
	39	void apply() const;
40	40
41	41	private:

orxonox/trunk/src/lib/physics/physics_engine.cc

-                      r4733
+                      r4746
    \brief standard constructor
 */
 PhysicsEngine::PhysicsEngine(void)
+PhysicsEngine::PhysicsEngine()
+{
   this->setClassID(CL_PHYSICS_ENGINE, "PhysicsEngine");
 …
 */
 PhysicsEngine::~PhysicsEngine(void)
+PhysicsEngine::~PhysicsEngine()
+{
   PhysicsEngine::singletonRef = NULL;
 …
    \brief print out interesting debug information of this class
 */
 void PhysicsEngine::debug(void) const
+void PhysicsEngine::debug() const
+{
   PRINT(0)("====================================\n");

orxonox/trunk/src/lib/physics/physics_engine.h

-                      r4733
+                      r4746
  public:
   virtual ~PhysicsEngine(void);
+  virtual ~PhysicsEngine();
   /** \returns a Pointer to the only object of this Class */
   inline static PhysicsEngine* getInstance(void) { if (!singletonRef) singletonRef = new PhysicsEngine();  return singletonRef; };
+  inline static PhysicsEngine* getInstance() { if (!singletonRef) singletonRef = new PhysicsEngine();  return singletonRef; };
   void loadParams(const TiXmlElement* root);
 …
   void                   tick(float dt);
   void                   debug(void) const;
+  void                   debug() const;
  private:
   PhysicsEngine(void);
+  PhysicsEngine();
  private:

orxonox/trunk/src/lib/sound/sound_engine.cc

-                      r4605
+                      r4746
+}
 SoundBuffer::~SoundBuffer(void)
+SoundBuffer::~SoundBuffer()
+{
   SoundEngine::getInstance()->removeBuffer(this);
 …
    \brief deletes a SoundSource
 */
 SoundSource::~SoundSource(void)
+SoundSource::~SoundSource()
+{
   SoundEngine::getInstance()->removeSource(this);
 …
    \brief updates all The positions, Directions and Velocities of all Sounds
 */
 void SoundEngine::update(void)
+void SoundEngine::update()
+{
 …
    \brief Removes all the Buffers that are not anymore needed by any Sources
 */
 void SoundEngine::flushUnusedBuffers(void)
+void SoundEngine::flushUnusedBuffers()
+{
   tIterator<SoundBuffer>* bufferIterator = this->bufferList->getIterator();
 …
    \brief SourceEngine::flushAllBuffers
 */
 void SoundEngine::flushAllBuffers(void)
+void SoundEngine::flushAllBuffers()
+{
     tIterator<SoundBuffer>* bufferIterator = this->bufferList->getIterator();
 …
    \brief initializes Audio in general
 */
 bool SoundEngine::initAudio(void)
+bool SoundEngine::initAudio()
+{
   ALenum result;

orxonox/trunk/src/lib/sound/sound_engine.h

-                      r4597
+                      r4746
  public:
   SoundBuffer(const char* fileName);
   ~SoundBuffer(void);
+  ~SoundBuffer();
   /** \returns the ID of the buffer used in this SoundBuffer */
   inline ALuint getID(void) { return this->bufferID; }
+  inline ALuint getID() { return this->bufferID; }
  private:
 …
  public:
   SoundSource(SoundBuffer* buffer, PNode* sourceNode = NULL);
   ~SoundSource(void);
+  ~SoundSource();
   // user interaction
 …
   // development functions
   /** \returns The ID of this Source */
   inline ALuint getID(void) const { return this->sourceID; }
+  inline ALuint getID() const { return this->sourceID; }
   /** \returns the SoundBuffer of this Source */
   inline SoundBuffer* getBuffer(void) const { return this->buffer; }
+  inline SoundBuffer* getBuffer() const { return this->buffer; }
   /** \returns the SourceNode of this Source */
   inline PNode* getNode(void) const { return this->sourceNode;}
+  inline PNode* getNode() const { return this->sourceNode;}
   void setRolloffFactor(ALfloat rolloffFactor);
 …
  public:
   virtual ~SoundEngine(void);
+  virtual ~SoundEngine();
   /** \returns a Pointer to the only object of this Class */
   inline static SoundEngine* getInstance(void) { if (!singletonRef) singletonRef = new SoundEngine();  return singletonRef; };
+  inline static SoundEngine* getInstance() { if (!singletonRef) singletonRef = new SoundEngine();  return singletonRef; };
   SoundSource* createSource(const char* fileName, PNode* sourceNode = NULL);
 …
   void removeSource(SoundSource* source);
   void update(void);
+  void update();
   // administrative
   void flushUnusedBuffers(void);
   void flushAllBuffers(void);
   bool initAudio(void);
+  void flushUnusedBuffers();
+  void flushAllBuffers();
+  bool initAudio();
   // error handling:
 …
  private:
   SoundEngine(void);
+  SoundEngine();
   static SoundEngine*      singletonRef;             //!< Reference to this class

Context Navigation

Changeset 4746 in orxonox.OLD for orxonox/trunk/src/lib

Legend:

Download in other formats: