Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/kicklib/src/libraries/core/GUIManager.cc @ 8058

Last change on this file since 8058 was 7973, checked in by rgrieder, 14 years ago

Fix for "error in error handling" when a Lua error occurs.
Untested and does not seem to be required by MSVC or Windows systems, so I cannot test. Please do so.

  • Property svn:eol-style set to native
File size: 20.8 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Reto Grieder
24 *      Benjamin Knecht
25 *   Co-authors:
26 *      ...
27 *
28 */
29
30#include "GUIManager.h"
31
32#include <memory>
33#include <boost/bind.hpp>
34#include <OgreRenderQueue.h>
35#include <OgreRenderWindow.h>
36
37#include <CEGUIDefaultLogger.h>
38#include <CEGUIExceptions.h>
39#include <CEGUIInputEvent.h>
40#include <CEGUIMouseCursor.h>
41#include <CEGUIResourceProvider.h>
42#include <CEGUISystem.h>
43#include <CEGUIWindow.h>
44#include <CEGUIWindowManager.h>
45#include <elements/CEGUIListbox.h>
46#include <elements/CEGUIListboxItem.h>
47
48#ifdef ORXONOX_OLD_CEGUI
49#  include <CEGUILua.h>
50#  include <ogreceguirenderer/OgreCEGUIRenderer.h>
51extern "C" {
52#  include <lauxlib.h>
53}
54#else
55#  include <ScriptingModules/LuaScriptModule/CEGUILua.h>
56#  include <RendererModules/Ogre/CEGUIOgreImageCodec.h>
57#  include <RendererModules/Ogre/CEGUIOgreRenderer.h>
58#  include <RendererModules/Ogre/CEGUIOgreResourceProvider.h>
59#endif
60
61#include "util/Clock.h"
62#include "util/Convert.h"
63#include "util/Debug.h"
64#include "util/Exception.h"
65#include "util/OrxAssert.h"
66#include "ConfigValueIncludes.h"
67#include "Core.h"
68#include "CoreIncludes.h"
69#include "Game.h"
70#include "GraphicsManager.h"
71#include "LuaState.h"
72#include "PathConfig.h"
73#include "Resource.h"
74#include "command/ConsoleCommand.h"
75#include "input/InputManager.h"
76#include "input/InputState.h"
77#include "input/KeyBinderManager.h"
78
79namespace orxonox
80{
81    static void key_esc()
82        { GUIManager::getInstance().keyESC(); }
83    SetConsoleCommand("keyESC", &key_esc);
84
85    class CEGUILogger : public CEGUI::DefaultLogger
86    {
87    public:
88        void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
89        {
90            int orxonoxLevel = CEGUI::Standard;
91            switch (level)
92            {
93                case CEGUI::Errors:      orxonoxLevel = 1; break;
94                case CEGUI::Warnings:    orxonoxLevel = 2; break;
95                case CEGUI::Standard:    orxonoxLevel = 4; break;
96                case CEGUI::Informative: orxonoxLevel = 5; break;
97                case CEGUI::Insane:      orxonoxLevel = 6; break;
98                default: OrxAssert(false, "CEGUI log level out of range, inspect immediately!");
99            }
100            OutputHandler::getOutStream(orxonoxLevel)
101                << "CEGUI: " << message << std::endl;
102
103            CEGUI::DefaultLogger::logEvent(message, level);
104        }
105    };
106
107#ifdef ORXONOX_OLD_CEGUI
108    /** Class with the same memory layout as CEGUI::LuaScriptModule. <br>
109        We need this to fix a problem with an uninitialised member variable
110        in CEGUI < 0.7 <br>
111        Notice that "public" modifier for the otherwise private variables.
112    */
113    class CEGUILUA_API LuaScriptModuleWorkaround : public CEGUI::ScriptModule
114    {
115    public:
116        LuaScriptModuleWorkaround();
117        ~LuaScriptModuleWorkaround();
118
119    public:
120        bool d_ownsState;
121        lua_State* d_state;
122        CEGUI::String d_errFuncName;
123        int d_errFuncIndex;
124        CEGUI::String d_activeErrFuncName;
125        int d_activeErrFuncIndex;
126    };
127#endif
128
129    static CEGUI::MouseButton convertButton(MouseButtonCode::ByEnum button);
130
131    GUIManager* GUIManager::singletonPtr_s = 0;
132    /*static*/ const std::string GUIManager::defaultScheme_ = "TaharezGreen";
133
134    SetConsoleCommand("showGUI", &GUIManager::showGUI).defaultValue(1, false).defaultValue(2, false);
135    SetConsoleCommand("hideGUI", &GUIManager::hideGUI);
136
137    /**
138    @brief
139        Constructs the GUIManager by starting up CEGUI
140
141        Creates the interface to Ogre, sets up the CEGUI renderer and the Lua script module together with the Lua engine.
142        The log is set up and connected to the CEGUILogger.
143        After Lua setup tolua++-elements are linked to Lua-state to give Lua access to C++-code.
144        Finally initial Lua code is executed (maybe we can do this with the CEGUI startup script automatically).
145    @return true if success, otherwise false
146    */
147    GUIManager::GUIManager(const std::pair<int, int>& mousePosition)
148        : destroyer_(*this, &GUIManager::cleanup)
149        , guiRenderer_(NULL)
150        , luaState_(NULL)
151        , scriptModule_(NULL)
152        , guiSystem_(NULL)
153        , resourceProvider_(NULL)
154#ifndef ORXONOX_OLD_CEGUI
155        , imageCodec_(NULL)
156#endif
157        , camera_(NULL)
158    {
159        RegisterRootObject(GUIManager);
160        this->setConfigValues();
161
162        using namespace CEGUI;
163
164        COUT(3) << "Initialising CEGUI." << std::endl;
165
166        // Note: No SceneManager specified yet
167#ifdef ORXONOX_OLD_CEGUI
168        guiRenderer_ = new OgreCEGUIRenderer(GraphicsManager::getInstance().getRenderWindow(), Ogre::RENDER_QUEUE_OVERLAY, false, 3000);
169        resourceProvider_ = guiRenderer_->createResourceProvider();
170#else
171        guiRenderer_ = &OgreRenderer::create(*GraphicsManager::getInstance().getRenderWindow());
172        resourceProvider_ = &OgreRenderer::createOgreResourceProvider();
173        imageCodec_ = &OgreRenderer::createOgreImageCodec();
174#endif
175        resourceProvider_->setDefaultResourceGroup("General");
176
177        // Setup scripting
178        luaState_ = new LuaState();
179        rootFileInfo_ = Resource::getInfo("InitialiseGUI.lua");
180        // This is necessary to ensure that input events also use the right resource info when triggering lua functions
181        luaState_->setDefaultResourceInfo(this->rootFileInfo_);
182#ifdef ORXONOX_OLD_CEGUI
183        scriptModule_ = new LuaScriptModule(luaState_->getInternalLuaState());
184        // Ugly workaround: older CEGUILua versions don't initialise the member
185        // d_activeErrFuncIndex at all. That leads to "error in error handling"
186        // problems when a Lua error occurs.
187        // We fix this by setting the member manually.
188        reinterpret_cast<LuaScriptModuleWorkaround*>(scriptModule_)->d_activeErrFuncIndex = LUA_NOREF;
189        luaState_->doString("ORXONOX_OLD_CEGUI = true");
190#else
191        scriptModule_ = &LuaScriptModule::create(luaState_->getInternalLuaState());
192#endif
193        scriptModule_->setDefaultPCallErrorHandler(LuaState::ERROR_HANDLER_NAME);
194
195        // Create our own logger to specify the filepath
196        std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
197        ceguiLogger->setLogFilename(PathConfig::getLogPathString() + "cegui.log");
198        // Set the log level according to ours (translate by subtracting 1)
199        ceguiLogger->setLoggingLevel(
200            static_cast<LoggingLevel>(OutputHandler::getInstance().getSoftDebugLevel("logFile") - 1));
201        this->ceguiLogger_ = ceguiLogger.release();
202
203        // Create the CEGUI system singleton
204#ifdef ORXONOX_OLD_CEGUI
205        guiSystem_ = new System(guiRenderer_, resourceProvider_, 0, scriptModule_);
206        // Add functions that have been renamed in newer versions
207        luaState_->doString("CEGUI.SchemeManager.create = CEGUI.SchemeManager.loadScheme");
208        luaState_->doString("CEGUI.Window.getUnclippedOuterRect = CEGUI.Window.getUnclippedPixelRect");
209#else
210        guiSystem_ = &System::create(*guiRenderer_, resourceProvider_, 0, imageCodec_, scriptModule_);
211#endif
212
213        // Align CEGUI mouse with OIS mouse
214        guiSystem_->injectMousePosition((float)mousePosition.first, (float)mousePosition.second);
215
216        // Initialise the Lua framework and load the schemes
217        this->luaState_->doFile("InitialiseGUI.lua");
218
219        // Create the root nodes
220        this->rootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("MenuWidgets/StaticImage", "AbsoluteRootWindow");
221        this->rootWindow_->setProperty("FrameEnabled", "False");
222        this->hudRootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("DefaultWindow", "HUDRootWindow");
223        this->menuRootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("DefaultWindow", "MenuRootWindow");
224        // And connect them
225        CEGUI::System::getSingleton().setGUISheet(this->rootWindow_);
226        this->rootWindow_->addChildWindow(this->hudRootWindow_);
227        this->rootWindow_->addChildWindow(this->menuRootWindow_);
228
229        // No background to start with (sets the alpha value to 0)
230        this->setBackgroundImage("");
231
232        // Set up the sheet manager in the Lua framework
233        this->luaState_->doFile("SheetManager.lua");
234    }
235
236    void GUIManager::cleanup()
237    {
238        using namespace CEGUI;
239
240#ifdef ORXONOX_OLD_CEGUI
241        delete guiSystem_;
242        delete guiRenderer_;
243        delete scriptModule_;
244#else
245        System::destroy();
246        OgreRenderer::destroyOgreResourceProvider(*resourceProvider_);
247        OgreRenderer::destroyOgreImageCodec(*imageCodec_);
248        OgreRenderer::destroy(*guiRenderer_);
249        LuaScriptModule::destroy(*scriptModule_);
250#endif
251        delete luaState_;
252    }
253
254    void GUIManager::setConfigValues(void)
255    {
256        SetConfigValue(guiScheme_, GUIManager::defaultScheme_) .description("Changes the current GUI scheme.") .callback(this, &GUIManager::changedGUIScheme);
257    }
258
259    void GUIManager::changedGUIScheme(void)
260    {
261
262    }
263
264    /**
265    @brief
266        used to tick the GUI
267    @param time
268        clock which provides time value for the GUI System
269
270        Ticking the GUI means updating it with a certain regularity.
271        The elapsed time since the last call is given in the time value provided by the clock.
272        This time value is then used to provide a fluent animation of the GUI.
273    */
274    void GUIManager::preUpdate(const Clock& time)
275    {
276        assert(guiSystem_);
277        this->protectedCall(boost::bind(&CEGUI::System::injectTimePulse, _1, time.getDeltaTime()));
278    }
279
280    /**
281    @brief
282        Tells the GUIManager which SceneManager to use
283    @param camera
284        The current camera on which the GUI should be displayed on.
285
286        In fact the GUIManager needs the SceneManager and not the Camera to display the GUI.
287        This means the GUI is not bound to a camera but rather to the SceneManager.
288        Hiding the GUI when needed can therefore not be resolved by just NOT setting the current camera.
289    */
290    void GUIManager::setCamera(Ogre::Camera* camera)
291    {
292        this->camera_ = camera;
293#ifdef ORXONOX_OLD_CEGUI
294        if (camera == NULL)
295            this->guiRenderer_->setTargetSceneManager(0);
296        else
297            this->guiRenderer_->setTargetSceneManager(camera->getSceneManager());
298#endif
299    }
300
301    /**
302    @brief
303        Executes Lua code
304    @param str
305        reference to string object holding the Lua code which is to be executed
306    */
307    void GUIManager::executeCode(const std::string& str)
308    {
309        this->luaState_->doString(str, rootFileInfo_);
310    }
311
312    /** Loads a GUI sheet by Lua script
313    @param name
314        The name of the GUI (like the script name, but without the extension)
315    */
316    void GUIManager::loadGUI(const std::string& name)
317    {
318        this->executeCode("loadSheet(\"" + name + "\")");
319    }
320
321    /**
322    @brief
323        Displays specified GUI on screen
324    @param name
325        The name of the GUI
326    @param bHidePrevious
327        If true all displayed GUIs on the stack, that are below this GUI are hidden.
328    @param bNoInput
329        If true the GUI is transparent to input.
330
331        The function executes the Lua function with the same name in case the GUIManager is ready.
332    */
333    /*static*/ void GUIManager::showGUI(const std::string& name, bool bHidePrevious, bool bNoInput)
334    {
335        GUIManager::getInstance().executeCode("showMenuSheet(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + multi_cast<std::string>(bNoInput) + ")");
336    }
337
338    /**
339    @brief
340        Hack-ish. Needed for GUIOverlay.
341    */
342    void GUIManager::showGUIExtra(const std::string& name, const std::string& ptr, bool bHidePrevious, bool bNoInput)
343    {
344        this->executeCode("showMenuSheet(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + multi_cast<std::string>(bNoInput) + ", " + ptr + ")");
345    }
346
347    /**
348    @brief
349        Hides specified GUI.
350    @param name
351        The name of the GUI.
352    */
353    /*static*/ void GUIManager::hideGUI(const std::string& name)
354    {
355        GUIManager::getInstance().executeCode("hideMenuSheet(\"" + name + "\")");
356    }
357
358    const std::string& GUIManager::createInputState(const std::string& name, TriBool::Value showCursor, TriBool::Value useKeyboard, bool bBlockJoyStick)
359    {
360        InputState* state = InputManager::getInstance().createInputState(name);
361        if (!state)
362            return BLANKSTRING;
363
364        /* Table that maps isFullScreen() and showCursor to mouseExclusive
365        isFullscreen / showCursor | True  | False | Dontcare
366        ----------------------------------------------------
367        true                      | True  | True  | Dontcare
368        ----------------------------------------------------
369        false                     | False | True  | Dontcare
370        */
371        if (showCursor == TriBool::Dontcare)
372            state->setMouseExclusive(TriBool::Dontcare);
373        else if (GraphicsManager::getInstance().isFullScreen() || showCursor == TriBool::False)
374            state->setMouseExclusive(TriBool::True);
375        else
376            state->setMouseExclusive(TriBool::False);
377
378        if (showCursor == TriBool::True)
379            state->setMouseHandler(this);
380        else if (showCursor == TriBool::False)
381            state->setMouseHandler(&InputHandler::EMPTY);
382
383        if (useKeyboard == TriBool::True)
384            state->setKeyHandler(this);
385        else if (useKeyboard == TriBool::False)
386            state->setKeyHandler(&InputHandler::EMPTY);
387
388        if (bBlockJoyStick)
389            state->setJoyStickHandler(&InputHandler::EMPTY);
390
391        return state->getName();
392    }
393
394    void GUIManager::keyESC()
395    {
396        this->executeCode("keyESC()");
397    }
398
399    void GUIManager::setBackgroundImage(const std::string& imageSet, const std::string imageName)
400    {
401        if (imageSet.empty() || imageName.empty())
402            this->setBackgroundImage("");
403        else
404            this->setBackgroundImage("set: " + imageSet + " image: " + imageName);
405    }
406
407    void GUIManager::setBackgroundImage(const std::string& image)
408    {
409        if (image.empty())
410            this->rootWindow_->setProperty("Alpha", "0.0");
411        else
412            this->rootWindow_->setProperty("Alpha", "1.0");
413        this->rootWindow_->setProperty("Image", image);
414    }
415
416    void GUIManager::buttonPressed(const KeyEvent& evt)
417    {
418        this->protectedCall(boost::bind(&CEGUI::System::injectKeyDown, _1, evt.getKeyCode()));
419        this->protectedCall(boost::bind(&CEGUI::System::injectChar, _1, evt.getText()));
420    }
421
422    void GUIManager::buttonReleased(const KeyEvent& evt)
423    {
424        this->protectedCall(boost::bind(&CEGUI::System::injectKeyUp, _1, evt.getKeyCode()));
425    }
426
427    /**
428    @brief
429        Function receiving a mouse button pressed event.
430    @param id
431        ID of the mouse button which got pressed
432
433        This function is inherited by MouseHandler and injects the event into CEGUI.
434        It is for CEGUI to process the event.
435    */
436    void GUIManager::buttonPressed(MouseButtonCode::ByEnum id)
437    {
438        this->protectedCall(boost::bind(&CEGUI::System::injectMouseButtonDown, _1, convertButton(id)));
439    }
440
441    /**
442    @brief
443        Function receiving a mouse button released event.
444    @param id
445        ID of the mouse button which got released
446
447        This function is inherited by MouseHandler and injects the event into CEGUI.
448        It is for CEGUI to process the event.
449    */
450    void GUIManager::buttonReleased(MouseButtonCode::ByEnum id)
451    {
452        this->protectedCall(boost::bind(&CEGUI::System::injectMouseButtonUp, _1, convertButton(id)));
453    }
454
455    void GUIManager::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
456    {
457        this->protectedCall(boost::bind(&CEGUI::System::injectMousePosition, _1, (float)abs.x, (float)abs.y));
458    }
459
460    void GUIManager::mouseScrolled(int abs, int rel)
461    {
462        this->protectedCall(boost::bind(&CEGUI::System::injectMouseWheelChange, _1, (float)rel));
463    }
464
465    /**
466        @brief Indicates that the mouse left the application's window.
467    */
468    void GUIManager::mouseLeft()
469    {
470        this->protectedCall(boost::bind(&CEGUI::System::injectMouseLeaves, _1));
471    }
472
473    /**
474    @brief
475        converts mouse event code to CEGUI event code
476    @param button
477        code of the mouse button as we use it in Orxonox
478    @return
479        code of the mouse button as it is used by CEGUI
480
481        Simple conversion from mouse event code in Orxonox to the one used in CEGUI.
482     */
483    static inline CEGUI::MouseButton convertButton(MouseButtonCode::ByEnum button)
484    {
485        switch (button)
486        {
487        case MouseButtonCode::Left:
488            return CEGUI::LeftButton;
489
490        case MouseButtonCode::Right:
491            return CEGUI::RightButton;
492
493        case MouseButtonCode::Middle:
494            return CEGUI::MiddleButton;
495
496        case MouseButtonCode::Button3:
497            return CEGUI::X1Button;
498
499        case MouseButtonCode::Button4:
500            return CEGUI::X2Button;
501
502        default:
503            return CEGUI::NoButton;
504        }
505    }
506
507    /** Executes a CEGUI function normally, but catches CEGUI::ScriptException.
508        When a ScriptException occurs, the error message will be displayed and
509        the program carries on.
510    @remarks
511        The exception behaviour may pose problems if the code is not written
512        exception-safe (and you can forget about that in Lua). The program might
513        be left in an undefined state. But otherwise one script error would
514        terminate the whole program...
515    @note
516        Your life gets easier if you use boost::bind to create the object/function.
517    @param function
518        Any callable object/function that takes this->guiSystem_ as its only parameter.
519    @return
520        True if input was handled, false otherwise. A caught exception yields true.
521    */
522    template <typename FunctionType>
523    bool GUIManager::protectedCall(FunctionType function)
524    {
525        try
526        {
527            return function(this->guiSystem_);
528        }
529        catch (CEGUI::ScriptException& ex)
530        {
531            // Display the error and proceed. See @remarks why this can be dangerous.
532            COUT(1) << ex.getMessage() << std::endl;
533            return true;
534        }
535    }
536
537    /**
538    @brief
539        Subscribe the input function to the input event for the input window.
540        This is a helper to be used in lua, because subscribeScriptedEvent() doesn't work in lua.
541    @param window
542        The window for which the event is subscribed.
543    @param event
544        The type of event to which we subscribe.
545    @param function
546        The function that is called when the event occurs.
547    */
548    void GUIManager::subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function)
549    {
550        window->subscribeScriptedEvent(event, function);
551    }
552
553    /**
554    @brief
555        Set the input tooltip text for the input ListboxItem.
556    @param item
557        The ListboxItem for which the tooltip should be set.
558    @param tooltip
559        The tooltip text that should be set.
560    */
561    void GUIManager::setTooltipTextHelper(CEGUI::ListboxItem* item, const std::string& tooltip)
562    {
563        item->setTooltipText(tooltip);
564    }
565
566    /**
567    @brief
568        Set whether the tooltips for the input Listbox are enabled.
569    @param listbox
570        The Listbox for which to enable (or disable) tooltips.
571    @param enabled
572        Whether to enable or disable the tooltips.
573    */
574    void GUIManager::setItemTooltipsEnabledHelper(CEGUI::Listbox* listbox, bool enabled)
575    {
576        listbox->setItemTooltipsEnabled(enabled);
577    }
578
579    /**
580        @brief Callback of window event listener, called if the window is resized. Sets the display size of CEGUI.
581    */
582    void GUIManager::windowResized(unsigned int newWidth, unsigned int newHeight)
583    {
584#ifdef ORXONOX_OLD_CEGUI
585        this->guiRenderer_->setDisplaySize(CEGUI::Size(newWidth, newHeight));
586#else
587        this->guiRenderer_->setDisplaySize(CEGUI::Size((float)newWidth, (float)newHeight));
588#endif
589    }
590
591    /**
592        @brief Notify CEGUI if the windows loses the focus (stops highlight of menu items, etc).
593    */
594    void GUIManager::windowFocusChanged(bool bFocus)
595    {
596        if (!bFocus)
597            this->mouseLeft();
598    }
599
600}
Note: See TracBrowser for help on using the repository browser.