SuperTuxKart
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 <vector>
23 #include <string>
24 #include "guiengine/engine.hpp"
25 #include "guiengine/screen.hpp"
26 #include "utils/leak_check.hpp"
27 
31 namespace GUIEngine
32 {
33  class Widget;
34  class Screen;
35 
39  enum GameState
40  {
41  MENU,
42  GAME,
43  INGAME_MENU,
46  }; // GameState
47 
53  {
54  protected:
59 
64  std::vector<std::pair<std::string, Screen*> > m_menu_stack;
65 
66  void pushMenu(Screen* screen);
67 
68  void setGameState(GameState state);
69 
70  public:
71 
72  LEAK_CHECK()
73 
74 
76 
77  virtual ~AbstractStateManager() { }
78 
80  void pushScreen(Screen* screen);
81 
88 
95  void popMenu();
96 
101  void resetAndGoToScreen(Screen* screen);
102 
111  void resetAndSetStack(Screen* screens[]);
112 
116  void onResize();
117 
122  void enterMenuState() { setGameState(MENU); }
123 
129  void enterGameState();
130 
133 
135  void reshowTopMostMenu();
136 
137  template<typename T>
138  void hardResetAndGoToScreen()
139  {
140  if (m_game_mode != GAME) GUIEngine::getCurrentScreen()->tearDown();
141 
142  GUIEngine::clearScreenCache();
143 
144  T* instance = T::getInstance();
145 
146  m_menu_stack.emplace_back(instance->getName(), instance);
147  setGameState(MENU);
148 
149  switchToScreen(instance);
150  getCurrentScreen()->init();
151 
152  onTopMostScreenChanged();
153  }
154 
155  /* ***********************************
156  * methods to override in children *
157  *********************************** */
158 
163  virtual void escapePressed() = 0;
164 
169  virtual void onGameStateChange(GameState new_state) = 0;
170 
176  virtual void onStackEmptied() = 0;
177 
178  virtual void onTopMostScreenChanged() = 0;
179 
180  // --------------------------------------------------------------------
183  unsigned int getMenuStackSize() const
184  {
185  return (unsigned int)m_menu_stack.size();
186  }
187  }; // Class AbstractStateManager
188 
189 } // GUIEngine
190 #endif
GameState getGameState()
Definition: abstract_state_manager.cpp:74
void reshowTopMostMenu()
to be called after e.g.
Definition: abstract_state_manager.cpp:192
Contains all GUI engine related classes and functions.
Definition: abstract_state_manager.hpp:31
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
void resetAndSetStack(Screen *screens[])
Sets the whole menu stack.
Definition: abstract_state_manager.cpp:290
virtual void escapePressed()=0
callback invoked whenever escape was pressed (or any similar cancel operation)
Dummy GameState e.
Definition: abstract_state_manager.hpp:45
void enterMenuState()
Used in no graphics STK to enter menu screen (when server is idle state)
Definition: abstract_state_manager.hpp:122
virtual void onStackEmptied()=0
callback invoked when the stack is emptied (all menus are popped out).
virtual void init()
Callback invoked when entering this menu (after the widgets have been added).
Definition: screen.cpp:96
GameState
Definition: abstract_state_manager.hpp:39
void enterGameState()
call to make the state manager enter game mode.
Definition: abstract_state_manager.cpp:50
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
void switchToScreen(Screen *screen)
Low-level mean to change current screen.
Definition: engine.cpp:922
virtual void tearDown()
Callback invoked before leaving this menu.
Definition: screen.cpp:118
unsigned int getMenuStackSize() const
Returns the number of screens on the stack.
Definition: abstract_state_manager.hpp:183
Represents a single GUI screen.
Definition: screen.hpp:96
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 onGameStateChange(GameState new_state)=0
callback invoked when game mode changes (e.g.
std::vector< std::pair< std::string, Screen * > > m_menu_stack
This stack will contain menu names (e.g.
Definition: abstract_state_manager.hpp:64
void pushScreen(Screen *screen)
adds a menu at the top of the screens stack
Definition: abstract_state_manager.cpp:134
void onResize()
Called when resizing of stk window.
Definition: abstract_state_manager.cpp:317
GameState m_game_mode
Whether we are in game mode.
Definition: abstract_state_manager.hpp:58
The nearly-abstract base of all widgets (not fully abstract since a bare Widget can be created for th...
Definition: widget.hpp:142
Screen * getCurrentScreen()
Definition: engine.hpp:178
Abstract base class you must override from to use the GUI engine.
Definition: abstract_state_manager.hpp:52