Hosting courtesy of Sourceforge

               

---

MenuManager.h

Go to the documentation of this file.

//
//                                 MenuManager.h
//                             -------------------
//    begin                : Tue May 14 2002
//    copyright            : (C) 2002 by Rob Renaud
//    email                : rrenaud@eden.rutgers.edu
//
//   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 2 of the License, or
//   (at your option) any later version.
//

#ifndef MENU_MANAGER_H_
#define MENU_MANAGER_H_

#include "../Config.h"
#include "SDL.h"
#ifdef HAVE_SDL_TTF
#include "SDL_ttf.h"
#endif

#include <vector>
#include <string>
#include <map>

namespace Menu {
#ifdef HAVE_SDL_TTF

        const int DEFAULT_FONT_SIZE=24;
        const int TEXT_CENTER_X=200;
        const int TITLE_OFFSET_FROM_TOP=50;
        const int VERTICAL_SPACING=DEFAULT_FONT_SIZE/2;
        const int INPUT_HORIZ_SPACE=DEFAULT_FONT_SIZE*6;

        const char DEFAULT_FONT[]="GameData/Fonts/bboron.ttf";
        const SDL_Color DEFAULT_SELECTED_COL = {255, 0, 0, 0};
        const SDL_Color DEFAULT_DESELECTED_COL = {0, 255, 0, 0};
        const SDL_Color DEFAULT_ACTIVE_COL = {255, 255, 255, 0};
        const SDL_Color DEFAULT_BG_COL = {0, 0, 0, 0};

        enum MenuHandleResult {
                MENU_QUIT,                      
                EVENT_HANDLED,          
                EVENT_PASSED            
        };

        class MenuItem {
        public:
                virtual MenuHandleResult handleEvent(SDL_Event* e)=0;
                virtual void draw(SDL_Surface* surf, TTF_Font* font, int centerX, int centerY)=0;

                virtual void select()=0;
                
                virtual void deselect()=0;

                virtual ~MenuItem() { }
        };

        class DefaultMenuItem : public MenuItem {
        public:
                virtual void select();
                virtual void deselect();
                virtual ~DefaultMenuItem() { }
                void draw(SDL_Surface* surf, TTF_Font* font, int centerX, int centerY);
        protected:
                DefaultMenuItem(const std::string& name,
                                        const SDL_Color& selected=DEFAULT_SELECTED_COL,
                                        const SDL_Color& unselected=DEFAULT_DESELECTED_COL);
                virtual const SDL_Color& getCurrentColor();
        private:
                std::string name;
                SDL_Color selectedColor;
                SDL_Color deselectedColor;
                bool isSelected;
        };

        class MenuManager {
        public:
                MenuManager(const std::string& title, const SDL_Color& titleCol, const SDL_Color& bg=DEFAULT_BG_COL);

                bool run(SDL_Surface* screen);
                
                void addMenuItem(MenuItem* item);

                ~MenuManager();
        private:
                std::string title;      
                int fontSize;           
                TTF_Font* font;
                SDL_Color titleCol;
                SDL_Color bgCol;
                std::vector<MenuItem*> itemVec;
                size_t currentSelection;
        };

        /* MenuItem that toggles message between enabled/disabled, used to determine whether an option should be on/off */
        class BooleanItem : public DefaultMenuItem {
        public:
                BooleanItem(const std::string& name, bool& b,
                const SDL_Color& sel=DEFAULT_SELECTED_COL, const SDL_Color& unsel=DEFAULT_DESELECTED_COL);
                MenuHandleResult handleEvent(SDL_Event* e);
                void draw(SDL_Surface* surf, TTF_Font* font, int centerX, int centerY);
        private:
                bool& optionEnabled;
        };

        class GotoSubMenu : public DefaultMenuItem {
        public:
                GotoSubMenu(const std::string& title, MenuManager& m, SDL_Surface* screen,
                                const SDL_Color& selCol=DEFAULT_SELECTED_COL,
                                const SDL_Color& nonSelCol=DEFAULT_DESELECTED_COL);
                MenuHandleResult handleEvent(SDL_Event* e);
        private:
                MenuManager& menu;
                SDL_Surface* screen;
        };

        class InputGetter : public DefaultMenuItem {
        public:
                MenuHandleResult handleEvent(SDL_Event* e);
        protected:
                InputGetter(const std::string& name,
                                        const SDL_Color& selectedCol=DEFAULT_SELECTED_COL,
                                        const SDL_Color& unselectedCol=DEFAULT_DESELECTED_COL,
                                        const SDL_Color& activeCol=DEFAULT_ACTIVE_COL);
                const SDL_Color& getCurrentColor();
                bool isActive() { return active; }
        private:
                SDL_Color activeCol;
                bool active;
        };      

        class KeyInputter : public InputGetter {
        public:
                KeyInputter(const std::string& name, SDLKey& key,
                                        const SDL_Color& selected=DEFAULT_SELECTED_COL,
                                        const SDL_Color& unselected=DEFAULT_DESELECTED_COL,
                                        const SDL_Color& active=DEFAULT_ACTIVE_COL);
                MenuHandleResult handleEvent(SDL_Event* e);
                virtual void draw(SDL_Surface* surf, TTF_Font* font, int centerX, int centerY);
        private:
                SDLKey& key;
        };

        class IntInputter : public InputGetter {
        public:
                /*      @param i input integer to modify
                *       @param min minimum value for i
                *       @param max maximum value for i
                */
                IntInputter(const std::string& name, int& i, int min, int max,
                                        const SDL_Color& s=DEFAULT_SELECTED_COL,
                                        const SDL_Color& u=DEFAULT_DESELECTED_COL,
                                        const SDL_Color& a=DEFAULT_ACTIVE_COL);
                MenuHandleResult handleEvent(SDL_Event* e);
                
                virtual void draw(SDL_Surface* surf, TTF_Font* font, int centerX, int centerY);
        private:
                int& storageInt;
                int min;
                int max;
        };
#endif // ifdef HAVE_SDL_TTF

        typedef std::map<std::string, SDLKey> StringToKeyMap_t;
        typedef std::map<SDLKey, std::string> KeyToStringMap_t;

        class KeyMapContainer {
        public:
                static const StringToKeyMap_t& getStringToKeyMap();
                static const KeyToStringMap_t& getKeyToStringMap();
        private:
                static void init();
                static void addPair(const std::string& s, const SDLKey& k );
                static bool initialized;
                static KeyToStringMap_t keyStringMap;
                static StringToKeyMap_t stringKeyMap;
        };
};

#endif // ifndef MENU_MANAGER_H_

---