spinner_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_SPINNER_HPP
#define HEADER_SPINNER_HPP
 
#include <irrString.h>
#include <functional>
namespace irr
{
    namespace video { class ITexture; }
    namespace gui { class IGUIImage; }
}
 
#include "guiengine/widget.hpp"
#include "utils/leak_check.hpp"
#include "utils/ptr_vector.hpp"
 
#include <rect.h>
 
namespace GUIEngine
{
    
    class SpinnerWidget : public Widget
    {
    public:
        class ISpinnerConfirmListener
        {
        public:
            virtual ~ISpinnerConfirmListener() {}
            
            virtual EventPropagation onSpinnerConfirmed() = 0;
        };
        
    private:
        std::function<void(SpinnerWidget* spinner)> m_value_updated_callback;
        ISpinnerConfirmListener* m_listener;
        
        int m_value, m_min, m_max;
        float m_step;
 
        bool m_incorrect;
        irr::gui::IGUIImage* m_red_mark_widget;
        
        int m_spinner_widget_player_id;
        bool m_use_background_color;
        
        std::vector<irr::core::stringw> m_labels;
        
        bool m_graphical;
        
        bool m_gauge;
    
    
        bool m_wrap_around;
 
        bool m_color_slider;
 
        bool m_left_selected;
 
        bool m_right_selected;
 
        core::rect<s32> m_left_arrow;
 
        core::stringw m_custom_text;
        
        virtual EventPropagation transmitEvent(Widget* w,
                                               const std::string& originator,
                                               const int playerID);
        
        virtual EventPropagation rightPressed(const int playerID);
        
        virtual EventPropagation leftPressed(const int playerID);
        
        virtual int getWidthNeededAroundLabel()  const { return 25; }
        
        virtual int getHeightNeededAroundLabel() const { return 8; }
        
        irr::video::ITexture* getTexture();
 
        void resizeLabel();
       
    public:
 
        LEAK_CHECK()
        
        SpinnerWidget(const bool gauge=false);
        virtual ~SpinnerWidget() {}
        virtual void resize();
 
        void addLabel(irr::core::stringw label);
        void clearLabels();
 
    // next four functions are for background colour behind playername in multikart screen selection
        void setUseBackgroundColor()                { m_use_background_color=true;         }
        bool getUseBackgroundColor() const          { return m_use_background_color;       }
        void setSpinnerWidgetPlayerID(int playerID) { m_spinner_widget_player_id=playerID; }
        int getSpinnerWidgetPlayerID() const        { return m_spinner_widget_player_id;   }
        void unsetUseBackgroundColor()              { m_use_background_color=false;        }
 
        void activateSelectedButton();
        void setSelectedButton(bool right)
        {
            if (right)
            {
                m_left_selected = false;
                m_right_selected = true;
            }
            else
            {
                m_left_selected = true;
                m_right_selected = false;
            }
        }
        void clearSelected()
        {
            m_left_selected = false;
            m_right_selected = false;
        }
        bool isButtonSelected(bool right)
        {
            if (right && m_right_selected)
                return true;
            else if (!right && m_left_selected)
                return true;
            return false;
        }
 
        void setListener(ISpinnerConfirmListener* listener) { m_listener = listener; }
 
        virtual void add();
 
        void setValue(const int new_value);
 
        void setFloatValue(const float new_value) { setValue(int(round(new_value/m_step))); }
        
        void setValue(irr::core::stringw new_value);
        
        bool isGauge()  const { return m_gauge; }
 
        bool isColorSlider()  const { return m_color_slider; }
 
        int  getValue() const { return m_value; }
 
        float getFloatValue() const { return m_value*m_step; }
        
        irr::core::stringw getStringValue() const;
 
        irr::core::stringw getStringValueFromID(unsigned id) const
        {
            if (id > m_labels.size())
                return L"";
            return m_labels[id];
        }
 
        // --------------------------------------------------------------------
        float  getStep()  const { return m_step; }
        // --------------------------------------------------------------------
        void setStep(float n) { m_step = n; }
        // --------------------------------------------------------------------
        // --------------------------------------------------------------------
        int  getMax()  const { return m_max;   }
        // --------------------------------------------------------------------
        void setMax(int n)
        {
            m_max = n;
            if(getValue()>m_max) setValue(m_max);
        }   // setMax
        // --------------------------------------------------------------------
        int  getMin()   const { return m_min;   }
        // --------------------------------------------------------------------
        void setMin(int n)
        {
            m_min = n;
            if(getValue()<m_min) setValue(m_min);
        }   // setMin
 
        core::rect<s32> getLeftArrow() const { return m_left_arrow; }
 
        // ------------------------------------------------------------------------
        void markAsIncorrect();
        // ------------------------------------------------------------------------
        void markAsCorrect();
        
        // --------------------------------------------------------------------
        virtual void setActive(bool active = true);
 
        void setCustomText(const core::stringw& text);
        const core::stringw& getCustomText() const { return m_custom_text; }
 
        /* Set a spinner with numeric values min <= i <= max, with a precision of defined by step */
        void setRange(float min, float max, float step);
        void setRange(int min, int max) { setRange(min, max, 1.0); }
 
        void onPressed(int x, int y);
        void doValueUpdatedCallback()
        {
            if (m_value_updated_callback)
                m_value_updated_callback(this);
        }
        void setValueUpdatedCallback(
            std::function<void(SpinnerWidget* spinner)> callback)
        {
            m_value_updated_callback = callback;
        }
        virtual void elementRemoved()
        {
            m_incorrect = false;
            m_red_mark_widget = NULL;
            Widget::elementRemoved();
        }
 
    };
 
}
 
#endif