Pressable.hpp

/*
 * Pressable.hpp
 *
 *  Created on: 21.04.2017
 *      Author: jakub
 */

#ifndef PRESSABLE_HPP_
#define PRESSABLE_HPP_

#include <functional>
#include <SFML/Graphics.hpp>
#include "HaveHover.hpp"
#include "HavePressed.hpp"
#include "HaveVisible.hpp"
#include "HaveFocus.hpp"
#include "HaveSelected.hpp"
#include "HaveGUIManagerInfo.hpp"
#include "FocusAction.hpp"

#include "TextInputable.hpp"

class Dialog;

namespace ActionType {
    namespace Press {
        const char* const hold = "holdpress";
        const char* const click= "clickpress";
        const char* const gain = "gainpress";
        const char* const lost = "lostpress";
    }

    namespace PressAlt {
        const char* const hold = "holdpressalt";
        const char* const click= "clickpressalt";
        const char* const gain = "gainpressalt";
        const char* const lost = "lostpressalt";
    }
}

template <typename T>
class Pressable :
    public FocusAction<T>,
    public HavePressed,
    public HaveSelected,
    public HaveGUIManagerInfo {
public:
    Pressable():
        HavePressed(this->getColorProvider()),
        HaveSelected(this->getColorProvider()),
        hotKey(sf::Keyboard::Unknown),
        hotPress(false),
        stickyPress(false),
        ignoreAbove(false),
        ignoreDialogs(false),
        ignoreTextInputable(false)
    {}

    virtual bool setPressed(bool pressed) {
        if(stickyPress && pressed) {
            this->setFocus(true);
        }

        if((this->hover || hotPress) && this->pressed && !pressed) {
            hotPress = false;
            this->setFocus(true);
            this->doAction(ActionType::Press::click);
            this->pressed = pressed;
            return true;
        }
        this->pressed = pressed;
        return false;
    }

    virtual bool setPressedAlt(bool pressed) {
        if(stickyPress && pressed) {
            this->setFocus(true);
        }

        if(this->hover && this->pressedAlt && !pressed) {
            this->setFocus(true);
            this->doAction(ActionType::PressAlt::click);
            this->pressedAlt = pressed;
            return true;
        }
        this->pressedAlt = pressed;
        return false;
    }

    sf::Keyboard::Key getHotKey() const {
        return hotKey;
    }

    void setHotKey(sf::Keyboard::Key hotKey) {
        this->hotKey = hotKey;
    }

    virtual bool update(sf::Vector2f mp = sf::Vector2f(0.f,0.f), bool pressLeft = false, bool pressRight = false, bool aboveHover = false) {
        FocusAction<T>::update(mp, pressLeft, pressRight, aboveHover);

        bool lastPressed = pressed;
        bool lastPressedAlt = pressedAlt;
        bool hp = false;

        if(aboveHover && ((!ignoreAbove && !stickyPress) || (!ignoreDialogs && anyDialogExist()))) {
            pressed = false;
            pressedAlt = false;
            if(lastPressed) {
                this->doAction(ActionType::Press::lost);
            }
            if(lastPressedAlt) {
                this->doAction(ActionType::PressAlt::lost);
            }
            lastPressLeft = pressLeft;
            lastPressRight = pressRight;
            return true;
        }

        if(hotKey != sf::Keyboard::Unknown) {
            hp = sf::Keyboard::isKeyPressed(hotKey);
            if(hp && !ignoreTextInputable && TextInputable::isFocused()) {
                hp = false;
            }

            if(hp) {
                hotPress = true;
                this->hover = true;
                setPressed(true);
            } else {
                if(hotPress && !pressLeft)
                    setPressed(false);
                hotPress = false;
            }
        }

        if(!hp) {
            if(stickyPress) {
                if(this->visible) {
                    if(pressLeft && pressed && this->lastFocus == this) {
                        setPressed(true);
                        this->hover = true;
                    } else if(this->hover && pressLeft && (!lastPressLeft || pressed)) {
                        setPressed(true);
                    } else {
                        setPressed(false);
                    }

                    if(pressRight && pressedAlt && this->lastFocus == this) {
                        setPressedAlt(true);
                        this->hover = true;
                    } else if(this->hover && pressRight && (!lastPressRight || pressedAlt)) {
                        setPressedAlt(true);
                    } else {
                        setPressedAlt(false);
                    }
                } else {
                    setPressed(false);
                    setPressedAlt(false);
                }
            } else {
                if(this->visible && this->hover) {
                    if(pressLeft && (!lastPressLeft || pressed)) {
                        setPressed(true);
                    } else {
                        setPressed(false);
                    }
                    if(pressRight && (!lastPressRight || pressedAlt)) {
                        setPressedAlt(true);
                    } else {
                        setPressedAlt(false);
                    }
                } else {
                    setPressed(false);
                    setPressedAlt(false);
                }
            }
        }

        if(lastPressed) {
            if(pressed) {
                this->doAction(ActionType::Press::hold);
            } else {
                this->doAction(ActionType::Press::lost);
            }
        } else {
            if(pressed) {
                this->doAction(ActionType::Press::gain);
            }
        }

        if(lastPressedAlt) {
            if(pressedAlt) {
                this->doAction(ActionType::PressAlt::hold);
            } else {
                this->doAction(ActionType::PressAlt::lost);
            }
        } else {
            if(pressedAlt) {
                this->doAction(ActionType::PressAlt::gain);
            }
        }

        lastPressLeft = pressLeft;
        return this->hover;
    }

    void setStickyPress(bool stickyPress) {
        this->stickyPress = stickyPress;
    }

    void setIgnoreAbove(bool value) {
        ignoreAbove = value;
    }

    void setIgnoreDialogs(bool value) {
        ignoreDialogs = value;
    }

    void setIgnoreTextInputable(bool value) {
        ignoreTextInputable = value;
    }


protected:
    sf::Keyboard::Key hotKey;
    bool hotPress;
    bool stickyPress;

    bool ignoreAbove;
    bool ignoreDialogs;
    bool ignoreTextInputable;

};



#endif /* PRESSABLE_HPP_ */