dynamic_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_RIBBONGRID_HPP
#define HEADER_RIBBONGRID_HPP
 
#include <irrString.h>
 
#include <algorithm>
 
#include "guiengine/widget.hpp"
#include "guiengine/widgets/ribbon_widget.hpp"
#include "utils/leak_check.hpp"
#include "utils/ptr_vector.hpp"
 
namespace GUIEngine
{
    class IconButtonWidget;
 
    class DynamicRibbonHoverListener
    {
    public:
        virtual ~DynamicRibbonHoverListener() {}
        virtual void onSelectionChanged(DynamicRibbonWidget* theWidget,
                                       const std::string& selectionID,
                                       const irr::core::stringw& selectionText,
                                       const int playerID) = 0;
    };
 
    struct ItemDescription
    {
        irr::core::stringw m_user_name;
        std::string m_code_name;
        std::string m_sshot_file;
        IconButtonWidget::IconPathType m_image_path_type;
 
        bool m_animated;
        std::vector<std::string> m_all_images;
        float m_curr_time;
        float m_time_per_frame;
 
        unsigned int m_badges;
    };
 
    struct DynamicRibbonScrollCallback
    {
        void* data;
        void (*callback)(void* data);
    };
 
    class DynamicRibbonWidget : public Widget, public RibbonWidget::IRibbonListener
    {
        friend class RibbonWidget;
 
        PtrVector<DynamicRibbonHoverListener> m_hover_listeners;
 
        virtual ~DynamicRibbonWidget();
 
        bool m_has_label;
        irr::gui::IGUIStaticText* m_label;
 
        int m_label_height;
 
        bool m_animated_contents;
 
        bool m_scrolling_enabled;
 
        int m_previous_item_count;
 
        std::vector<ItemDescription> m_items;
 
        int m_arrows_w;
 
        int m_scroll_offset;
 
        int m_child_width, m_child_height;
 
        int m_row_amount;
        int m_col_amount;
 
        float m_size_ratio;
 
        int m_needed_cols;
 
        bool m_multi_row;
 
        std::vector<int> m_ids;
 
        bool m_combo;
 
        /* reference pointers only, the actual instances are owned by m_children */
        IconButtonWidget* m_left_widget;
        IconButtonWidget* m_right_widget;
 
        RibbonWidget* getSelectedRibbon(const int playerID);
 
        RibbonWidget* getRowContaining(Widget* w);
 
        void updateLabel(RibbonWidget* from_this_ribbon=NULL);
 
        void propagateSelection();
 
        EventPropagation focused(const int playerID);
 
        float estimateRowScore(const int rowCount, const int width, const int height,
                              const float iconAspectRatio, const int maxIcons, float* heightRatio,
                              float capSize = 0.5f);
 
        void buildInternalStructure();
 
        void scroll(int x_delta, bool evenIfDeactivated = false);
 
        int m_selected_item[MAX_PLAYER_COUNT];
 
        virtual void add();
        virtual EventPropagation mouseHovered(Widget* child, const int playerID);
        virtual EventPropagation transmitEvent(Widget* w, const std::string& originator, const int playerID);
 
        bool findItemInRows(const char* name, int* p_row, int* p_id);
 
        int m_item_count_hint;
 
        float getFontScale(int icon_width) const;
        void setLabelSize(const irr::core::stringw& text);
        irr::core::stringw getUserName(const irr::core::stringw& user_name) const;
 
        void updateForResizing();
        irr::gui::ScalableFont* m_font;
 
        int m_max_label_width;
 
        unsigned int m_max_label_length;
 
        DynamicRibbonScrollCallback m_scroll_callback;
    public:
 
        LEAK_CHECK()
 
        
        DynamicRibbonWidget(const bool combo, const bool multi_row);
 
        PtrVector<RibbonWidget, REF> m_rows;
 
        void addItem( const irr::core::stringw& user_name, const std::string& code_name,
                      const std::string& image_file, const unsigned int badge=0,
                      IconButtonWidget::IconPathType image_path_type=IconButtonWidget::ICON_PATH_TYPE_RELATIVE);
 
        void addAnimatedItem( const irr::core::stringw& user_name, const std::string& code_name,
                             const std::vector<std::string>& image_files, const float time_per_frame,
                             const unsigned int badge=0,
                             IconButtonWidget::IconPathType image_path_type=IconButtonWidget::ICON_PATH_TYPE_RELATIVE);
 
        void clearItems();
        void setBadge(const std::string &name, BadgeType badge);
 
        template<typename Compare>
        void sortItems(Compare comp)
        {
            std::sort(m_items.begin(), m_items.end(), comp);
        }
 
        void registerHoverListener(DynamicRibbonHoverListener* listener);
 
        EventPropagation rightPressed(const int playerID);
 
        EventPropagation leftPressed(const int playerID);
 
        void updateItemDisplay();
 
        const std::string& getSelectionIDString(const int playerID);
 
        irr::core::stringw getSelectionText(const int playerID);
 
        const std::vector<ItemDescription>& getItems() const { return m_items; }
 
        bool setSelection(int item_id, const int playerID, const bool focusIt, bool evenIfDeactivated=false);
 
        bool setSelection(const std::string &item_codename,
                          const int playerID, const bool focusIt,
                          bool evenIfDeactivated=false);
 
        virtual void elementRemoved();
 
        virtual void onRibbonWidgetScroll(const int delta_x);
 
        virtual void onRibbonWidgetFocus(RibbonWidget* emitter, const int playerID);
 
        virtual void onSelectionChange(){}
 
        virtual void setText(const irr::core::stringw& text);
 
        virtual void update(float delta);
 
        virtual void resize();
 
        void setItemCountHint(int hint) { m_item_count_hint = hint; }
 
        void setMaxLabelLength(int length) { m_max_label_length = length; }
 
        void registerScrollCallback(void (*callback)(void* data), void* data)
        { 
            m_scroll_callback.callback = callback; 
            m_scroll_callback.data = data;
        }
    };
 
}
 
#endif