SuperTuxKart
Loading...
Searching...
No Matches
abstract_state_manager.hpp
1//
2// SuperTuxKart - a fun racing game with go-kart
3// Copyright (C) 2010-2015 SuperTuxKart-Team
4//
5// This program is free software; you can redistribute it and/or
6// modify it under the terms of the GNU General Public License
7// as published by the Free Software Foundation; either version 3
8// of the License, or (at your option) any later version.
9//
10// This program is distributed in the hope that it will be useful,
11// but WITHOUT ANY WARRANTY; without even the implied warranty of
12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13// GNU General Public License for more details.
14//
15// You should have received a copy of the GNU General Public License
16// along with this program; if not, write to the Free Software
17// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
19#ifndef HEADER_ABSTRACT_STATE_MANAGER_HPP
20#define HEADER_ABSTRACT_STATE_MANAGER_HPP
21
22#include <atomic>
23#include <vector>
24#include <string>
25#include "guiengine/engine.hpp"
26#include "guiengine/screen.hpp"
27#include "utils/leak_check.hpp"
28
32namespace GUIEngine
33{
34 class Widget;
35 class Screen;
36
40 enum GameState : unsigned int
41 {
42 MENU,
43 GAME,
44 INGAME_MENU,
47 }; // GameState
48
54 {
55 protected:
59 std::atomic<GameState> m_game_mode;
60
65 std::vector<std::pair<std::string, Screen*> > m_menu_stack;
66
67 void pushMenu(Screen* screen);
68
69 void setGameState(GameState state);
70
71 public:
72
73 LEAK_CHECK()
74
75
77
78 virtual ~AbstractStateManager() { }
79
81 void pushScreen(Screen* screen);
82
89
96 void popMenu();
97
102 void resetAndGoToScreen(Screen* screen);
103
112 void resetAndSetStack(Screen* screens[]);
113
117 void onResize();
118
123 void enterMenuState() { setGameState(MENU); }
124
130 void enterGameState();
131
134
136 void reshowTopMostMenu();
137
138 template<typename T>
139 void hardResetAndGoToScreen()
140 {
141 if (m_game_mode.load() != GAME) GUIEngine::getCurrentScreen()->tearDown();
142
143 GUIEngine::clearScreenCache();
144
145 T* instance = T::getInstance();
146
147 m_menu_stack.emplace_back(instance->getName(), instance);
148 setGameState(MENU);
149
150 switchToScreen(instance);
152
153 onTopMostScreenChanged();
154 }
155
156 /* ***********************************
157 * methods to override in children *
158 *********************************** */
159
164 virtual void escapePressed() = 0;
165
170 virtual void onGameStateChange(GameState new_state) = 0;
171
177 virtual void onStackEmptied() = 0;
178
179 virtual void onTopMostScreenChanged() = 0;
180
181 // --------------------------------------------------------------------
184 unsigned int getMenuStackSize() const
185 {
186 return (unsigned int)m_menu_stack.size();
187 }
188 }; // Class AbstractStateManager
189
190} // GUIEngine
191#endif
Abstract base class you must override from to use the GUI engine.
Definition: abstract_state_manager.hpp:54
void enterGameState()
call to make the state manager enter game mode.
Definition: abstract_state_manager.cpp:50
void reshowTopMostMenu()
to be called after e.g.
Definition: abstract_state_manager.cpp:192
virtual void escapePressed()=0
callback invoked whenever escape was pressed (or any similar cancel operation)
void enterMenuState()
Used in no graphics STK to enter menu screen (when server is idle state)
Definition: abstract_state_manager.hpp:123
unsigned int getMenuStackSize() const
Returns the number of screens on the stack.
Definition: abstract_state_manager.hpp:184
void pushScreen(Screen *screen)
adds a menu at the top of the screens stack
Definition: abstract_state_manager.cpp:134
void replaceTopMostScreen(Screen *screen, GUIEngine::GameState gameState=GUIEngine::CURRENT)
replaces the menu at the top of the screens stack (i.e.
Definition: abstract_state_manager.cpp:155
std::vector< std::pair< std::string, Screen * > > m_menu_stack
This stack will contain menu names (e.g.
Definition: abstract_state_manager.hpp:65
void resetAndGoToScreen(Screen *screen)
clears the menu stack and starts afresh with a new stack containing only the given screen
Definition: abstract_state_manager.cpp:263
GameState getGameState()
Definition: abstract_state_manager.cpp:74
void resetAndSetStack(Screen *screens[])
Sets the whole menu stack.
Definition: abstract_state_manager.cpp:290
std::atomic< GameState > m_game_mode
Whether we are in game mode.
Definition: abstract_state_manager.hpp:59
virtual void onGameStateChange(GameState new_state)=0
callback invoked when game mode changes (e.g.
void onResize()
Called when resizing of stk window.
Definition: abstract_state_manager.cpp:317
void popMenu()
removes the menu at the top of the screens stack If the stack becomes empty after performing the pop ...
Definition: abstract_state_manager.cpp:218
virtual void onStackEmptied()=0
callback invoked when the stack is emptied (all menus are popped out).
Represents a single GUI screen.
Definition: screen.hpp:97
virtual void init()
Callback invoked when entering this menu (after the widgets have been added).
Definition: screen.cpp:94
virtual void tearDown()
Callback invoked before leaving this menu.
Definition: screen.cpp:116
The nearly-abstract base of all widgets (not fully abstract since a bare Widget can be created for th...
Definition: widget.hpp:143
GameState
Definition: abstract_state_manager.hpp:41
@ CURRENT
Dummy GameState e.
Definition: abstract_state_manager.hpp:46
Contains all GUI engine related classes and functions.
Definition: abstract_state_manager.hpp:33
void switchToScreen(Screen *screen)
Low-level mean to change current screen.
Definition: engine.cpp:925
Screen * getCurrentScreen()
Definition: engine.hpp:178