kart_selection.hpp

//  SuperTuxKart - a fun racing game with go-kart
//
//  Copyright (C) 2006-2015 SuperTuxKart-Team
//
//  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 3
//  of the License, or (at your option) any later version.
//
//  This program 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 General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef KART_SELECTION_INCLUDED
#define KART_SELECTION_INCLUDED
 
#include "guiengine/screen.hpp"
#include "guiengine/widgets/dynamic_ribbon_widget.hpp"
#include "guiengine/widgets/player_kart_widget.hpp"
#include "states_screens/state_manager.hpp"
 
namespace GUIEngine
{
    class Widget;
    class BubbleWidget;
    enum EventPropagation;
}
namespace Online
{
    class User;
    class OnlineProfile;
}
 
class FocusDispatcher;
class InputDevice;
class PlayerProfile;
class KartHoverListener;
 
extern int g_root_id;
 
class KartSelectionScreen : public GUIEngine::Screen
{
    friend class KartHoverListener;
    friend class PlayerNameSpinner;
    friend class FocusDispatcher;
protected:
    PtrVector<GUIEngine::PlayerKartWidget, REF> m_kart_widgets;
 
    friend class GUIEngine::ScreenSingleton<KartSelectionScreen>;
    friend class GUIEngine::PlayerKartWidget;
 
    bool m_multiplayer;
 
    bool m_from_overworld;
 
    bool m_go_to_overworld_next;
 
    bool m_must_delete_on_back; 
 
    bool m_game_master_confirmed;
 
    GUIEngine::PlayerKartWidget* m_removed_widget;
 
    GUIEngine::BubbleWidget* m_multiplayer_message;
 
    FocusDispatcher  *m_dispatcher;
 
    KartSelectionScreen(const char* filename);
 
    virtual void allPlayersDone();
 
    void renumberKarts();
 
    bool validateIdentChoices();
 
    bool validateKartChoices();
 
    void setKartsFromCurrentGroup();
 
    void playerConfirm(const int playerID);
 
    void updateKartStats(uint8_t widget_id,
                         const std::string& selection);
 
    void updateKartWidgetModel(int widget_id,
                const std::string& selection,
                const irr::core::stringw& selectionText,
                float kart_color);
 
    void addMultiplayerMessage();
 
    void removeMultiplayerMessage();
 
    virtual bool isIgnored(const std::string& ident) const { return false; }
 
    static KartSelectionScreen* m_instance_ptr;
private:
    PtrVector<const KartProperties, REF> getUsableKarts(
        const std::string& selected_kart_group);
    bool useContinueButton() const;
public:
    static KartSelectionScreen* getRunningInstance();
 
    virtual void loadedFromFile() OVERRIDE;
 
    void setMultiplayer(bool multiplayer);
 
    void setFromOverworld(bool from_overworld) { m_from_overworld = from_overworld; }
 
    void setGoToOverworldNext() { m_go_to_overworld_next = true; }
 
    bool joinPlayer(InputDevice* device, PlayerProfile* p);
 
    virtual bool playerQuit(StateManager::ActivePlayer* player);
 
    virtual void init() OVERRIDE;
 
    virtual void beforeAddingWidget() OVERRIDE;
 
    virtual void tearDown() OVERRIDE;
 
    virtual void eventCallback(GUIEngine::Widget* widget, const std::string& name,
                               const int playerID) OVERRIDE;
 
    virtual void onUpdate(float dt) OVERRIDE;
 
    virtual void unloaded() OVERRIDE;
 
    virtual bool onEscapePressed() OVERRIDE;
 
};   // KartSelectionScreen
 
 
class FocusDispatcher : public GUIEngine::Widget
{
protected:
    KartSelectionScreen* m_parent;
    int m_reserved_id;
 
    bool m_is_initialised;
 
public:
 
    LEAK_CHECK()
 
    // ------------------------------------------------------------------------
    FocusDispatcher(KartSelectionScreen* parent);
    // ------------------------------------------------------------------------
    void setRootID(const int reservedID);
 
    // ------------------------------------------------------------------------
    virtual void add();
 
    // ------------------------------------------------------------------------
 
    virtual GUIEngine::EventPropagation focused(const int playerID);
};   // FocusDispatcher
 
class KartHoverListener : public GUIEngine::DynamicRibbonHoverListener
{
    KartSelectionScreen* m_parent;
public:
    unsigned int m_magic_number;
 
    KartHoverListener(KartSelectionScreen* parent);
 
    // ------------------------------------------------------------------------
    virtual ~KartHoverListener();
 
    // ------------------------------------------------------------------------
    void onSelectionChanged(GUIEngine::DynamicRibbonWidget* theWidget,
                            const std::string& selectionID,
                            const irr::core::stringw& selectionText,
                            const int playerID);
};   // KartHoverListener
 
#endif