Use std::unique_ptr<> in ScreenManager

[supertux.git] / src / supertux / screen_manager.cpp

diff --git a/src/supertux/screen_manager.cpp b/src/supertux/screen_manager.cpp
index e1e7f12..49468c2 100644 (file)
--- a/src/supertux/screen_manager.cpp
+++ b/src/supertux/screen_manager.cpp
@@ -17,20 +17,21 @@
 #include "supertux/screen_manager.hpp"
 
 #include "audio/sound_manager.hpp"
-#include "control/joystickkeyboardcontroller.hpp"
+#include "control/input_manager.hpp"
 #include "gui/menu.hpp"
 #include "gui/menu_manager.hpp"
 #include "scripting/squirrel_util.hpp"
 #include "scripting/time_scheduler.hpp"
-#include "supertux/constants.hpp"
 #include "supertux/console.hpp"
+#include "supertux/constants.hpp"
 #include "supertux/gameconfig.hpp"
 #include "supertux/globals.hpp"
 #include "supertux/main.hpp"
+#include "supertux/menu/menu_storage.hpp"
 #include "supertux/player_status.hpp"
 #include "supertux/resources.hpp"
-#include "supertux/screen_fade.hpp"
 #include "supertux/screen.hpp"
+#include "supertux/screen_fade.hpp"
 #include "supertux/timer.hpp"
 #include "video/drawing_context.hpp"
 #include "video/renderer.hpp"
@@ -43,6 +44,8 @@ static const int MAX_FRAME_SKIP = 2;
 
 ScreenManager::ScreenManager() :
   waiting_threads(),
+  m_menu_storage(new MenuStorage),
+  m_menu_manager(new MenuManager),
   running(),
   speed(1.0), 
   nextpop(false), 
@@ -64,47 +67,39 @@ ScreenManager::~ScreenManager()
   using namespace scripting;
   delete TimeScheduler::instance;
   TimeScheduler::instance = NULL;
-
-  for(std::vector<Screen*>::iterator i = screen_stack.begin();
-      i != screen_stack.end(); ++i) {
-    delete *i;
-  }
 }
 
 void
-ScreenManager::push_screen(Screen* screen, ScreenFade* screen_fade)
+ScreenManager::push_screen(std::unique_ptr<Screen> screen, std::unique_ptr<ScreenFade> screen_fade)
 {
-  this->next_screen.reset(screen);
-  this->screen_fade.reset(screen_fade);
+  assert(!this->next_screen);
+  this->next_screen = std::move(screen);
+  this->screen_fade = std::move(screen_fade);
   nextpush = !nextpop;
   nextpop = false;
   speed = 1.0f;
 }
 
 void
-ScreenManager::exit_screen(ScreenFade* screen_fade)
+ScreenManager::exit_screen(std::unique_ptr<ScreenFade> screen_fade)
 {
-  next_screen.reset(NULL);
-  this->screen_fade.reset(screen_fade);
+  next_screen.reset();
+  this->screen_fade = std::move(screen_fade);
   nextpop = true;
   nextpush = false;
 }
 
 void
-ScreenManager::set_screen_fade(ScreenFade* screen_fade)
+ScreenManager::set_screen_fade(std::unique_ptr<ScreenFade> screen_fade)
 {
-  this->screen_fade.reset(screen_fade);
+  this->screen_fade = std::move(screen_fade);
 }
 
 void
-ScreenManager::quit(ScreenFade* screen_fade)
+ScreenManager::quit(std::unique_ptr<ScreenFade> screen_fade)
 {
-  for(std::vector<Screen*>::iterator i = screen_stack.begin();
-      i != screen_stack.end(); ++i)
-    delete *i;
   screen_stack.clear();
-
-  exit_screen(screen_fade);
+  exit_screen(std::move(screen_fade));
 }
 
 void
@@ -144,8 +139,8 @@ ScreenManager::draw(DrawingContext& context)
   static int frame_count = 0;
 
   current_screen->draw(context);
-  if(MenuManager::current() != NULL)
-    MenuManager::current()->draw(context);
+  if(MenuManager::instance().current() != NULL)
+    MenuManager::instance().current()->draw(context);
   if(screen_fade.get() != NULL)
     screen_fade->draw(context);
   Console::instance->draw(context);
@@ -180,8 +175,8 @@ ScreenManager::update_gamelogic(float elapsed_time)
   scripting::update_debugger();
   scripting::TimeScheduler::instance->update(game_time);
   current_screen->update(elapsed_time);
-  if (MenuManager::current() != NULL)
-    MenuManager::current()->update();
+  if (MenuManager::instance().current() != NULL)
+    MenuManager::instance().current()->update();
   if(screen_fade.get() != NULL)
     screen_fade->update(elapsed_time);
   Console::instance->update(elapsed_time);
@@ -190,14 +185,14 @@ ScreenManager::update_gamelogic(float elapsed_time)
 void
 ScreenManager::process_events()
 {
-  g_jk_controller->update();
+  g_input_manager->update();
   SDL_Event event;
   while(SDL_PollEvent(&event)) 
   {
-    g_jk_controller->process_event(event);
+    g_input_manager->process_event(event);
 
-    if(MenuManager::current() != NULL)
-      MenuManager::current()->event(event);
+    if(MenuManager::instance().current() != NULL)
+      MenuManager::instance().current()->event(event);
 
     switch(event.type)
     {
@@ -211,7 +206,7 @@ ScreenManager::process_events()
           case SDL_WINDOWEVENT_RESIZED:
             Renderer::instance()->resize(event.window.data1,
                                          event.window.data2);
-            MenuManager::recalc_pos();
+            MenuManager::instance().recalc_pos();
             break;
         }
         break;
@@ -225,7 +220,7 @@ ScreenManager::process_events()
         {
           g_config->use_fullscreen = !g_config->use_fullscreen;
           Renderer::instance()->apply_config();
-          MenuManager::recalc_pos();
+          MenuManager::instance().recalc_pos();
         }
         else if (event.key.keysym.sym == SDLK_PRINTSCREEN ||
                  event.key.keysym.sym == SDLK_F12)
@@ -247,9 +242,10 @@ ScreenManager::process_events()
 void
 ScreenManager::handle_screen_switch()
 {
-  while( (next_screen.get() != NULL || nextpop) &&
-         has_no_pending_fadeout()) {
-    if(current_screen.get() != NULL) {
+  while((next_screen || nextpop) &&
+        has_no_pending_fadeout())
+  {
+    if(current_screen) {
       current_screen->leave();
     }
 
@@ -258,22 +254,20 @@ ScreenManager::handle_screen_switch()
         running = false;
         break;
       }
-      next_screen.reset(screen_stack.back());
+      next_screen = std::move(screen_stack.back());
       screen_stack.pop_back();
     }
-    if(nextpush && current_screen.get() != NULL) {
-      screen_stack.push_back(current_screen.release());
+    if(nextpush && current_screen) {
+      screen_stack.push_back(std::move(current_screen));
     }
 
     nextpush = false;
     nextpop = false;
     speed = 1.0;
-    Screen* next_screen_ptr = next_screen.release();
-    next_screen.reset(0);
-    if(next_screen_ptr)
-      next_screen_ptr->setup();
-    current_screen.reset(next_screen_ptr);
-    screen_fade.reset(NULL);
+    current_screen = std::move(next_screen);
+    if(current_screen)
+      current_screen->setup();
+    screen_fade.reset();
 
     waiting_threads.wakeup();
   }
@@ -289,7 +283,7 @@ ScreenManager::run(DrawingContext &context)
   while(running) {
 
     handle_screen_switch();
-    if(!running || current_screen.get() == NULL)
+    if(!running || !current_screen)
       break;
 
     Uint32 ticks = SDL_GetTicks();