screen.hpp

//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2010-2015 Marianne Gagnon
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 3
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 
#ifndef HEADER_SCREEN_HPP
#define HEADER_SCREEN_HPP
 
#include <map>
#include <string>
#include <typeinfo>
#include "utils/cpp2011.hpp"
 
#include <irrString.h>
#include <IXMLReader.h>
 
namespace irr
{
    namespace gui { class IGUIElement; }
}
using namespace irr;
 
#include "config/stk_config.hpp"
#include "guiengine/abstract_top_level_container.hpp"
#include "guiengine/engine.hpp"
#include "guiengine/event_handler.hpp"
#include "guiengine/widget.hpp"
#include "input/input.hpp"
#include "utils/leak_check.hpp"
#include "utils/ptr_vector.hpp"
 
#include <functional>
 
namespace GUIEngine
{
    template<typename SCREEN>
    class ScreenSingleton
    {
    protected:
        static SCREEN* singleton;
    public:
 
        ~ScreenSingleton()
        {
            singleton = NULL;
        }
 
        static SCREEN* getInstance()
        {
            if (singleton == NULL)
            {
                singleton = new SCREEN();
                std::function<SCREEN*()> new_screen_function = []()
                    { return ScreenSingleton::getInstance(); };
                singleton->setScreenPointerFunction(new_screen_function);
                GUIEngine::addScreenToList(singleton);
            }
 
            return singleton;
        }
    };
    template <typename SCREEN> SCREEN*
        ScreenSingleton<SCREEN>::singleton = nullptr;
 
    class Screen : public AbstractTopLevelContainer
    {
protected:
        bool m_resizable;
    private:
        bool m_pause_race;
 
        bool m_loaded;
 
        bool m_render_3d;
 
        bool m_update_in_background;
 
        unsigned int m_magic_number;
 
        unsigned m_width, m_height;
 
        friend class Skin;
 
        std::string m_filename;
        std::function<Screen*()> m_screen_func;
    public:
 
        LEAK_CHECK()
 
        
        static void parseScreenFileDiv(irr::io::IXMLReader* xml,
                                       PtrVector<Widget>& append_to,
                                       irr::gui::IGUIElement* parent = NULL);
 
        std::function<Screen*()> getNewScreenPointer() const { return m_screen_func; }
 
        void setScreenPointerFunction(const std::function<Screen*()>& f) { m_screen_func = f; }
 
        Screen(bool pause_race=true);
 
        Screen(const char* filename, bool pause_race=true);
 
        virtual ~Screen();
 
        bool operator ==(const char* filename) const { return m_filename == filename; }
 
        void loadFromFile();
 
        bool isLoaded() const { return m_loaded; }
 
        void addWidgets();
 
        void calculateLayout();
 
        void manualAddWidget(Widget* w);
 
        void manualRemoveWidget(Widget* w);
        
        void setUpdateInBackground(bool value) {m_update_in_background = value;}
        bool getUpdateInBackground() {return m_update_in_background;}
 
        const std::string& getName() const { return m_filename; }
 
        virtual void unload();
 
        bool needs3D() { return m_render_3d; }
 
        void setNeeds3D(bool needs3D) { m_render_3d = needs3D; }
 
        virtual void loadedFromFile() = 0;
 
        virtual void unloaded() {}
 
        virtual void beforeAddingWidget() {}
 
        virtual void init();
 
        void push();
 
        virtual void tearDown();
 
        virtual bool onEscapePressed() { return true; }
 
        virtual void eventCallback(Widget* widget, const std::string& name, const int playerID) = 0;
 
        virtual void onUpdate(float dt) { };
 
        virtual void onDraw(float dt) { };
 
        virtual MusicInformation* getMusic() const { return stk_config->m_title_music; }
 
        virtual MusicInformation* getInGameMenuMusic() const { return NULL; }
 
        virtual int getWidth() { return m_width; }
 
        virtual int getHeight() { return m_height; }
 
        virtual bool isResizable() const { return m_resizable; }
        virtual EventPropagation filterActions(PlayerAction action,
                                               int deviceID,
                                               const unsigned int value,
                                               Input::InputType type,
                                               int playerId)
            { return EVENT_LET; }
 
        virtual void onDisabledItemClicked(const std::string& item) {}
 
        virtual void filterInput(Input::InputType type,
                                 int deviceID,
                                 int btnID,
                                 int axisDir,
                                 int value) {}
 
        virtual void onDialogClose() {}
 
        virtual void onFocusChanged(Widget* previous, Widget* focus, int playerID) {}
    };
 
    class CutsceneScreen : public Screen
    {
    public:
        CutsceneScreen(const char* name) : Screen(name, false)
        {
            setNeeds3D(true);
        }
 
        virtual void onCutsceneEnd() = 0;
    };
}
 
#endif