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_WIDGET_HPP
#define HEADER_WIDGET_HPP
 
#include <irrString.h>
namespace irr
{
    namespace gui { class IGUIElement; }
}
#include <bitset>
#include <map>
 
#include "guiengine/event_handler.hpp"
#include "guiengine/skin.hpp"
#include "utils/constants.hpp"
#include "utils/ptr_vector.hpp"
 
namespace GUIEngine
{
 
    class DynamicRibbonWidget;
    class Screen;
 
    enum WidgetType
    {
        WTYPE_NONE = -1,
        WTYPE_RIBBON,
        WTYPE_SPINNER,
        WTYPE_BUTTON,
        WTYPE_ICON_BUTTON,
        WTYPE_CHECKBOX,
        WTYPE_LABEL,
        WTYPE_BUBBLE,
        WTYPE_SPACER,
        WTYPE_DIV,
        WTYPE_DYNAMIC_RIBBON,
        WTYPE_MODEL_VIEW,
        WTYPE_LIST,
        WTYPE_TEXTBOX,
        WTYPE_PROGRESS,
        WTYPE_RATINGBAR
    };
 
    enum BadgeType
    {
        LOCKED_BADGE   = 1,
        OK_BADGE       = 2,
        BAD_BADGE      = 4,
        TROPHY_BADGE   = 8,
        GAMEPAD_BADGE  = 16,
        KEYBOARD_BADGE = 32,
        LOADING_BADGE  = 64,
        ZIPPER_BADGE   = 128,
        ANCHOR_BADGE   = 256,
        DOWN_BADGE     = 512,
        HEART_BADGE    = 1024,
        REDDOT_BADGE   = 2048
    };
 
 
    enum Property
    {
        PROP_ID = 100,
        PROP_PROPORTION,
        PROP_WIDTH,
        PROP_HEIGHT,
        PROP_CHILD_WIDTH,
        PROP_CHILD_HEIGHT,
        PROP_WORD_WRAP,
        PROP_ALTERNATE_BG,
        PROP_LINE_HEIGHT,
        //PROP_GROW_WITH_TEXT, // yet unused
        PROP_X,
        PROP_Y,
        PROP_LAYOUT,
        PROP_ALIGN,
        // PROP_TEXT, // this one is a bit special, can't go along others since it's wide strings
        PROP_ICON,
        PROP_FOCUS_ICON,
        PROP_TEXT_ALIGN,
        PROP_TEXT_VALIGN,
        PROP_MIN_VALUE,
        PROP_MAX_VALUE,
        PROP_MAX_WIDTH,
        PROP_MAX_HEIGHT,
        PROP_SQUARE,
        PROP_EXTEND_LABEL,
        PROP_LABELS_LOCATION,
        PROP_MAX_ROWS,
        PROP_WRAP_AROUND,
        PROP_DIV_PADDING,
        PROP_KEEP_SELECTION,
        PROP_CUSTOM_RATIO,
        PROP_ICON_ALIGN,
        PROP_COLOR_SLIDER, // this one is used to identify if a gauge is used as the color slider
    };
 
    bool isWithinATextBox();
    void setWithinATextBox(bool in);
 
    class Widget : public SkinWidgetContainer
    {
    protected:
        unsigned int m_magic_number;
 
        // Used to limit event callback on this widget based on input type
        // At the moment used for continue button in kart selection
        std::bitset<Input::IT_LAST + 1> m_active_event_callback;
 
        // FIXME: find better ways than hackish "friend"?
        friend class EventHandler;
        friend class Screen;
        friend class Skin;
        friend class RibbonWidget;
        friend class SpinnerWidget;
        friend class ProgressBarWidget;
        friend class DynamicRibbonWidget;
        friend class LayoutManager;
        friend class ModalDialog;
        friend class AbstractTopLevelContainer;
 
        int m_absolute_x, m_absolute_y, m_absolute_w, m_absolute_h;
        int m_absolute_reverse_x, m_absolute_reverse_y;
        float m_relative_x, m_relative_y, m_relative_w, m_relative_h;
 
        irr::core::stringw m_text;
 
        bool m_title_font;
 
        bool m_selected[MAX_PLAYER_COUNT];
 
        bool m_check_inside_me;
 
        virtual EventPropagation rightPressed(const int playerID) { return EVENT_BLOCK; }
 
        virtual EventPropagation leftPressed (const int playerID) { return EVENT_BLOCK; }
 
        virtual EventPropagation upPressed(const int playerID) { return EVENT_BLOCK; }
 
        virtual EventPropagation downPressed(const int playerID) { return EVENT_BLOCK; }
 
        virtual EventPropagation mouseHovered(Widget* child, const int playerID) { return EVENT_BLOCK; }
 
        virtual EventPropagation focused(const int playerID) { setWithinATextBox(false); return EVENT_LET; }
 
        virtual void unfocused(const int playerID, Widget* new_focus) { }
 
        irr::gui::IGUIElement* m_parent;
 
        irr::gui::IGUIElement* m_element;
 
 
        int m_id;
 
        bool m_player_focus[MAX_PLAYER_COUNT];
 
        bool m_reserve_id;
 
        WidgetType m_type;
 
        PtrVector<Widget> m_children;
 
        int m_badges;
 
        bool m_deactivated;
 
        bool m_is_visible;
 
        bool m_focusable;
 
        bool m_bottom_bar;
        bool m_top_bar;
 
        int m_badge_x_shift;
 
        bool m_has_tooltip;
        irr::core::stringw m_tooltip_text;
 
        int m_uncollapsed_height;
 
        bool m_is_collapsed;
 
    public:
 
        Widget* m_event_handler;
 
        bool m_supports_multiplayer;
 
        int m_tab_down_root;
 
        int m_tab_up_root;
 
        int m_x, m_y, m_w, m_h;
 
        bool m_show_bounding_box;
 
        bool m_is_bounding_box_round;
 
        int m_reserved_id;
 
        std::map<Property, std::string> m_properties;
 
        Widget(WidgetType type, bool reserve_id = false);
        virtual ~Widget();
 
        virtual void setEventCallbackActive(Input::InputType type, bool active);
 
        virtual bool isEventCallbackActive(Input::InputType type) const;
 
        void setParent(irr::gui::IGUIElement* parent);
 
        virtual void setVisible(bool visible);
 
        virtual void setCollapsed(bool collapsed, Screen* calling_screen = NULL);
 
        virtual void setCollapsed(bool collapsed, int uncollapsed_height, Screen* calling_screen = NULL);
 
        bool isVisible() const;
 
        bool isCollapsed() const { return  m_is_collapsed; }
 
        bool isActivated() const;
 
        virtual EventPropagation onActivationInput(const int playerID) { return EVENT_LET; }
 
        void resetCoordinates();
 
        virtual void resize();
 
        virtual void move(const int x, const int y, const int w, const int h);
 
        bool isSelected(const int playerID) const { return m_selected[playerID]; }
        void setSelected(const int playerID, bool state) { m_selected[playerID] = state;}
 
        bool isBottomBar() const { return m_bottom_bar; }
        bool isTopBar   () const { return m_top_bar;    }
 
        virtual void setActive(bool active=true);
 
        template<typename T> T* getIrrlichtElement()
        {
        #if HAVE_RTT
            T* out = dynamic_cast<T*>(m_element);
            return out;
        #else
            return static_cast<T*>(m_element);
        #endif
        }
 
        template<typename T> const T* getIrrlichtElement() const
        {
            #if HAVE_RTT
                T* out = dynamic_cast<T*>(m_element);
                return out;
            #else
                return static_cast<T*>(m_element);
            #endif
        }
 
        irr::gui::IGUIElement* getIrrlichtElement() { return m_element; }
 
        void moveIrrlichtElement();
        bool isSameIrrlichtWidgetAs(const Widget* ref) const { return m_element == ref->m_element; }
 
        virtual void setText(const irr::core::stringw &s);
 
        const irr::core::stringw &getText() const {return m_text; }
 
        WidgetType getType() const { return m_type; }
 
        int getID() const { return m_id; }
 
        std::string getName() { return m_properties[PROP_ID]; }
 
        bool isFocusable() const { return m_focusable; }
 
        void setFocusable(bool f) { m_focusable = f; }
 
        void setFocusForPlayer(const int playerID);
 
        bool isFocusedForPlayer(const int playerID);
 
        void unsetFocusForPlayer(const int playerID);
 
        static void resetIDCounters();
 
        static int getNewID();
 
        static int getNewNoFocusID();
 
        static bool isFocusableId(const int id);
 
        const PtrVector<Widget>& getChildren() const { return m_children; }
 
        PtrVector<Widget>&       getChildren()       { return m_children; }
 
        bool deleteChild(const char* id);
 
        virtual void update(float delta) { }
 
        virtual EventPropagation transmitEvent(Widget* w,
                                               const std::string& originator,
                                               const int playerID)
                { return EVENT_LET; }
 
        virtual void add();
 
        virtual void elementRemoved();
 
        bool searchInsideMe() const { return m_check_inside_me; }
 
        virtual int getWidthNeededAroundLabel()  const { return 0; }
 
        virtual int getHeightNeededAroundLabel() const { return 0; }
 
        void setBadge(BadgeType badge_bit)
        {
            m_badges |= int(badge_bit);
        }
 
        void unsetBadge(BadgeType badge_bit)
        {
            m_badges &= (~int(badge_bit));
        }
 
        void resetAllBadges()
        {
            m_badges = 0;
        }
 
        int getBadges() const
        {
            return m_badges;
        }
 
        bool hasTooltip() const { return m_has_tooltip; }
 
        irr::core::stringw getTooltipText() const { return m_tooltip_text; }
 
        void setTooltip(irr::core::stringw s) { m_tooltip_text = s; m_has_tooltip = true; }
 
        bool ok() const { return (m_magic_number == 0xCAFEC001); }
 
        virtual EventPropagation onClick()  { return EVENT_LET; }
        virtual irr::core::dimension2di getDimension() const { return irr::core::dimension2di(m_w, m_h); }
    };
 
 
}
#endif