Action.h

Go to the documentation of this file.

// Action.h
//
// Copyright (c) 2013-2016 Michael Imamura.
//
// Licensed under GrokkSoft HoverRace SourceCode License v1.0(the "License");
// you may not use this file except in compliance with the License.
//
// A copy of the license should have been attached to the package from which
// you have taken this file. If you can not find the license you can not use
// this file.
//
//
// The author makes no representations about the suitability of
// this software for any purpose.  It is provided "as is" "AS IS",
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied.
//
// See the License for the specific language governing permissions
// and limitations under the License.

#pragma once

#include <SDL2/SDL_keycode.h>
#include <SDL2/SDL_mouse.h>

#include "../Vec.h"
#include "../Exception.h"

#include "ControlAction.h"

#if defined(_WIN32) && defined(HR_ENGINE_SHARED)
#   ifdef MR_ENGINE
#       define MR_DllDeclare   __declspec( dllexport )
#   else
#       define MR_DllDeclare   __declspec( dllimport )
#   endif
#else
#   define MR_DllDeclare
#endif

namespace HoverRace {
namespace Control {

namespace TextControl {

enum key_t {
    BACKSPACE = SDLK_BACKSPACE,
    ENTER = SDLK_RETURN
};

}  // namespace TextControl

namespace Mouse {

enum button_t {
    LEFT = SDL_BUTTON_LEFT,
    MIDDLE = SDL_BUTTON_MIDDLE,
    RIGHT = SDL_BUTTON_RIGHT,
    B4 = SDL_BUTTON_X1,
    B5 = SDL_BUTTON_X2
};

struct Click
{
    constexpr Click(double x, double y, button_t btn) noexcept :
        pos(x, y), btn(btn) { }

    Vec2 pos;
    button_t btn;
};

struct Scroll
{
    constexpr Scroll(double x, double y, double dx, double dy) noexcept :
        pos(x, y), motion(dx, dy) { }

    Vec2 pos;
    Vec2 motion;
};

}  // namespace Mouse

struct CancelCombiner
{
    using result_type = bool;

    template<typename InputIterator>
    bool operator()(InputIterator first, InputIterator last) const
    {
        while (first != last) {
            if (*first) return true;
            ++first;
        }
        return false;
    }
};

using voidSignal_t = boost::signals2::signal<void()>;

using valueSignal_t = boost::signals2::signal<void(int)>;

using stringSignal_t = boost::signals2::signal<void(const std::string&)>;

using textControlSignal_t = boost::signals2::signal<void(TextControl::key_t)>;

using vec2Signal_t = boost::signals2::signal<void(const Vec2&)>;

using mouseClickSignal_t =
    boost::signals2::signal<bool(const Mouse::Click&), CancelCombiner>;

using mouseScrollSignal_t =
    boost::signals2::signal<bool(const Mouse::Scroll&), CancelCombiner>;

template<class T, class Val>
inline void PerformAction(const T&, Val)
{
    std::ostringstream oss;
    oss << "PerformAction<" << typeid(T).name() << ", " <<
        typeid(Val).name() << '>';
    throw UnimplementedExn(oss.str());
}

template<>
inline void PerformAction<voidSignal_t, int>(const voidSignal_t &signal,
                                             int value)
{
    // voidSignals are only triggered if the value is > 0.
    // For keys and buttons, that means key-down / button-down.
    if (value > 0) {
        signal();
    }
}

template<>
inline void PerformAction<valueSignal_t, int>(const valueSignal_t &signal,
                                              int value)
{
    signal(value);
}

template<>
inline void PerformAction<stringSignal_t, const std::string &>(
    const stringSignal_t &signal, const std::string &s)
{
    signal(s);
}

template<>
inline void PerformAction<textControlSignal_t, TextControl::key_t>(
    const textControlSignal_t &signal, TextControl::key_t key)
{
    signal(key);
}

template<>
inline void PerformAction<vec2Signal_t, const Vec2&>(
    const vec2Signal_t &signal, const Vec2 &vec)
{
    signal(vec);
}

template<>
inline void PerformAction<mouseClickSignal_t, const Mouse::Click&>(
    const mouseClickSignal_t &signal, const Mouse::Click &vec)
{
    signal(vec);
}

template<>
inline void PerformAction<mouseScrollSignal_t, const Mouse::Scroll&>(
    const mouseScrollSignal_t &signal, const Mouse::Scroll &scroll)
{
    signal(scroll);
}

template<class T, class Val = int>
class Action : public ControlAction<Val>
{
    using SUPER = ControlAction<Val>;

public:
    Action() : SUPER(), primaryTrigger(0) { }
    Action(const std::string &name, int listOrder) :
        SUPER(name, listOrder), primaryTrigger(0) { }
    virtual ~Action() { }

    virtual void operator()(Val value) {
        PerformAction<T, Val>(signal, value);
    }

    template<class U>
    boost::signals2::connection Connect(U &&del) {
        return signal.connect(std::forward<U>(del));
    }

    int GetPrimaryTrigger() const { return primaryTrigger; }

    void SetPrimaryTrigger(int hash) { primaryTrigger = hash; }

    T &GetSignal() { return signal; }

private:
    int primaryTrigger;
    T signal;
};

} // namespace Control
} // namespace HoverRace

#undef MR_DllDeclare