Changeset 6281 for code/branches/presentation2/src/libraries/core

Timestamp:

Dec 9, 2009, 12:43:12 PM (15 years ago)

Author:

rgrieder

Message:

Added LuaFunctor that can execute arbitrary lua code.
Also added LuaState::createLuaFunctor(std::string) and implemented that for the keybindings menu.

Location:

code/branches/presentation2/src/libraries/core

Files:

• LuaState.cc (modified) (1 diff)
• LuaState.h (modified) (2 diffs)
• input/KeyBinderManager.cc (modified) (7 diffs)
• input/KeyBinderManager.h (modified) (3 diffs)
• input/KeyDetector.h (modified) (3 diffs)

code/branches/presentation2/src/libraries/core/LuaState.cc

@@ -263 +263 @@
         }
     }
+
+
+    LuaFunctor::LuaFunctor(const std::string& code, LuaState* luaState)
+    {
+        this->code_ = code;
+        this->lua_ = luaState;
+    }
+
+    void LuaFunctor::operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
+    {
+        lua_->doString(this->code_);
+    }
 }

code/branches/presentation2/src/libraries/core/LuaState.h

@@ -40 +40 @@
 
 #include "util/ScopeGuard.h"
+#include "core/Functor.h"
 #include "ToluaInterface.h"
 
-// tolua_begin
-namespace orxonox
-{
+namespace orxonox // tolua_export
+{ // tolua_export
+    class Functor; // tolua_export
+
+    //! Functor subclass that simply executes code with 0 arguments.
+    class _CoreExport LuaFunctor : public Functor
+    {
+        public:
+            LuaFunctor(const std::string& code, LuaState* luaState);
+            void operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null);
+            void evaluateParam(unsigned int index, MultiType& param) const {}
+
+        private:
+            std::string code_;
+            LuaState*   lua_;
+    };
+
+
     /**
     @brief
         Representation of an interface to lua
     */
-    class _CoreExport LuaState
-    {
-// tolua_end
+    class _CoreExport LuaState // tolua_export
+    { // tolua_export
     public:
         LuaState();
@@ -74 +89 @@
         void setDefaultResourceInfo(const shared_ptr<ResourceInfo>& sourceFileInfo) { this->sourceFileInfo_ = sourceFileInfo; }
         const shared_ptr<ResourceInfo>& getDefaultResourceInfo() { return this->sourceFileInfo_; }
+
+        Functor* createLuaFunctor(const std::string& code) { return new LuaFunctor(code, this); } // tolua_export
 
         static bool addToluaInterface(int (*function)(lua_State*), const std::string& name);

code/branches/presentation2/src/libraries/core/input/KeyBinderManager.cc

@@ -29 +29 @@
 #include "KeyBinderManager.h"
 
+#include <CEGUIWindow.h>
+
 #include "util/Debug.h"
 #include "util/Exception.h"
@@ -37 +39 @@
 #include "InputManager.h"
 #include "KeyDetector.h"
-
-#include <CEGUIWindow.h>
 
 namespace orxonox
@@ -49 +49 @@
         , bBinding_(false)
     {
-        this->callbackFunction_ = createFunctor(&KeyBinderManager::callback, this);
-
         RegisterObject(KeyBinderManager);
         this->setConfigValues();
@@ -69 +67 @@
         for (std::map<std::string, KeyBinder*>::const_iterator it = this->binders_.begin(); it != this->binders_.end(); ++it)
             delete it->second;
-        delete this->callbackFunction_;
     }
 
@@ -152 +149 @@
         {
             COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
-            KeyDetector::getInstance().setCallback(callbackFunction_);
+            KeyDetector::getInstance().setCallback(shared_ptr<Functor>(createFunctor(&KeyBinderManager::keybindKeyPressed, this)));
             InputManager::getInstance().enterState("detector");
             this->command_ = command;
@@ -162 +159 @@
 
     // Gets called by the KeyDetector (registered with a Functor)
-    void KeyBinderManager::callback(const std::string& keyName)
+    void KeyBinderManager::keybindKeyPressed(const std::string& keyName)
     {
         if (this->bBinding_)
@@ -169 +166 @@
             this->currentBinder_->setBinding(command_, keyName, bTemporary_);
             InputManager::getInstance().leaveState("detector");
+            // inform whatever was calling the command
+            if (this->callbackFunction_)
+                (*this->callbackFunction_)();
             this->bBinding_ = false;
         }

code/branches/presentation2/src/libraries/core/input/KeyBinderManager.h

@@ -34 +34 @@
 #include <map>
 #include <string>
+#include <boost/shared_ptr.hpp>
+#include <CEGUIForwardRefs.h>
+
 #include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
-
-#include <CEGUIForwardRefs.h>
 
 namespace orxonox //tolua_export
@@ -99 +100 @@
         inline void tkeybind(const std::string& command)
             { this->keybindInternal(command, true); }
+        inline void registerKeybindCallback(Functor* function) { this->callbackFunction_.reset(function); } // tolua_export
 
     private:
         KeyBinderManager(const KeyBinderManager&);
         void keybindInternal(const std::string& command, bool bTemporary);
-        void callback(const std::string& keyName);
+        void keybindKeyPressed(const std::string& keyName);
         void defaultFilenameChanged();
 
@@ -113 +115 @@
 
         // keybind command related
-        Functor* callbackFunction_;                  //! Function to be called when key was pressed after "keybind" command
+        shared_ptr<Functor> callbackFunction_;       //! Function to be called when key was pressed after "keybind" command
         bool bBinding_;                              //! Tells whether a key binding process is active
         bool bTemporary_;                            //! Stores tkeybind/keybind value

code/branches/presentation2/src/libraries/core/input/KeyDetector.h

@@ -32 +32 @@
 #include "InputPrereqs.h"
 
+#include <boost/shared_ptr.hpp>
 #include "util/Singleton.h"
 #include "KeyBinder.h"
@@ -45 +46 @@
         ~KeyDetector();
 
-        void setCallback(Functor* function) { this->callbackFunction_ = function; }
+        void setCallback(const shared_ptr<Functor>& function) { this->callbackFunction_ = function; }
 
     private:
@@ -54 +55 @@
         void assignCommands();
 
-        Functor* callbackFunction_;
+        shared_ptr<Functor> callbackFunction_;
         InputState* inputState_;
         static std::string callbackCommand_s;