guiButton.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
 
#pragma once
 
#include <IGUIStaticText.h>
#include "irrlicht_changes/static_text.h"
#include "IGUIButton.h"
#include "IGUISpriteBank.h"
#include "ITexture.h"
#include "SColor.h"
#include "StyleSpec.h"
 
using namespace irr;
 
class ISimpleTextureSource;
 
class GUIButton : public gui::IGUIButton
{
public:
 
        GUIButton(gui::IGUIEnvironment* environment, gui::IGUIElement* parent,
                           s32 id, core::rect<s32> rectangle, ISimpleTextureSource *tsrc,
                           bool noclip=false);
 
        virtual ~GUIButton();
 
        virtual bool OnEvent(const SEvent& event) override;
 
        virtual void draw() override;
 
        virtual void setOverrideFont(gui::IGUIFont* font=0) override;
 
        virtual gui::IGUIFont* getOverrideFont() const override;
 
        virtual gui::IGUIFont* getActiveFont() const override;
 
        virtual void setOverrideColor(video::SColor color) override;
 
        virtual video::SColor getOverrideColor() const override;
 
        virtual video::SColor getActiveColor() const override;
 
        virtual void enableOverrideColor(bool enable) override;
 
        virtual bool isOverrideColorEnabled(void) const override;
 
        // PATCH
        virtual void setImage(gui::EGUI_BUTTON_IMAGE_STATE state,
                        video::ITexture* image=nullptr,
                        const core::rect<s32>& sourceRect=core::rect<s32>(0,0,0,0)) override;
 
        virtual void setImage(video::ITexture* image=nullptr) override;
 
        virtual void setImage(video::ITexture* image, const core::rect<s32>& pos) override;
 
        virtual void setPressedImage(video::ITexture* image=nullptr) override;
 
        virtual void setPressedImage(video::ITexture* image, const core::rect<s32>& pos) override;
 
        virtual void setText(const wchar_t* text) override;
        // END PATCH
 
        virtual void setSpriteBank(gui::IGUISpriteBank* bank=0) override;
 
 
        virtual void setSprite(gui::EGUI_BUTTON_STATE state, s32 index,
                                                   video::SColor color=video::SColor(255,255,255,255),
                                                   bool loop=false) override;
 
        virtual s32 getSpriteIndex(gui::EGUI_BUTTON_STATE state) const override;
 
        virtual video::SColor getSpriteColor(gui::EGUI_BUTTON_STATE state) const override;
 
        virtual bool getSpriteLoop(gui::EGUI_BUTTON_STATE state) const override;
 
        virtual void setIsPushButton(bool isPushButton=true) override;
 
        virtual bool isPushButton() const override;
 
        virtual void setPressed(bool pressed=true) override;
 
        virtual bool isPressed() const override;
 
        // PATCH
        bool isHovered() const;
 
        bool isFocused() const;
        // END PATCH
 
        virtual void setDrawBorder(bool border=true) override;
 
        virtual bool isDrawingBorder() const override;
 
        virtual void setUseAlphaChannel(bool useAlphaChannel=true) override;
 
        virtual bool isAlphaChannelUsed() const override;
 
        virtual void setScaleImage(bool scaleImage=true) override;
 
        virtual bool isScalingImage() const override;
 
        virtual bool getClickShiftState() const override
        {
                return ClickShiftState;
        }
 
        virtual bool getClickControlState() const override
        {
                return ClickControlState;
        }
 
        void setColor(video::SColor color);
        // PATCH
        void setFromState();
 
        virtual void setFromStyle(const StyleSpec& style);
 
        void setStyles(const std::array<StyleSpec, StyleSpec::NUM_STATES>& styles);
        // END PATCH
 
 
        static GUIButton* addButton(gui::IGUIEnvironment *environment,
                        const core::rect<s32>& rectangle, ISimpleTextureSource *tsrc,
                        IGUIElement* parent, s32 id, const wchar_t* text,
                        const wchar_t *tooltiptext=L"");
 
protected:
        void drawSprite(gui::EGUI_BUTTON_STATE state, u32 startTime, const core::position2di& center);
        gui::EGUI_BUTTON_IMAGE_STATE getImageState(bool pressed) const;
 
        ISimpleTextureSource *getTextureSource() { return TSrc; }
 
        struct ButtonImage
        {
                ButtonImage() = default;
 
                ButtonImage(const ButtonImage& other)
                {
                        *this = other;
                }
 
                ~ButtonImage()
                {
                        if ( Texture )
                                Texture->drop();
                }
 
                ButtonImage& operator=(const ButtonImage& other)
                {
                        if ( this == &other )
                                return *this;
 
                        if (other.Texture)
                                other.Texture->grab();
                        if ( Texture )
                                Texture->drop();
                        Texture = other.Texture;
                        SourceRect = other.SourceRect;
                        return *this;
                }
 
                bool operator==(const ButtonImage& other) const
                {
                        return Texture == other.Texture && SourceRect == other.SourceRect;
                }
 
 
                video::ITexture* Texture = nullptr;
                core::rect<s32> SourceRect = core::rect<s32>(0,0,0,0);
        };
 
        gui::EGUI_BUTTON_IMAGE_STATE getImageState(bool pressed, const ButtonImage* images) const;
 
private:
 
        struct ButtonSprite
        {
                bool operator==(const ButtonSprite &other) const
                {
                        return Index == other.Index && Color == other.Color && Loop == other.Loop;
                }
 
                s32 Index = -1;
                video::SColor Color;
                bool Loop = false;
        };
 
        ButtonSprite ButtonSprites[gui::EGBS_COUNT];
        gui::IGUISpriteBank* SpriteBank = nullptr;
 
        ButtonImage ButtonImages[gui::EGBIS_COUNT];
 
        std::array<StyleSpec, StyleSpec::NUM_STATES> Styles;
 
        gui::IGUIFont* OverrideFont = nullptr;
 
        bool OverrideColorEnabled = false;
        video::SColor OverrideColor = video::SColor(101,255,255,255);
 
        u32 ClickTime = 0;
        u32 HoverTime = 0;
        u32 FocusTime = 0;
 
        bool ClickShiftState = false;
        bool ClickControlState = false;
 
        bool IsPushButton = false;
        bool Pressed = false;
        bool UseAlphaChannel = false;
        bool DrawBorder = true;
        bool ScaleImage = false;
 
        video::SColor Colors[4];
        // PATCH
        bool WasHovered = false;
        bool WasFocused = false;
        ISimpleTextureSource *TSrc;
 
        gui::IGUIStaticText *StaticText;
 
        core::rect<s32> BgMiddle;
        core::rect<s32> Padding;
        core::vector2d<s32> ContentOffset;
        video::SColor BgColor = video::SColor(0xFF,0xFF,0xFF,0xFF);
        // END PATCH
};