fifechanmanager.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2019 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE is free software; you can redistribute it and/or                 *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

#ifndef FIFE_GUI_FIFECHANMANAGER_H
#define FIFE_GUI_FIFECHANMANAGER_H

// Standard C++ library includes
#include <set>

// 3rd party library includes
#include <fifechan.hpp>

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "util/base/fife_stdint.h"
#include "util/base/singleton.h"
#include "eventchannel/sdl/isdleventlistener.h"

#include "gui/guimanager.h"

namespace fcn {

    class Gui;
    class Container;
    class Widget;
    class SDLInput;
    class FocusHandler;

}


namespace FIFE {

    class GuiImageLoader;
    class Console;
    class Cursor;
    class KeyEvent;
    class MouseEvent;
    class IFont;
    class GuiFont;


    /* GUI Fifechan Manager.
     *
     * This class controls the Fifechan GUI system in FIFE.
     */
    class FifechanManager :
        public IGUIManager,
        public DynamicSingleton<FifechanManager>
         {
        public:
            FifechanManager();
            virtual ~FifechanManager();

            fcn::Gui* getFifechanGUI() const;

            virtual void turn();

            void init(const std::string& backend, int32_t screenWidth, int32_t screenHeight);

            void resizeTopContainer(uint32_t x, uint32_t y, uint32_t width, uint32_t height);

            void add(fcn::Widget* widget);

            void remove(fcn::Widget* widget);

            fcn::Container* getTopContainer() const { return m_fcn_topcontainer; }

            Console* getConsole() const { return m_console; };

            void setConsoleEnabled(bool console);

            bool isConsoleEnabled() const;

            void setCursor(Cursor* cursor) { m_cursor = cursor; }

            Cursor* getCursor() const { return m_cursor; }

            GuiFont* setDefaultFont(const std::string& path, uint32_t size, const std::string& glyphs);

            GuiFont* getDefaultFont() { return m_defaultfont; };

            GuiFont* createFont(const std::string& path = "", uint32_t size = 0, const std::string& glyphs = "");

            void releaseFont(GuiFont* font);

            void invalidateFonts();

            virtual bool onSdlEvent(SDL_Event& evt);

            KeyEvent translateKeyEvent(const fcn::KeyEvent& evt);
            MouseEvent translateMouseEvent(const fcn::MouseEvent& evt);

            void setTabbingEnabled(bool tabbing);

            bool isTabbingEnabled() const;

        protected:
            static int32_t convertFifechanKeyToFifeKey(int32_t value);

        private:
            // The Fifechan GUI.
            fcn::Gui* m_fcn_gui;
            // Fifechan Graphics
            fcn::Graphics* m_gui_graphics;
            // Focus handler for input management
            fcn::FocusHandler* m_focushandler;
            // The top container of the GUI.
            fcn::Container* m_fcn_topcontainer;
            // The imageloader.
            GuiImageLoader* m_imgloader;
            // The input controller.
            fcn::SDLInput *m_input;
            // The console.
            Console* m_console;
            // Acess to the Cursor class.
            Cursor* m_cursor;
            //The default font
            GuiFont* m_defaultfont;
            // The fonts used
            std::vector<GuiFont*> m_fonts;
            // Added widgets
            std::set<fcn::Widget*> m_widgets;

            // Used to accept mouse motion events that leave widget space
            bool m_had_mouse;
            bool m_had_widget;
            // Track last motion event position
            int32_t m_lastMotionX;
            int32_t m_lastMotionY;

            // default font settings
            std::string m_fontpath;
            std::string m_fontglyphs;
            int32_t m_fontsize;

            // true, if fifechan logic has already been executed for this round
            bool m_logic_executed;
            // True if the console should be created
            bool m_enabled_console;

            std::string m_backend;
    };

}

#endif