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 "guiSkin.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, bool scale=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 bool getSpriteScale(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 && Scale == other.Scale;
        }
 
        s32 Index = -1;
        video::SColor Color;
        bool Loop = false;
        bool Scale = 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
};