UiViewModel.h

Go to the documentation of this file.

// UiViewModel.h
//
// Copyright (c) 2013-2015 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 "../Control/Nav.h"
#include "../Util/MR_Types.h"
#include "../Vec.h"
#include "UiLayoutFlags.h"
#include "ViewModel.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 Mouse {
            struct Click;
            struct Scroll;
        }
    }
}

namespace HoverRace {
namespace Display {

class MR_DllDeclare UiViewModel : public ViewModel
{
    using SUPER = ViewModel;

public:
    struct Props
    {
        enum
        {
            POS,
            ALIGNMENT,
            FOCUSED,
            NEXT_,  
        };
    };

    enum class Alignment
    {
        NW,  
        N,  
        NE,  
        E,  
        SE,  
        S,  
        SW,  
        W,  
        CENTER,  
    };

public:
    UiViewModel(uiLayoutFlags_t layoutFlags = 0) :
        SUPER(), pos(0, 0), translation(0, 0), alignment(Alignment::NW),
        layoutFlags(layoutFlags), focused(false) { }
    virtual ~UiViewModel() { }

public:
    virtual bool OnMouseMoved(const Vec2&) { return false; }
    virtual bool OnMousePressed(const Control::Mouse::Click&) { return false; }
    virtual bool OnMouseReleased(const Control::Mouse::Click&) { return false; }
    virtual bool OnMouseScrolled(const Control::Mouse::Scroll&) { return false; }
    virtual bool OnAction() { return false; }
    virtual bool OnNavigate(const Control::Nav&) { return false; }

public:
    const Vec2 &GetPos() const { return pos; }
    void SetPos(const Vec2 &pos);
    void SetPos(double x, double y) { SetPos(Vec2(x, y)); }

    const Vec2 &GetTranslation() const { return translation; }
    void SetTranslation(const Vec2 &translation);
    void SetTranslation(double x, double y) { SetTranslation(Vec2(x, y)); }

    Alignment GetAlignment() const { return alignment; }
    void SetAlignment(Alignment alignment);

    Vec2 GetAlignedPos(const Vec2 &pos, double w, double h) const;

    Vec2 GetAlignedPos(double w, double h) const
    {
        return GetAlignedPos(pos + translation, w, h);
    }

    uiLayoutFlags_t GetLayoutFlags() const { return layoutFlags; }

    // Convenience functions for querying layout flags.
    uiLayoutFlags_t IsLayoutUnscaled() const { return layoutFlags & UiLayoutFlags::UNSCALED; }
    uiLayoutFlags_t IsLayoutFloating() const { return layoutFlags & UiLayoutFlags::FLOATING; }

#   ifdef _DEBUG

        std::string GetId() const { return id; }

        void SetId(std::string id) { this->id = id; }
#   endif

    bool IsFocused() const { return focused; }

    virtual bool TryFocus(const Control::Nav &nav = Control::Nav::NEUTRAL)
    {
        HR_UNUSED(nav);
        return false;
    }

    virtual void DropFocus() { SetFocused(false); }

protected:
    void SetFocused(bool focused);

public:
    using focusRequestedSignal_t =
        boost::signals2::signal<void(UiViewModel&)>;
    focusRequestedSignal_t &GetFocusRequestedSignal() { return focusRequestedSignal; }

    void RequestFocus();

public:
    using focusRelinquishedSignal_t =
        boost::signals2::signal<void(UiViewModel&, const Control::Nav&)>;
    focusRelinquishedSignal_t &GetFocusRelinquishedSignal() { return focusRelinquishedSignal; }

protected:
    void RelinquishFocus(const Control::Nav &nav);

private:
    Vec2 pos;
    Vec2 translation;
    Alignment alignment;
    uiLayoutFlags_t layoutFlags;
#   ifdef _DEBUG
        std::string id;
#   endif
    bool focused;
    focusRequestedSignal_t focusRequestedSignal;
    focusRelinquishedSignal_t focusRelinquishedSignal;
};

}  // namespace Display
}  // namespace HoverRace

#undef MR_DllDeclare