Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/libraries/core/GUIManager.cc @ 9022

Last change on this file since 9022 was 9016, checked in by jo, 13 years ago

Merging presentation2011 branch to trunk. Please check for possible bugs.

  • Property svn:eol-style set to native
File size: 28.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 <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#else
316        guiSystem_ = &System::create(*guiRenderer_, resourceProvider_, 0, imageCodec_, scriptModule_);
317#endif
318
319        // Align CEGUI mouse with OIS mouse
320        guiSystem_->injectMousePosition((float)mousePosition.first, (float)mousePosition.second);
321
322        // Initialise the Lua framework and load the schemes
323        orxout(user_info) << "Loading user interface..." << endl;
324        this->luaState_->doFile("InitialiseGUI.lua");
325
326        // Create the root nodes
327        this->rootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("MenuWidgets/StaticImage", "AbsoluteRootWindow");
328        this->rootWindow_->setProperty("FrameEnabled", "False");
329        this->hudRootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("DefaultWindow", "HUDRootWindow");
330        this->menuRootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("DefaultWindow", "MenuRootWindow");
331        // And connect them
332        CEGUI::System::getSingleton().setGUISheet(this->rootWindow_);
333        this->rootWindow_->addChildWindow(this->hudRootWindow_);
334        this->rootWindow_->addChildWindow(this->menuRootWindow_);
335
336        // No background to start with (sets the alpha value to 0)
337        this->setBackgroundImage("");
338
339        // Set up the sheet manager in the Lua framework
340        this->luaState_->doFile("SheetManager.lua");
341
342        orxout(internal_status) << "finished initializing GUIManager" << endl;
343    }
344
345    void GUIManager::destroy()
346    {
347        orxout(internal_status) << "destroying GUIManager..." << endl;
348
349        using namespace CEGUI;
350
351#ifdef ORXONOX_OLD_CEGUI
352        safeObjectDelete(&guiSystem_);
353        safeObjectDelete(&guiRenderer_);
354        safeObjectDelete(&scriptModule_);
355#else
356        System::destroy();
357        OgreRenderer::destroyOgreResourceProvider(*resourceProvider_);
358        OgreRenderer::destroyOgreImageCodec(*imageCodec_);
359        OgreRenderer::destroy(*guiRenderer_);
360        LuaScriptModule::destroy(*scriptModule_);
361        safeObjectDelete(&ceguiLogger_);
362        safeObjectDelete(&rqListener_);
363#endif
364        safeObjectDelete(&luaState_);
365
366        orxout(internal_status) << "finished destroying GUIManager" << endl;
367    }
368
369    void GUIManager::setConfigValues(void)
370    {
371        SetConfigValue(guiScheme_, GUIManager::defaultScheme_).description("Changes the current GUI scheme.").callback(this, &GUIManager::changedGUIScheme);
372        SetConfigValue(numScrollLines_, 1).description("How many lines to scroll in a list if the scroll wheel is used");
373        SetConfigValue(bPreloadMenuSheets_, false).description("Pre-load menu sheets during startup");
374
375        SetConfigValueExternal(outputLevelCeguiLog_, BaseWriter::getConfigurableSectionName(), "outputLevelCeguiLog", CEGUI::Standard).description("The log level of the CEGUI log file").callback(this, &GUIManager::changedCeguiOutputLevel);
376    }
377
378    void GUIManager::changedGUIScheme(void)
379    {
380    }
381
382    void GUIManager::changedCeguiOutputLevel()
383    {
384        if (this->ceguiLogger_)
385            this->ceguiLogger_->setLoggingLevel(static_cast<CEGUI::LoggingLevel>(this->outputLevelCeguiLog_));
386    }
387
388    /**
389    @brief
390        used to tick the GUI
391    @param time
392        clock which provides time value for the GUI System
393
394        Ticking the GUI means updating it with a certain regularity.
395        The elapsed time since the last call is given in the time value provided by the clock.
396        This time value is then used to provide a fluent animation of the GUI.
397    */
398    void GUIManager::preUpdate(const Clock& time)
399    {
400        assert(guiSystem_);
401        this->protectedCall(boost::bind(&CEGUI::System::injectTimePulse, _1, time.getDeltaTime()));
402    }
403
404    /**
405    @brief
406        Tells the GUIManager which SceneManager to use
407    @param camera
408        The current camera on which the GUI should be displayed on.
409
410        In fact the GUIManager needs the SceneManager and not the Camera to display the GUI.
411        This means the GUI is not bound to a camera but rather to the SceneManager.
412        Hiding the GUI when needed can therefore not be resolved by just NOT setting the current camera.
413    */
414    void GUIManager::setCamera(Ogre::Camera* camera)
415    {
416#ifdef ORXONOX_OLD_CEGUI
417        if (camera == NULL)
418            this->guiRenderer_->setTargetSceneManager(0);
419        else
420            this->guiRenderer_->setTargetSceneManager(camera->getSceneManager());
421#else
422        if (camera_ != NULL && camera_->getSceneManager() != NULL)
423            camera_->getSceneManager()->removeRenderQueueListener(rqListener_);
424        if (camera != NULL && camera->getSceneManager() != NULL)
425            camera->getSceneManager()->addRenderQueueListener(rqListener_);
426#endif
427        this->camera_ = camera;
428    }
429
430    /**
431    @brief
432        Executes Lua code
433    @param str
434        reference to string object holding the Lua code which is to be executed
435    */
436    void GUIManager::executeCode(const std::string& str)
437    {
438        this->luaState_->doString(str, rootFileInfo_);
439    }
440
441    /** Loads a GUI sheet by Lua script
442    @param name
443        The name of the GUI (like the script name, but without the extension)
444    */
445    void GUIManager::loadGUI(const std::string& name)
446    {
447        this->executeCode("loadSheet(\"" + name + "\")");
448    }
449
450    /**
451    @brief
452        Displays specified GUI on screen
453    @param name
454        The name of the GUI
455    @param bHidePrevious
456        If true all displayed GUIs on the stack, that are below this GUI are hidden.
457    @param bNoInput
458        If true the GUI is transparent to input.
459
460        The function executes the Lua function with the same name in case the GUIManager is ready.
461    */
462    /*static*/ void GUIManager::showGUI(const std::string& name, bool bHidePrevious, bool bNoInput)
463    {
464        GUIManager::getInstance().executeCode("showMenuSheet(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + multi_cast<std::string>(bNoInput) + ")");
465    }
466
467    /**
468    @brief
469        Hack-ish. Needed for GUIOverlay.
470    */
471    void GUIManager::showGUIExtra(const std::string& name, const std::string& ptr, bool bHidePrevious, bool bNoInput)
472    {
473        this->executeCode("showMenuSheet(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + multi_cast<std::string>(bNoInput) + ", " + ptr + ")");
474    }
475
476    /**
477    @brief
478        Hides specified GUI.
479    @param name
480        The name of the GUI.
481    */
482    /*static*/ void GUIManager::hideGUI(const std::string& name)
483    {
484        GUIManager::getInstance().executeCode("hideMenuSheet(\"" + name + "\")");
485    }
486
487    /**
488    @brief
489        Toggles specified GUI.
490        If the GUI with the input name is already shown and on the top, it is hidden, else it is shown.
491    */
492    /*static*/ void GUIManager::toggleGUI(const std::string& name, bool bHidePrevious, bool bNoInput)
493    {
494        GUIManager::getInstance().executeCode("getGUIFirstActive(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + multi_cast<std::string>(bNoInput) + ")");
495    }
496
497    /**
498    @brief
499        Helper method to toggle a specified GUI.
500        Is called by lua.
501    */
502    void GUIManager::toggleGUIHelper(const std::string& name, bool bHidePrevious, bool bNoInput, bool show)
503    {
504        if(show)
505            GUIManager::showGUI(name, bHidePrevious, bNoInput);
506        else
507            GUIManager::hideGUI(name);
508    }
509
510    const std::string& GUIManager::createInputState(const std::string& name, tribool showCursor, tribool useKeyboard, bool bBlockJoyStick)
511    {
512        InputState* state = InputManager::getInstance().createInputState(name);
513        if (!state)
514            return BLANKSTRING;
515
516        /* Table that maps isFullScreen() and showCursor to mouseExclusive
517        isFullscreen / showCursor | True  | False | Dontcare
518        ----------------------------------------------------
519        true                      | True  | True  | Dontcare
520        ----------------------------------------------------
521        false                     | False | True  | Dontcare
522        */
523
524#ifdef ORXONOX_PLATFORM_APPLE
525        // There is no non exclusive mode on OS X yet
526        state->setMouseExclusive(true);
527#else
528        if (showCursor == dontcare)
529            state->setMouseExclusive(dontcare);
530        else if (GraphicsManager::getInstance().isFullScreen() || showCursor == false)
531            state->setMouseExclusive(true);
532        else
533            state->setMouseExclusive(false);
534#endif
535
536        if (showCursor == true)
537            state->setMouseHandler(this);
538        else if (showCursor == false)
539            state->setMouseHandler(&InputHandler::EMPTY);
540
541        if (useKeyboard == true)
542            state->setKeyHandler(this);
543        else if (useKeyboard == false)
544            state->setKeyHandler(&InputHandler::EMPTY);
545
546        if (bBlockJoyStick)
547            state->setJoyStickHandler(&InputHandler::EMPTY);
548
549        return state->getName();
550    }
551
552    void GUIManager::keyESC()
553    {
554        this->executeCode("keyESC()");
555    }
556
557    void GUIManager::setBackgroundImage(const std::string& imageSet, const std::string imageName)
558    {
559        if (imageSet.empty() || imageName.empty())
560            this->setBackgroundImage("");
561        else
562            this->setBackgroundImage("set: " + imageSet + " image: " + imageName);
563    }
564
565    void GUIManager::setBackgroundImage(const std::string& image)
566    {
567        if (image.empty())
568            this->rootWindow_->setProperty("Alpha", "0.0");
569        else
570            this->rootWindow_->setProperty("Alpha", "1.0");
571        this->rootWindow_->setProperty("Image", image);
572    }
573
574    void GUIManager::buttonPressed(const KeyEvent& evt)
575    {
576        this->protectedCall(boost::bind(&CEGUI::System::injectKeyDown, _1, evt.getKeyCode()));
577        this->protectedCall(boost::bind(&CEGUI::System::injectChar, _1, evt.getText()));
578    }
579
580    void GUIManager::buttonReleased(const KeyEvent& evt)
581    {
582        this->protectedCall(boost::bind(&CEGUI::System::injectKeyUp, _1, evt.getKeyCode()));
583    }
584
585    /**
586    @brief
587        Function receiving a mouse button pressed event.
588    @param id
589        ID of the mouse button which got pressed
590
591        This function is inherited by MouseHandler and injects the event into CEGUI.
592        It is for CEGUI to process the event.
593    */
594    void GUIManager::buttonPressed(MouseButtonCode::ByEnum id)
595    {
596        this->protectedCall(boost::bind(&CEGUI::System::injectMouseButtonDown, _1, convertButton(id)));
597    }
598
599    /**
600    @brief
601        Function receiving a mouse button released event.
602    @param id
603        ID of the mouse button which got released
604
605        This function is inherited by MouseHandler and injects the event into CEGUI.
606        It is for CEGUI to process the event.
607    */
608    void GUIManager::buttonReleased(MouseButtonCode::ByEnum id)
609    {
610        this->protectedCall(boost::bind(&CEGUI::System::injectMouseButtonUp, _1, convertButton(id)));
611    }
612
613    void GUIManager::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
614    {
615        this->protectedCall(boost::bind(&CEGUI::System::injectMousePosition, _1, (float)abs.x, (float)abs.y));
616    }
617
618    void GUIManager::mouseScrolled(int abs, int rel)
619    {
620        this->protectedCall(boost::bind(&CEGUI::System::injectMouseWheelChange, _1, (float)sgn(rel) * this->numScrollLines_));
621    }
622
623    /**
624        @brief Indicates that the mouse left the application's window.
625    */
626    void GUIManager::mouseLeft()
627    {
628        this->protectedCall(boost::bind(&CEGUI::System::injectMouseLeaves, _1));
629    }
630
631    /**
632    @brief
633        converts mouse event code to CEGUI event code
634    @param button
635        code of the mouse button as we use it in Orxonox
636    @return
637        code of the mouse button as it is used by CEGUI
638
639        Simple conversion from mouse event code in Orxonox to the one used in CEGUI.
640     */
641    static inline CEGUI::MouseButton convertButton(MouseButtonCode::ByEnum button)
642    {
643        switch (button)
644        {
645        case MouseButtonCode::Left:
646            return CEGUI::LeftButton;
647
648        case MouseButtonCode::Right:
649            return CEGUI::RightButton;
650
651        case MouseButtonCode::Middle:
652            return CEGUI::MiddleButton;
653
654        case MouseButtonCode::Button3:
655            return CEGUI::X1Button;
656
657        case MouseButtonCode::Button4:
658            return CEGUI::X2Button;
659
660        default:
661            return CEGUI::NoButton;
662        }
663    }
664
665    /** Executes a CEGUI function normally, but catches CEGUI::ScriptException.
666        When a ScriptException occurs, the error message will be displayed and
667        the program carries on.
668    @remarks
669        The exception behaviour may pose problems if the code is not written
670        exception-safe (and you can forget about that in Lua). The program might
671        be left in an undefined state. But otherwise one script error would
672        terminate the whole program...
673    @note
674        Your life gets easier if you use boost::bind to create the object/function.
675    @param function
676        Any callable object/function that takes this->guiSystem_ as its only parameter.
677    @return
678        True if input was handled, false otherwise. A caught exception yields true.
679    */
680    template <typename FunctionType>
681    bool GUIManager::protectedCall(FunctionType function)
682    {
683        try
684        {
685            return function(this->guiSystem_);
686        }
687        catch (CEGUI::ScriptException& ex)
688        {
689            // Display the error and proceed. See @remarks why this can be dangerous.
690            orxout(internal_error) << ex.getMessage() << endl;
691            return true;
692        }
693    }
694
695    /**
696    @brief
697        Subscribe the input function to the input event for the input window.
698        This is a helper to be used in lua, because subscribeScriptedEvent() doesn't work in lua.
699    @param window
700        The window for which the event is subscribed.
701    @param event
702        The type of event to which we subscribe.
703    @param function
704        The function that is called when the event occurs.
705    */
706    void GUIManager::subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function)
707    {
708        window->subscribeScriptedEvent(event, function);
709    }
710
711    /**
712    @brief
713        Set the input tooltip text for the input ListboxItem.
714    @param item
715        The ListboxItem for which the tooltip should be set.
716    @param tooltip
717        The tooltip text that should be set.
718    */
719    void GUIManager::setTooltipTextHelper(CEGUI::ListboxItem* item, const std::string& tooltip)
720    {
721        item->setTooltipText(tooltip);
722    }
723
724    /**
725    @brief
726        Set whether the tooltips for the input Listbox are enabled.
727    @param listbox
728        The Listbox for which to enable (or disable) tooltips.
729    @param enabled
730        Whether to enable or disable the tooltips.
731    */
732    void GUIManager::setItemTooltipsEnabledHelper(CEGUI::Listbox* listbox, bool enabled)
733    {
734        listbox->setItemTooltipsEnabled(enabled);
735    }
736
737    /** Helper method to get the developer's mode without having to export Core.h.
738    @see Core::inDevMode
739    */
740    /*static*/ bool GUIManager::inDevMode()
741    {
742         return Core::getInstance().inDevMode();
743    }
744
745    /**
746        @brief Callback of window event listener, called if the window is resized. Sets the display size of CEGUI.
747    */
748    void GUIManager::windowResized(unsigned int newWidth, unsigned int newHeight)
749    {
750        this->guiRenderer_->setDisplaySize(CEGUI::Size((float)newWidth, (float)newHeight));
751    }
752
753    /**
754        @brief Notify CEGUI if the windows loses the focus (stops highlighting of menu items, etc).
755    */
756    void GUIManager::windowFocusChanged(bool bFocus)
757    {
758        if (!bFocus)
759            this->mouseLeft();
760    }
761
762    /**
763    @brief
764        Adds a new freetype font to the CEGUI system.
765    @param name
766        The name of the new font.
767    @param size
768        The font size of the new font in pixels.
769        @param fontName
770        The filename of the font.
771    */
772    /*static*/ void GUIManager::addFontHelper(const std::string& name, int size, const std::string& fontName)
773    {
774#ifdef ORXONOX_OLD_CEGUI
775        if(CEGUI::FontManager::getSingleton().isFontPresent(name)) // If a font with that name already exists.
776            return;
777
778        CEGUI::Font* font = NULL;
779        CEGUI::XMLAttributes xmlAttributes;
780
781        // Attributes specified within CEGUIFont
782        xmlAttributes.add("Name", name);
783        xmlAttributes.add("Filename", fontName);
784        xmlAttributes.add("ResourceGroup", "");
785        xmlAttributes.add("AutoScaled", "true");
786        xmlAttributes.add("NativeHorzRes", "800");
787        xmlAttributes.add("NativeVertRes", "600");
788
789        // Attributes specified within CEGUIXMLAttributes
790        xmlAttributes.add("Size", multi_cast<std::string>(size));
791        xmlAttributes.add("AntiAlias", "true");
792
793        font = CEGUI::FontManager::getSingleton().createFont("FreeType", xmlAttributes);
794        if(font != NULL)
795            font->load();
796#else
797        if(CEGUI::FontManager::getSingleton().isDefined(name)) // If a font with that name already exists.
798            return;
799
800        CEGUI::FontManager::getSingleton().createFreeTypeFont(name, (float)size, true, fontName, "", true, 800.0f, 600.0f);
801#endif
802    }
803
804}
Note: See TracBrowser for help on using the repository browser.