Changeset 7648 for code/trunk/src

Timestamp:

Nov 13, 2010, 11:55:23 PM (14 years ago)

Author:

dafrick

Message:

Merged releasetodo, containing a new way to describe and tag levels, back to trunk.

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/GUIManager.cc (modified) (2 diffs)
• src/libraries/core/GUIManager.h (modified) (1 diff)
• src/libraries/core/Loader.cc (modified) (5 diffs)
• src/libraries/core/Loader.h (modified) (1 diff)
• src/orxonox/CMakeLists.txt (modified) (2 diffs)
• src/orxonox/Level.cc (modified) (1 diff)
• src/orxonox/LevelInfo.cc (copied) (copied from code/branches/releasetodo/src/orxonox/LevelInfo.cc)
• src/orxonox/LevelInfo.h (copied) (copied from code/branches/releasetodo/src/orxonox/LevelInfo.h)
• src/orxonox/LevelManager.cc (modified) (4 diffs)
• src/orxonox/LevelManager.h (modified) (3 diffs)
• src/orxonox/OrxonoxPrereqs.h (modified) (1 diff)

code/trunk/src/libraries/core/GUIManager.cc

@@ -43 +43 @@
 #include <CEGUIWindow.h>
 #include <CEGUIWindowManager.h>
+#include <elements/CEGUIListbox.h>
+#include <elements/CEGUIListboxItem.h>
 #include <ogreceguirenderer/OgreCEGUIRenderer.h>
 
@@ -436 +438 @@
     }
 
+    /**
+    @brief
+        Subscribe the input function to the input event for the input window.
+        This is a helper to be used in lua, because subscribeScriptedEvent() doesn't work in lua.
+    @param window
+        The window for which the event is subscribed.
+    @param event
+        The type of event to which we subscribe.
+    @param function
+        The function that is called when the event occurs.
+    */
     void GUIManager::subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function)
     {
         window->subscribeScriptedEvent(event, function);
     }
+
+    /**
+    @brief
+        Set the input tooltip text for the input ListboxItem.
+    @param item
+        The ListboxItem for which the tooltip should be set.
+    @param tooltip
+        The tooltip text that should be set.
+    */
+    void GUIManager::setTooltipTextHelper(CEGUI::ListboxItem* item, const std::string& tooltip)
+    {
+        item->setTooltipText(tooltip);
+    }
+
+    /**
+    @brief
+        Set whether the tooltips for the input Listbox are enabled.
+    @param listbox
+        The Listbox for which to enable (or disable) tooltips.
+    @param enabled
+        Whether to enable or disabel the tooltips.
+    */
+    void GUIManager::setItemTooltipsEnabledHelper(CEGUI::Listbox* listbox, bool enabled)
+    {
+        listbox->setItemTooltipsEnabled(enabled);
+    }
+
 }

code/trunk/src/libraries/core/GUIManager.h

@@ -106 +106 @@
         // TODO: Temporary hack because the tolua exported CEGUI method does not seem to work
         static void subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function); //tolua_export
+        static void setTooltipTextHelper(CEGUI::ListboxItem* item, const std::string& toooltip); //tolua_export
+        static void setItemTooltipsEnabledHelper(CEGUI::Listbox* listbox, bool enabled); //tolua_export
 
         static GUIManager& getInstance() { return Singleton<GUIManager>::getInstance(); } // tolua_export

code/trunk/src/libraries/core/Loader.cc

@@ -88 +88 @@
     }
 
-    bool Loader::load(const ClassTreeMask& mask)
+    /**
+    @brief
+        Loads all opened files, while conforming to the restrictions given by the input ClassTreeMask.
+    @param mask
+        A ClassTreeMask, which defines which types of classes are loaded and which aren't.
+    @param verbose
+        Whether the loader is verbose (prints its progress in a low output level) or not.
+    @return
+        Returns true if successful.
+    */
+    bool Loader::load(const ClassTreeMask& mask, bool verbose)
     {
         bool success = true;
         for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
-            if (!Loader::load(it->first, it->second * mask))
+            if (!Loader::load(it->first, it->second * mask, verbose))
                 success = false;
 
@@ -109 +119 @@
     }
 
-    bool Loader::reload(const ClassTreeMask& mask)
+    /**
+    @brief
+        Reloads all opened files, while conforming to the restrictions given by the input ClassTreeMask.
+    @param mask
+        A ClassTreeMask, which defines which types of classes are reloaded and which aren't.
+    @param verbose
+        Whether the loader is verbose (prints its progress in a low output level) or not.
+    @return
+        Returns true if successful.
+    */
+    bool Loader::reload(const ClassTreeMask& mask, bool verbose)
     {
         Loader::unload(mask);
-        return Loader::load(mask);
-    }
-
-    bool Loader::load(const XMLFile* file, const ClassTreeMask& mask)
+        return Loader::load(mask, verbose);
+    }
+
+    /**
+    @brief
+        Loads the input file, while conforming to the restrictions given by the input ClassTreeMask.
+    @param file
+        The file to be loaded.
+    @param mask
+        A ClassTreeMask, which defines which types of classes are loaded and which aren't.
+    @param verbose
+        Whether the loader is verbose (prints its progress in a low output level) or not.
+    @return
+        Returns true if successful.
+    */
+    bool Loader::load(const XMLFile* file, const ClassTreeMask& mask, bool verbose)
     {
         if (!file)
@@ -144 +176 @@
         try
         {
-            COUT(0) << "Start loading " << file->getFilename() << "..." << std::endl;
-            COUT(3) << "Mask: " << Loader::currentMask_s << std::endl;
+            if(verbose)
+            {
+                COUT(0) << "Start loading " << file->getFilename() << "..." << std::endl;
+                COUT(3) << "Mask: " << Loader::currentMask_s << std::endl;
+            }
+            else
+            {
+                COUT(4) << "Start loading " << file->getFilename() << "..." << std::endl;
+                COUT(4) << "Mask: " << Loader::currentMask_s << std::endl;
+            }
 
             ticpp::Document xmlfile(file->getFilename());
@@ -165 +205 @@
             rootNamespace->XMLPort(rootElement, XMLPort::LoadObject);
 
-            COUT(0) << "Finished loading " << file->getFilename() << '.' << std::endl;
+            if(verbose)
+                COUT(0) << "Finished loading " << file->getFilename() << '.' << std::endl;
+            else
+                COUT(4) << "Finished loading " << file->getFilename() << '.' << std::endl;
 
             COUT(4) << "Namespace-tree:" << std::endl << rootNamespace->toString("  ") << std::endl;
@@ -210 +253 @@
     }
 
-    bool Loader::reload(const XMLFile* file, const ClassTreeMask& mask)
+    /**
+    @brief
+        Reloads the input file, while conforming to the restrictions given by the input ClassTreeMask.
+    @param file
+        The file to be reloaded.
+    @param mask
+        A ClassTreeMask, which defines which types of classes are reloaded and which aren't.
+    @param verbose
+        Whether the loader is verbose (prints its progress in a low output level) or not.
+    @return
+        Returns true if successful.
+    */
+    bool Loader::reload(const XMLFile* file, const ClassTreeMask& mask, bool verbose)
     {
         Loader::unload(file, mask);
-        return Loader::load(file, mask);
+        return Loader::load(file, mask, verbose);
     }
 

code/trunk/src/libraries/core/Loader.h

@@ -57 +57 @@
             static void remove(const XMLFile* file);
 
-            static bool load(const ClassTreeMask& mask = ClassTreeMask());
+            static bool load(const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
             static void unload(const ClassTreeMask& mask = ClassTreeMask());
-            static bool reload(const ClassTreeMask& mask = ClassTreeMask());
+            static bool reload(const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
 
-            static bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
+            static bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
             static void unload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
-            static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
+            static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
 
             static std::string replaceLuaTags(const std::string& text);

code/trunk/src/orxonox/CMakeLists.txt

@@ -25 +25 @@
 SET_SOURCE_FILES(ORXONOX_SRC_FILES
   Level.cc
+  LevelInfo.cc
   LevelManager.cc
   Main.cc
@@ -58 +59 @@
   TOLUA_FILES
     ChatInputHandler.h
+    LevelInfo.h
     LevelManager.h
     MoodManager.h

code/trunk/src/orxonox/Level.cc

@@ -76 +76 @@
         XMLPortObject(Level, MeshLodInformation, "lodinformation", addLodInfo, getLodInfo, xmlelement, mode);
         XMLPortObjectExtended(Level, BaseObject, "", addObject, getObject, xmlelement, mode, true, false);
-}
+    }
 
     void Level::registerVariables()

code/trunk/src/orxonox/LevelManager.cc

@@ -32 +32 @@
 
 #include "util/ScopedSingletonManager.h"
+#include "core/ClassTreeMask.h"
 #include "core/CommandLineParser.h"
 #include "core/ConfigValueIncludes.h"
@@ -37 +38 @@
 #include "core/Loader.h"
 #include "core/Resource.h"
+#include "core/XMLFile.h"
 #include "PlayerManager.h"
 #include "Level.h"
+#include "LevelInfo.h"
 
 namespace orxonox
@@ -56 +59 @@
             ModifyConfigValue(defaultLevelName_, tset, CommandLineParser::getValue("level").getString());
         }
+
+        this->compileAvailableLevelList();
     }
 
@@ -125 +130 @@
     }
 
-    const std::string& LevelManager::getAvailableLevelListItem(unsigned int index) const
+    unsigned int LevelManager::getNumberOfLevels()
     {
-        if (index >= availableLevels_.size())
-            return BLANKSTRING;
+        this->updateAvailableLevelList();
+
+        return this->availableLevels_.size();
+    }
+
+    LevelInfoItem* LevelManager::getAvailableLevelListItem(unsigned int index) const
+    {
+        if (index >= this->availableLevels_.size())
+            return NULL;
         else
-            return availableLevels_[index];
+        {
+            std::map<std::string, LevelInfoItem*>::const_iterator it = this->infos_.find(this->availableLevels_[index]);
+            return it->second;
+        }
     }
 
     void LevelManager::compileAvailableLevelList()
     {
-        this->availableLevels_.clear();
         Ogre::StringVectorPtr levels = Resource::findResourceNames("*.oxw");
+        // Iterate over all *.oxw level files.
         for (Ogre::StringVector::const_iterator it = levels->begin(); it != levels->end(); ++it)
         {
+            //TODO: Replace with tag,
             if (it->find("old/") != 0)
             {
                 size_t pos = it->find(".oxw");
+
+                bool infoExists = false;
+                // Load the LevelInfo object from the level file.
+                XMLFile file = XMLFile(*it);
+                ClassTreeMask mask = ClassTreeMask();
+                mask.exclude(ClassIdentifier<BaseObject>::getIdentifier());
+                mask.include(ClassIdentifier<LevelInfo>::getIdentifier());
+                Loader::load(&file, mask, false);
+                for(ObjectList<LevelInfo>::iterator item = ObjectList<LevelInfo>::begin(); item != ObjectList<LevelInfo>::end(); ++item)
+                {
+                    LevelInfoItem* info = item->copy();
+                    if(info->getXMLFilename() == *it)
+                    {
+                        this->infos_.insert(std::pair<std::string, LevelInfoItem*>(it->substr(0, pos),info));
+                        infoExists = true;
+                    }
+                }
+                Loader::unload(&file, mask);
+                if(!infoExists)
+                {
+                    this->infos_.insert(std::pair<std::string, LevelInfoItem*>(it->substr(0, pos), new LevelInfoItem(it->substr(0, pos), *it)));
+                }
+
                 this->availableLevels_.push_back(it->substr(0, pos));
             }
         }
     }
+
+    void LevelManager::updateAvailableLevelList(void)
+    {
+        //TODO: Implement some kind of update?
+    }
 }

code/trunk/src/orxonox/LevelManager.h

@@ -34 +34 @@
 #include <cassert>
 #include <list>
+#include <map>
 #include <string>
 
@@ -59 +60 @@
             void setDefaultLevel(const std::string& levelName); //tolua_export
             const std::string& getDefaultLevel() const; //tolua_export
-            void compileAvailableLevelList(); //tolua_export
-            const std::string& getAvailableLevelListItem(unsigned int index) const; //tolua_export
+            unsigned int getNumberOfLevels(void); //tolua_export
+            LevelInfoItem* getAvailableLevelListItem(unsigned int index) const; //tolua_export
 
             static LevelManager& getInstance()    { return Singleton<LevelManager>::getInstance(); } // tolua_export
@@ -69 +70 @@
             void activateNextLevel();
 
+            void compileAvailableLevelList(void);
+            void updateAvailableLevelList(void);
+
             std::list<Level*> levels_s;
             std::vector<std::string> availableLevels_;
+            std::map<std::string, LevelInfoItem*> infos_;
 
             // config values

code/trunk/src/orxonox/OrxonoxPrereqs.h

@@ -67 +67 @@
     class CameraManager;
     class Level;
+    class LevelInfo;
+    class LevelInfoItem;
     class LevelManager;
     class PawnManager;