Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/tutorial3/src/libraries/core/GUIManager.cc @ 9647

Last change on this file since 9647 was 9050, checked in by dafrick, 13 years ago

More elegant resolution of discrepancies between cegui 0.6 and 0.7.

  • Property svn:eol-style set to native
File size: 28.9 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 <fstream>
33#include <memory>
34#include <boost/bind.hpp>
35#include <OgreRenderQueue.h>
36#include <OgreRenderWindow.h>
37
38#include <CEGUIDefaultLogger.h>
39#include <CEGUIExceptions.h>
40#include <CEGUIFontManager.h>
41#include <CEGUIInputEvent.h>
42#include <CEGUIMouseCursor.h>
43#include <CEGUIResourceProvider.h>
44#include <CEGUISystem.h>
45#include <CEGUIWindow.h>
46#include <CEGUIWindowManager.h>
47#include <CEGUIXMLAttributes.h>
48#include <elements/CEGUIListbox.h>
49#include <elements/CEGUIListboxItem.h>
50
51#ifdef ORXONOX_OLD_CEGUI
52#  include <CEGUILua.h>
53#  include <ogreceguirenderer/OgreCEGUIRenderer.h>
54extern "C" {
55#  include <lauxlib.h>
56}
57#else
58#  include <ScriptingModules/LuaScriptModule/CEGUILua.h>
59#  include <RendererModules/Ogre/CEGUIOgreImageCodec.h>
60#  include <RendererModules/Ogre/CEGUIOgreRenderer.h>
61#  include <RendererModules/Ogre/CEGUIOgreResourceProvider.h>
62#  include <OgreCamera.h>
63#  include <OgreRenderQueueListener.h>
64#  include <OgreRenderSystem.h>
65#  include <OgreRoot.h>
66#  include <OgreSceneManager.h>
67#endif
68
69#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_COMPILER_MINGW)
70#  include <windows.h>
71#endif
72
73#include "util/Clock.h"
74#include "util/Convert.h"
75#include "util/Output.h"
76#include "util/Exception.h"
77#include "util/Math.h"
78#include "util/OrxAssert.h"
79#include "util/output/BaseWriter.h"
80#include "ConfigValueIncludes.h"
81#include "Core.h"
82#include "CoreIncludes.h"
83#include "Game.h"
84#include "GraphicsManager.h"
85#include "LuaState.h"
86#include "PathConfig.h"
87#include "Resource.h"
88#include "command/ConsoleCommand.h"
89#include "input/InputManager.h"
90#include "input/InputState.h"
91#include "input/KeyBinderManager.h"
92
93namespace orxonox
94{
95    static void key_esc()
96        { GUIManager::getInstance().keyESC(); }
97    SetConsoleCommand("keyESC", &key_esc);
98
99    class CEGUILogger : public CEGUI::DefaultLogger
100    {
101    public:
102        void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
103        {
104            OutputLevel orxonoxLevel = level::debug_output;
105            switch (level)
106            {
107                case CEGUI::Errors:      orxonoxLevel = level::internal_error; break;
108                case CEGUI::Warnings:    orxonoxLevel = level::internal_warning; break;
109                case CEGUI::Standard:    orxonoxLevel = level::verbose; break;
110                case CEGUI::Informative: orxonoxLevel = level::verbose_more; break;
111                case CEGUI::Insane:      orxonoxLevel = level::verbose_ultra; break;
112                default: OrxAssert(false, "CEGUI log level out of range, inspect immediately!");
113            }
114
115            orxout(orxonoxLevel, context::cegui) << message << endl;
116
117            CEGUI::DefaultLogger::logEvent(message, level);
118        }
119
120        /// Carbon copy from CEGUIDefaultLogger.cpp with a bugfix for Windows
121        void setLogFilename(const CEGUI::String& filename, bool append = false)
122        {
123            // Close current log file (if any)
124            if (d_ostream.is_open())
125                d_ostream.close();
126
127#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_COMPILER_MINGW)
128            // filename.c_str() is UTF-8 encoded, but Windows expects characters
129            // according to the current codepage or UTF-16 (wchar)
130            d_ostream.open(utf8ToUtf16(filename.c_str()).c_str(), std::ios_base::out | (append ? std::ios_base::app : std::ios_base::trunc));
131#else
132            d_ostream.open(filename.c_str(), std::ios_base::out | (append ? std::ios_base::app : std::ios_base::trunc));
133#endif
134            if (!d_ostream)
135                ThrowException(General, "Setting the CEGUI log filename failed");
136
137            // Initialise width for date & time alignment.
138            d_ostream.width(2);
139
140            // Write out cached log strings.
141            if (d_caching)
142            {
143                d_caching = false;
144
145                std::vector<std::pair<CEGUI::String, CEGUI::LoggingLevel> >::iterator it = d_cache.begin();
146
147                while (it != d_cache.end())
148                {
149                    if (d_level >= it->second)
150                    {
151                        d_ostream << it->first;
152                        // Ensure new event is written to the file, rather than just being buffered.
153                        d_ostream.flush();
154                    }
155                    ++it;
156                }
157
158                d_cache.clear();
159            }
160        }
161
162#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_COMPILER_MINGW)
163        /// Converts a UTF-8 character sequence to Windows UTF-16
164        static std::wstring utf8ToUtf16(const std::string& utf8text)
165        {
166            const int textLen = MultiByteToWideChar(CP_UTF8, 0, utf8text.c_str(),
167                utf8text.size() + 1, 0, 0);
168
169            if (textLen == 0)
170                ThrowException(General, "Utf8ToUtf16 - MultiByteToWideChar failed");
171
172            std::wstring wideStr(textLen, 0);
173            MultiByteToWideChar(CP_UTF8, 0, utf8text.c_str(), utf8text.size() + 1,
174                &wideStr[0], wideStr.size());
175            return wideStr;
176        }
177#endif
178    };
179
180#ifdef ORXONOX_OLD_CEGUI
181    /** Class with the same memory layout as CEGUI::LuaScriptModule. <br>
182        We need this to fix a problem with an uninitialised member variable
183        in CEGUI < 0.7 <br>
184        Notice the "public" modifier for the otherwise private variables.
185    */
186    class LuaScriptModuleWorkaround : public CEGUI::ScriptModule
187    {
188    public:
189        LuaScriptModuleWorkaround();
190        ~LuaScriptModuleWorkaround();
191
192    public:
193        bool d_ownsState;
194        lua_State* d_state;
195        CEGUI::String d_errFuncName;
196        int d_errFuncIndex;
197        CEGUI::String d_activeErrFuncName;
198        int d_activeErrFuncIndex;
199    };
200#else
201    /// RenderQueueListener based class used to hook into the ogre rendering system
202    class RQListener : public Ogre::RenderQueueListener
203    {
204    public:
205        /// Callback from Ogre invoked before other stuff in our target queue is rendered
206        void renderQueueStarted(Ogre::uint8 id, const Ogre::String& invocation, bool& skipThisQueue)
207        {
208            if (id == Ogre::RENDER_QUEUE_OVERLAY && invocation.empty())
209            {
210                CEGUI::System::getSingleton().renderGUI();
211
212                // Important workaround! (at least required by CEGUI 0.7.5)
213                // If we don't reset the scissor test, OGRE will only render overlays
214                // in the area where CEGUI last drew, which is usually nothing
215                // or a little box where the focused element is.
216                Ogre::Root::getSingleton().getRenderSystem()->setScissorTest(false);
217            }
218        }
219    };
220#endif
221
222    static CEGUI::MouseButton convertButton(MouseButtonCode::ByEnum button);
223
224    GUIManager* GUIManager::singletonPtr_s = 0;
225    /*static*/ const std::string GUIManager::defaultScheme_ = "TaharezGreen"; //Alternative: Orxonox (not fully complete yet, see the graphics menu)
226
227    SetConsoleCommand("showGUI", &GUIManager::showGUI).defaultValue(1, false).defaultValue(2, false);
228    SetConsoleCommand("hideGUI", &GUIManager::hideGUI);
229    SetConsoleCommand("toggleGUI", &GUIManager::toggleGUI).defaultValue(1, false).defaultValue(2, false);
230
231    /**
232    @brief
233        Constructs the GUIManager by starting up CEGUI
234
235        Creates the interface to Ogre, sets up the CEGUI renderer and the Lua script module together with the Lua engine.
236        The log is set up and connected to the CEGUILogger.
237        After Lua setup tolua++-elements are linked to Lua-state to give Lua access to C++-code.
238        Finally initial Lua code is executed (maybe we can do this with the CEGUI startup script automatically).
239    @return true if success, otherwise false
240    */
241    GUIManager::GUIManager(const std::pair<int, int>& mousePosition)
242        : guiRenderer_(NULL)
243        , resourceProvider_(NULL)
244#ifndef ORXONOX_OLD_CEGUI
245        , rqListener_(NULL)
246        , imageCodec_(NULL)
247#endif
248        , luaState_(NULL)
249        , scriptModule_(NULL)
250        , guiSystem_(NULL)
251        , ceguiLogger_(NULL)
252        , rootWindow_(NULL)
253        , hudRootWindow_(NULL)
254        , menuRootWindow_(NULL)
255        , camera_(NULL)
256        , destructionHelper_(this)
257    {
258        RegisterRootObject(GUIManager);
259
260        orxout(internal_status) << "initializing GUIManager..." << endl;
261
262        this->setConfigValues();
263
264        using namespace CEGUI;
265
266        orxout(internal_info) << "Initialising CEGUI." << endl;
267
268        this->oldCEGUI_ = false;
269
270        // Note: No SceneManager specified yet
271#ifdef ORXONOX_OLD_CEGUI
272        guiRenderer_ = new OgreCEGUIRenderer(GraphicsManager::getInstance().getRenderWindow(), Ogre::RENDER_QUEUE_OVERLAY, false, 3000);
273        resourceProvider_ = guiRenderer_->createResourceProvider();
274        this->oldCEGUI_ = true;
275#else
276        guiRenderer_ = &OgreRenderer::create(*GraphicsManager::getInstance().getRenderWindow());
277        // We use our own RenderQueueListener so we can draw UNDER overlays
278        guiRenderer_->setFrameControlExecutionEnabled(false);
279        rqListener_ = new RQListener();
280        resourceProvider_ = &OgreRenderer::createOgreResourceProvider();
281        imageCodec_ = &OgreRenderer::createOgreImageCodec();
282#endif
283        resourceProvider_->setDefaultResourceGroup("General");
284
285        // Setup scripting
286        luaState_ = new LuaState();
287        rootFileInfo_ = Resource::getInfo("InitialiseGUI.lua");
288        // This is necessary to ensure that input events also use the right resource info when triggering lua functions
289        luaState_->setDefaultResourceInfo(this->rootFileInfo_);
290#ifdef ORXONOX_OLD_CEGUI
291        scriptModule_ = new LuaScriptModule(luaState_->getInternalLuaState());
292        // Ugly workaround: older CEGUILua versions don't initialise the member
293        // d_activeErrFuncIndex at all. That leads to "error in error handling"
294        // problems when a Lua error occurs.
295        // We fix this by setting the member manually.
296        reinterpret_cast<LuaScriptModuleWorkaround*>(scriptModule_)->d_activeErrFuncIndex = LUA_NOREF;
297        luaState_->doString("ORXONOX_OLD_CEGUI = true");
298#else
299        scriptModule_ = &LuaScriptModule::create(luaState_->getInternalLuaState());
300#endif
301        scriptModule_->setDefaultPCallErrorHandler(LuaState::ERROR_HANDLER_NAME);
302
303        // Create our own logger to specify the filepath
304        std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
305        ceguiLogger->setLogFilename(PathConfig::getLogPathString() + "cegui.log");
306        ceguiLogger->setLoggingLevel(static_cast<CEGUI::LoggingLevel>(this->outputLevelCeguiLog_));
307        this->ceguiLogger_ = ceguiLogger.release();
308
309        // Create the CEGUI system singleton
310#ifdef ORXONOX_OLD_CEGUI
311        guiSystem_ = new System(guiRenderer_, resourceProvider_, 0, scriptModule_);
312        // Add functions that have been renamed in newer versions
313        luaState_->doString("CEGUI.SchemeManager.create = CEGUI.SchemeManager.loadScheme");
314        luaState_->doString("CEGUI.Window.getUnclippedOuterRect = CEGUI.Window.getUnclippedPixelRect");
315        luaState_->doString("CEGUI.ImagesetManager.createFromImageFile= CEGUI.ImagesetManager.createImagesetFromImageFile");
316#else
317        guiSystem_ = &System::create(*guiRenderer_, resourceProvider_, 0, imageCodec_, scriptModule_);
318#endif
319
320        // Align CEGUI mouse with OIS mouse
321        guiSystem_->injectMousePosition((float)mousePosition.first, (float)mousePosition.second);
322
323        // Initialise the Lua framework and load the schemes
324        orxout(user_info) << "Loading user interface..." << endl;
325        this->luaState_->doFile("InitialiseGUI.lua");
326
327        // Create the root nodes
328        this->rootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("MenuWidgets/StaticImage", "AbsoluteRootWindow");
329        this->rootWindow_->setProperty("FrameEnabled", "False");
330        this->hudRootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("DefaultWindow", "HUDRootWindow");
331        this->menuRootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("DefaultWindow", "MenuRootWindow");
332        // And connect them
333        CEGUI::System::getSingleton().setGUISheet(this->rootWindow_);
334        this->rootWindow_->addChildWindow(this->hudRootWindow_);
335        this->rootWindow_->addChildWindow(this->menuRootWindow_);
336
337        // No background to start with (sets the alpha value to 0)
338        this->setBackgroundImage("");
339
340        // Set up the sheet manager in the Lua framework
341        this->luaState_->doFile("SheetManager.lua");
342
343        orxout(internal_status) << "finished initializing GUIManager" << endl;
344    }
345
346    void GUIManager::destroy()
347    {
348        orxout(internal_status) << "destroying GUIManager..." << endl;
349
350        using namespace CEGUI;
351
352#ifdef ORXONOX_OLD_CEGUI
353        safeObjectDelete(&guiSystem_);
354        safeObjectDelete(&guiRenderer_);
355        safeObjectDelete(&scriptModule_);
356#else
357        System::destroy();
358        OgreRenderer::destroyOgreResourceProvider(*resourceProvider_);
359        OgreRenderer::destroyOgreImageCodec(*imageCodec_);
360        OgreRenderer::destroy(*guiRenderer_);
361        LuaScriptModule::destroy(*scriptModule_);
362        safeObjectDelete(&ceguiLogger_);
363        safeObjectDelete(&rqListener_);
364#endif
365        safeObjectDelete(&luaState_);
366
367        orxout(internal_status) << "finished destroying GUIManager" << endl;
368    }
369
370    void GUIManager::setConfigValues(void)
371    {
372        SetConfigValue(guiScheme_, GUIManager::defaultScheme_).description("Changes the current GUI scheme.").callback(this, &GUIManager::changedGUIScheme);
373        SetConfigValue(numScrollLines_, 1).description("How many lines to scroll in a list if the scroll wheel is used");
374        SetConfigValue(bPreloadMenuSheets_, false).description("Pre-load menu sheets during startup");
375
376        SetConfigValueExternal(outputLevelCeguiLog_, BaseWriter::getConfigurableSectionName(), "outputLevelCeguiLog", CEGUI::Standard).description("The log level of the CEGUI log file").callback(this, &GUIManager::changedCeguiOutputLevel);
377    }
378
379    void GUIManager::changedGUIScheme(void)
380    {
381    }
382
383    void GUIManager::changedCeguiOutputLevel()
384    {
385        if (this->ceguiLogger_)
386            this->ceguiLogger_->setLoggingLevel(static_cast<CEGUI::LoggingLevel>(this->outputLevelCeguiLog_));
387    }
388
389    /**
390    @brief
391        used to tick the GUI
392    @param time
393        clock which provides time value for the GUI System
394
395        Ticking the GUI means updating it with a certain regularity.
396        The elapsed time since the last call is given in the time value provided by the clock.
397        This time value is then used to provide a fluent animation of the GUI.
398    */
399    void GUIManager::preUpdate(const Clock& time)
400    {
401        assert(guiSystem_);
402        this->protectedCall(boost::bind(&CEGUI::System::injectTimePulse, _1, time.getDeltaTime()));
403    }
404
405    /**
406    @brief
407        Tells the GUIManager which SceneManager to use
408    @param camera
409        The current camera on which the GUI should be displayed on.
410
411        In fact the GUIManager needs the SceneManager and not the Camera to display the GUI.
412        This means the GUI is not bound to a camera but rather to the SceneManager.
413        Hiding the GUI when needed can therefore not be resolved by just NOT setting the current camera.
414    */
415    void GUIManager::setCamera(Ogre::Camera* camera)
416    {
417#ifdef ORXONOX_OLD_CEGUI
418        if (camera == NULL)
419            this->guiRenderer_->setTargetSceneManager(0);
420        else
421            this->guiRenderer_->setTargetSceneManager(camera->getSceneManager());
422#else
423        if (camera_ != NULL && camera_->getSceneManager() != NULL)
424            camera_->getSceneManager()->removeRenderQueueListener(rqListener_);
425        if (camera != NULL && camera->getSceneManager() != NULL)
426            camera->getSceneManager()->addRenderQueueListener(rqListener_);
427#endif
428        this->camera_ = camera;
429    }
430
431    /**
432    @brief
433        Executes Lua code
434    @param str
435        reference to string object holding the Lua code which is to be executed
436    */
437    void GUIManager::executeCode(const std::string& str)
438    {
439        this->luaState_->doString(str, rootFileInfo_);
440    }
441
442    /** Loads a GUI sheet by Lua script
443    @param name
444        The name of the GUI (like the script name, but without the extension)
445    */
446    void GUIManager::loadGUI(const std::string& name)
447    {
448        this->executeCode("loadSheet(\"" + name + "\")");
449    }
450
451    /**
452    @brief
453        Displays specified GUI on screen
454    @param name
455        The name of the GUI
456    @param bHidePrevious
457        If true all displayed GUIs on the stack, that are below this GUI are hidden.
458    @param bNoInput
459        If true the GUI is transparent to input.
460
461        The function executes the Lua function with the same name in case the GUIManager is ready.
462    */
463    /*static*/ void GUIManager::showGUI(const std::string& name, bool bHidePrevious, bool bNoInput)
464    {
465        GUIManager::getInstance().executeCode("showMenuSheet(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + multi_cast<std::string>(bNoInput) + ")");
466    }
467
468    /**
469    @brief
470        Hack-ish. Needed for GUIOverlay.
471    */
472    void GUIManager::showGUIExtra(const std::string& name, const std::string& ptr, bool bHidePrevious, bool bNoInput)
473    {
474        this->executeCode("showMenuSheet(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + multi_cast<std::string>(bNoInput) + ", " + ptr + ")");
475    }
476
477    /**
478    @brief
479        Hides specified GUI.
480    @param name
481        The name of the GUI.
482    */
483    /*static*/ void GUIManager::hideGUI(const std::string& name)
484    {
485        GUIManager::getInstance().executeCode("hideMenuSheet(\"" + name + "\")");
486    }
487
488    /**
489    @brief
490        Toggles specified GUI.
491        If the GUI with the input name is already shown and on the top, it is hidden, else it is shown.
492    */
493    /*static*/ void GUIManager::toggleGUI(const std::string& name, bool bHidePrevious, bool bNoInput)
494    {
495        GUIManager::getInstance().executeCode("getGUIFirstActive(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + multi_cast<std::string>(bNoInput) + ")");
496    }
497
498    /**
499    @brief
500        Helper method to toggle a specified GUI.
501        Is called by lua.
502    */
503    void GUIManager::toggleGUIHelper(const std::string& name, bool bHidePrevious, bool bNoInput, bool show)
504    {
505        if(show)
506            GUIManager::showGUI(name, bHidePrevious, bNoInput);
507        else
508            GUIManager::hideGUI(name);
509    }
510
511    const std::string& GUIManager::createInputState(const std::string& name, tribool showCursor, tribool useKeyboard, bool bBlockJoyStick)
512    {
513        InputState* state = InputManager::getInstance().createInputState(name);
514        if (!state)
515            return BLANKSTRING;
516
517        /* Table that maps isFullScreen() and showCursor to mouseExclusive
518        isFullscreen / showCursor | True  | False | Dontcare
519        ----------------------------------------------------
520        true                      | True  | True  | Dontcare
521        ----------------------------------------------------
522        false                     | False | True  | Dontcare
523        */
524
525#ifdef ORXONOX_PLATFORM_APPLE
526        // There is no non exclusive mode on OS X yet
527        state->setMouseExclusive(true);
528#else
529        if (showCursor == dontcare)
530            state->setMouseExclusive(dontcare);
531        else if (GraphicsManager::getInstance().isFullScreen() || showCursor == false)
532            state->setMouseExclusive(true);
533        else
534            state->setMouseExclusive(false);
535#endif
536
537        if (showCursor == true)
538            state->setMouseHandler(this);
539        else if (showCursor == false)
540            state->setMouseHandler(&InputHandler::EMPTY);
541
542        if (useKeyboard == true)
543            state->setKeyHandler(this);
544        else if (useKeyboard == false)
545            state->setKeyHandler(&InputHandler::EMPTY);
546
547        if (bBlockJoyStick)
548            state->setJoyStickHandler(&InputHandler::EMPTY);
549
550        return state->getName();
551    }
552
553    void GUIManager::keyESC()
554    {
555        this->executeCode("keyESC()");
556    }
557
558    void GUIManager::setBackgroundImage(const std::string& imageSet, const std::string imageName)
559    {
560        if (imageSet.empty() || imageName.empty())
561            this->setBackgroundImage("");
562        else
563            this->setBackgroundImage("set: " + imageSet + " image: " + imageName);
564    }
565
566    void GUIManager::setBackgroundImage(const std::string& image)
567    {
568        if (image.empty())
569            this->rootWindow_->setProperty("Alpha", "0.0");
570        else
571            this->rootWindow_->setProperty("Alpha", "1.0");
572        this->rootWindow_->setProperty("Image", image);
573    }
574
575    void GUIManager::buttonPressed(const KeyEvent& evt)
576    {
577        this->protectedCall(boost::bind(&CEGUI::System::injectKeyDown, _1, evt.getKeyCode()));
578        this->protectedCall(boost::bind(&CEGUI::System::injectChar, _1, evt.getText()));
579    }
580
581    void GUIManager::buttonReleased(const KeyEvent& evt)
582    {
583        this->protectedCall(boost::bind(&CEGUI::System::injectKeyUp, _1, evt.getKeyCode()));
584    }
585
586    /**
587    @brief
588        Function receiving a mouse button pressed event.
589    @param id
590        ID of the mouse button which got pressed
591
592        This function is inherited by MouseHandler and injects the event into CEGUI.
593        It is for CEGUI to process the event.
594    */
595    void GUIManager::buttonPressed(MouseButtonCode::ByEnum id)
596    {
597        this->protectedCall(boost::bind(&CEGUI::System::injectMouseButtonDown, _1, convertButton(id)));
598    }
599
600    /**
601    @brief
602        Function receiving a mouse button released event.
603    @param id
604        ID of the mouse button which got released
605
606        This function is inherited by MouseHandler and injects the event into CEGUI.
607        It is for CEGUI to process the event.
608    */
609    void GUIManager::buttonReleased(MouseButtonCode::ByEnum id)
610    {
611        this->protectedCall(boost::bind(&CEGUI::System::injectMouseButtonUp, _1, convertButton(id)));
612    }
613
614    void GUIManager::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
615    {
616        this->protectedCall(boost::bind(&CEGUI::System::injectMousePosition, _1, (float)abs.x, (float)abs.y));
617    }
618
619    void GUIManager::mouseScrolled(int abs, int rel)
620    {
621        this->protectedCall(boost::bind(&CEGUI::System::injectMouseWheelChange, _1, (float)sgn(rel) * this->numScrollLines_));
622    }
623
624    /**
625        @brief Indicates that the mouse left the application's window.
626    */
627    void GUIManager::mouseLeft()
628    {
629        this->protectedCall(boost::bind(&CEGUI::System::injectMouseLeaves, _1));
630    }
631
632    /**
633    @brief
634        converts mouse event code to CEGUI event code
635    @param button
636        code of the mouse button as we use it in Orxonox
637    @return
638        code of the mouse button as it is used by CEGUI
639
640        Simple conversion from mouse event code in Orxonox to the one used in CEGUI.
641     */
642    static inline CEGUI::MouseButton convertButton(MouseButtonCode::ByEnum button)
643    {
644        switch (button)
645        {
646        case MouseButtonCode::Left:
647            return CEGUI::LeftButton;
648
649        case MouseButtonCode::Right:
650            return CEGUI::RightButton;
651
652        case MouseButtonCode::Middle:
653            return CEGUI::MiddleButton;
654
655        case MouseButtonCode::Button3:
656            return CEGUI::X1Button;
657
658        case MouseButtonCode::Button4:
659            return CEGUI::X2Button;
660
661        default:
662            return CEGUI::NoButton;
663        }
664    }
665
666    /** Executes a CEGUI function normally, but catches CEGUI::ScriptException.
667        When a ScriptException occurs, the error message will be displayed and
668        the program carries on.
669    @remarks
670        The exception behaviour may pose problems if the code is not written
671        exception-safe (and you can forget about that in Lua). The program might
672        be left in an undefined state. But otherwise one script error would
673        terminate the whole program...
674    @note
675        Your life gets easier if you use boost::bind to create the object/function.
676    @param function
677        Any callable object/function that takes this->guiSystem_ as its only parameter.
678    @return
679        True if input was handled, false otherwise. A caught exception yields true.
680    */
681    template <typename FunctionType>
682    bool GUIManager::protectedCall(FunctionType function)
683    {
684        try
685        {
686            return function(this->guiSystem_);
687        }
688        catch (CEGUI::ScriptException& ex)
689        {
690            // Display the error and proceed. See @remarks why this can be dangerous.
691            orxout(internal_error) << ex.getMessage() << endl;
692            return true;
693        }
694    }
695
696    /**
697    @brief
698        Subscribe the input function to the input event for the input window.
699        This is a helper to be used in lua, because subscribeScriptedEvent() doesn't work in lua.
700    @param window
701        The window for which the event is subscribed.
702    @param event
703        The type of event to which we subscribe.
704    @param function
705        The function that is called when the event occurs.
706    */
707    void GUIManager::subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function)
708    {
709        window->subscribeScriptedEvent(event, function);
710    }
711
712    /**
713    @brief
714        Set the input tooltip text for the input ListboxItem.
715    @param item
716        The ListboxItem for which the tooltip should be set.
717    @param tooltip
718        The tooltip text that should be set.
719    */
720    void GUIManager::setTooltipTextHelper(CEGUI::ListboxItem* item, const std::string& tooltip)
721    {
722        item->setTooltipText(tooltip);
723    }
724
725    /**
726    @brief
727        Set whether the tooltips for the input Listbox are enabled.
728    @param listbox
729        The Listbox for which to enable (or disable) tooltips.
730    @param enabled
731        Whether to enable or disable the tooltips.
732    */
733    void GUIManager::setItemTooltipsEnabledHelper(CEGUI::Listbox* listbox, bool enabled)
734    {
735        listbox->setItemTooltipsEnabled(enabled);
736    }
737
738    /** Helper method to get the developer's mode without having to export Core.h.
739    @see Core::inDevMode
740    */
741    /*static*/ bool GUIManager::inDevMode()
742    {
743         return Core::getInstance().inDevMode();
744    }
745
746    /**
747        @brief Callback of window event listener, called if the window is resized. Sets the display size of CEGUI.
748    */
749    void GUIManager::windowResized(unsigned int newWidth, unsigned int newHeight)
750    {
751        this->guiRenderer_->setDisplaySize(CEGUI::Size((float)newWidth, (float)newHeight));
752    }
753
754    /**
755        @brief Notify CEGUI if the windows loses the focus (stops highlighting of menu items, etc).
756    */
757    void GUIManager::windowFocusChanged(bool bFocus)
758    {
759        if (!bFocus)
760            this->mouseLeft();
761    }
762
763    /**
764    @brief
765        Adds a new freetype font to the CEGUI system.
766    @param name
767        The name of the new font.
768    @param size
769        The font size of the new font in pixels.
770        @param fontName
771        The filename of the font.
772    */
773    /*static*/ void GUIManager::addFontHelper(const std::string& name, int size, const std::string& fontName)
774    {
775#ifdef ORXONOX_OLD_CEGUI
776        if(CEGUI::FontManager::getSingleton().isFontPresent(name)) // If a font with that name already exists.
777            return;
778
779        CEGUI::Font* font = NULL;
780        CEGUI::XMLAttributes xmlAttributes;
781
782        // Attributes specified within CEGUIFont
783        xmlAttributes.add("Name", name);
784        xmlAttributes.add("Filename", fontName);
785        xmlAttributes.add("ResourceGroup", "");
786        xmlAttributes.add("AutoScaled", "true");
787        xmlAttributes.add("NativeHorzRes", "800");
788        xmlAttributes.add("NativeVertRes", "600");
789
790        // Attributes specified within CEGUIXMLAttributes
791        xmlAttributes.add("Size", multi_cast<std::string>(size));
792        xmlAttributes.add("AntiAlias", "true");
793
794        font = CEGUI::FontManager::getSingleton().createFont("FreeType", xmlAttributes);
795        if(font != NULL)
796            font->load();
797#else
798        if(CEGUI::FontManager::getSingleton().isDefined(name)) // If a font with that name already exists.
799            return;
800
801        CEGUI::FontManager::getSingleton().createFreeTypeFont(name, (float)size, true, fontName, "", true, 800.0f, 600.0f);
802#endif
803    }
804
805}
Note: See TracBrowser for help on using the repository browser.