list_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_LISTWIDGET_HPP
#define HEADER_LISTWIDGET_HPP
 
#include <irrString.h>
 
#include "guiengine/widgets/CGUISTKListBox.hpp"
#include "guiengine/widget.hpp"
#include "utils/leak_check.hpp"
#include "utils/ptr_vector.hpp"
#include "IGUIElement.h"
 
 
namespace irr { namespace gui { class STKModifiedSpriteBank; } }
 
namespace GUIEngine
{
    class IListWidgetHeaderListener
    {
    public:
        virtual ~IListWidgetHeaderListener(){}
        
        virtual void onColumnClicked(int column_id, bool sort_desc, bool sort_default) = 0;
    };
    
    class ListWidget : public Widget
    {
        friend class Skin;
        
        bool m_use_icons;
        
        irr::gui::STKModifiedSpriteBank* m_icons;
                
        PtrVector< Widget > m_header_elements;
        
        Widget* m_selected_column;
        
        bool m_sort_desc;
        
        bool m_sort_default;
        
        int m_sort_col;
 
        bool m_choosing_header;
 
        struct Column
        {
            irr::core::stringw m_text;
            int m_proportion;
            irr::video::ITexture* m_texture;
            Column(irr::core::stringw text, int proportion)
            {
                m_text = text;
                m_proportion = proportion;
                m_texture = NULL;
            }
            Column(irr::video::ITexture* texture, int proportion)
            {
                m_proportion = proportion;
                m_texture = texture;
            }
        };
        
        std::vector< Column > m_header;
        
        IListWidgetHeaderListener* m_listener;
 
        bool m_sortable;
 
        bool m_header_created;
 
        float m_icon_scale;
 
        void repairSortCol()
        {
            // Exclude scrollbar
            int max_size = (int)m_header_elements.size() - 1;
            if (m_sort_col < 0)
                m_sort_col = max_size - 1;
            else if (m_sort_col >= max_size)
                m_sort_col = 0;
        }
 
        void updateHeader();
        void updateIconScale();
        int getHeaderHeight() const;
        irr::core::rect<s32> getListBoxSize() const;
 
    public:
        typedef irr::gui::CGUISTKListBox::ListItem ListItem;
        typedef ListItem::ListCell ListCell;
        
        LEAK_CHECK()
        
        ListWidget();
        
        SkinWidgetContainer m_selection_skin_info;
                
        virtual void add();
        
        virtual void unfocused(const int playerID, Widget* new_focus);
        
        virtual void elementRemoved();
        
        void setIcons(irr::gui::STKModifiedSpriteBank* icons, float scale = -1.0f);
        
        
        // ---- contents management
        
        void addItem(   const std::string& internal_name,
                        const irr::core::stringw &name,
                        const int icon=-1,
                        bool center = false);
 
        void addItem(   const std::string& internal_name,
                        const std::vector<ListCell>& contents);
 
        void createHeader();
        
        void clear();
 
        void clearColumns();
        
        int getItemCount() const;
        
        int getSelectionID() const;
        
        std::string getSelectionInternalName();
        
        irr::core::stringw getSelectionLabel(const int cell = 0) const;
        
        void selectItemWithLabel(const irr::core::stringw& name);
        
        int getItemID(const std::string &internalName) const;
        
        void setSelectionID(const int index);
        
        void renameCell(const int row_num, const int col_num, 
                        const irr::core::stringw &newName, const int icon=-1);
        
        void renameItem(const int row_num, 
                        const irr::core::stringw &newName, const int icon=-1);
        void renameItem(const std::string  & internal_name, 
                        const irr::core::stringw &newName, const int icon=-1);
 
        void renameCell(const std::string internalName, const int col_num, 
                        const irr::core::stringw &newName, const int icon=-1)
        {
            const int id = getItemID(internalName);
            assert(id != -1);
            renameCell( id, col_num, newName, icon );
        }
        
        void markItemRed(const int id, bool red=true);
        void markItemBlue(const int id, bool blue=true);
        void emphasisItem(const int id, bool enable=true);
        
        void markItemRed(const std::string &internalName, bool red=true)
        {
            const int id = getItemID(internalName);
            assert(id != -1);
            markItemRed( id, red );
        }
 
        void markItemBlue(const std::string &internalName, bool blue=true)
        {
            const int id = getItemID(internalName);
            assert(id != -1);
            markItemBlue( id, blue );
        }
 
        void emphasisItem(const std::string &internalName, bool enable=true)
        {
            const int id = getItemID(internalName);
            assert(id != -1);
            emphasisItem(id, enable);
        }
 
        virtual EventPropagation transmitEvent(Widget* w,
                                               const std::string& originator,
                                               const int playerID);
 
        virtual EventPropagation upPressed(const int playerID);
        
        virtual EventPropagation downPressed(const int playerID);
 
        virtual EventPropagation leftPressed(const int playerID);
 
        virtual EventPropagation rightPressed(const int playerID);
 
        EventPropagation moveToNextItem(const bool down);
 
        /* Apply page up, page down, list end or list start effects */
        void pageMove(bool up);
        void listStart();
        void listEnd();
        
        void setColumnListener(IListWidgetHeaderListener* listener)
        {
            if (m_listener) delete m_listener;
            m_listener = listener;
        }
        
        void addColumn(irr::core::stringw col, int proportion=1) { m_header.push_back( Column(col, proportion) ); }
        void addColumn(irr::video::ITexture* tex, int proportion=1) { m_header.push_back( Column(tex, proportion) ); }
 
        void setSortable(bool sortable) { m_sortable = sortable; }
        void focusHeader(const NavigationDirection nav);
        virtual void setActive(bool active=true);
        virtual void resize();
    };
}
 
#endif