ribbon_widget.hpp

//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2009-2015 Marianne Gagnon
//
//  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 HEADER_RIBBON_HPP
#define HEADER_RIBBON_HPP
 
#include <irrString.h>
 
#include "guiengine/widget.hpp"
#include "guiengine/widgets/icon_button_widget.hpp"
#include "utils/cpp2011.hpp"
#include "utils/leak_check.hpp"
#include "utils/ptr_vector.hpp"
 
#include <map>
 
namespace irr
{
    namespace gui { class IGUIButton; class IGUIStaticText; }
}
 
 
namespace GUIEngine
{
    enum RibbonType
    {
        RIBBON_COMBO,   
        RIBBON_TOOLBAR, 
        RIBBON_TABS,    
        RIBBON_VERTICAL_TABS 
    };
    
    enum RibbonFlip
    {
        FLIP_NO, // For non-tab ribbons
        FLIP_UP_LEFT, // For horizontal tabs it goes up vertical ones it goes left
        FLIP_DOWN_RIGHT // For horizontal tabs it goes down vertical ones it goes right
    };
 
    class RibbonWidget : public Widget
    {
    public:
        class IRibbonListener
        {
        public:
            virtual ~IRibbonListener(){}
            virtual void onRibbonWidgetScroll(const int delta_x) = 0;
            virtual void onRibbonWidgetFocus(RibbonWidget* emitter,
                                             const int playerID) = 0;
            virtual void onSelectionChange() = 0;
        };
        
    private:
        friend class DynamicRibbonWidget;
        friend class EventHandler;
        
        int m_selection[MAX_PLAYER_COUNT];
        
        RibbonType m_ribbon_type;
        
        RibbonFlip m_ribbon_flip;
                
        void updateSelection();
 
        virtual EventPropagation rightPressed(const int playerID=0) OVERRIDE;
        virtual EventPropagation leftPressed (const int playerID=0) OVERRIDE;
        virtual EventPropagation upPressed   (const int playerID=0) OVERRIDE;
        virtual EventPropagation downPressed (const int playerID=0) OVERRIDE;
        EventPropagation moveToNextItem(const bool horizontally, const bool reverse, const int playerID);
        EventPropagation propagationType(const bool horizontally);
        void selectNextActiveWidget(const bool horizontally, const bool reverse,
                                    const int playerID, const int old_selection);
        virtual EventPropagation mouseHovered(Widget* child,
                                              const int playerID) OVERRIDE;
        virtual EventPropagation transmitEvent(Widget* w,
                                               const std::string& originator,
                                               const int playerID=0) OVERRIDE;
        virtual EventPropagation focused(const int playerID) OVERRIDE;
        virtual void unfocused(const int playerID, Widget* new_focus) OVERRIDE;
        
        virtual EventPropagation onClick() OVERRIDE;
        
        PtrVector<irr::gui::IGUIStaticText, REF> m_labels;
        
        IRibbonListener* m_listener;
        PtrVector<Widget> m_active_children;
        std::map<int, std::pair<irr::gui::IGUIStaticText*, irr::gui::IGUIButton*> > m_child_data;
    public:
        
        LEAK_CHECK()
        
        static const char NO_ITEM_ID[];
        
        Widget* m_mouse_focus;
        
        RibbonWidget(const RibbonType type=RIBBON_COMBO);
        virtual ~RibbonWidget();
        
        virtual void add() OVERRIDE;
 
        void setListener(IRibbonListener* listener) { m_listener = listener; }
        // --------------------------------------------------------------------
        RibbonType getRibbonType() const { return m_ribbon_type; }
        // --------------------------------------------------------------------
        RibbonFlip getRibbonFlip() const { return m_ribbon_flip; }
        // --------------------------------------------------------------------
        int getActiveChildrenNumber(const int playerID) const
                                              { return m_active_children.size(); }
        // --------------------------------------------------------------------
        int getSelection(const int playerID) const
                                              { return m_selection[playerID]; }
        // --------------------------------------------------------------------
        const std::string& getSelectionIDString(const int playerID);
        // --------------------------------------------------------------------
        irr::core::stringw getSelectionText(const int playerID)
        {
            const int selection = m_selection[playerID];
            if (selection < 0 || selection >= int(m_children.size())) return "";
            return m_children[selection].m_text;
        }
        // --------------------------------------------------------------------
 
        void setSelection(const int i, const int playerID)
                             { m_selection[playerID] = i; updateSelection(); }
 
        void setFirstSelection(const int playerID, bool reverse_order = false);
 
        void setLastSelection(const int playerID)
                             { setFirstSelection(playerID, true); }
        
        void select(std::string item, const int playerID);
        
        void setLabel(const unsigned int id, irr::core::stringw new_name);
        
        void setItemVisible(const unsigned int id, bool visible);
        
        void setFlip(RibbonFlip direction);
 
        int findItemNamed(const char* internalName);
        
        GUIEngine::Widget * findWidgetNamed(const char* interalName);
 
        void addTextChild(const core::stringw& text, const std::string &id);
        
        
        void addIconChild(const core::stringw& text, const std::string &id,
                          const int w, const int h, const std::string &icon,
                          const IconButtonWidget::IconPathType iconPathType=
                                    IconButtonWidget::ICON_PATH_TYPE_RELATIVE);
    
        void clearAllChildren();
        
        void removeChildNamed(const char* name);
        
        PtrVector<Widget>& getRibbonChildren() { return m_children; }
 
        virtual EventPropagation onActivationInput(const int playerID) OVERRIDE;
 
        virtual void resize() OVERRIDE;
    };
 
}
 
#endif