BaseContainer.h

Go to the documentation of this file.

// BaseContainer.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 "UiViewModel.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 Display {
        class Display;
    }
}

namespace HoverRace {
namespace Display {

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

public:
    struct Props
    {
        enum
        {
            SIZE = SUPER::Props::NEXT_,
            CLIP,
            OPACITY,
            VISIBLE,
            CHILD_OFFSET,
            NEXT_,  
        };
    };

public:
    BaseContainer(Display &display, uiLayoutFlags_t layoutFlags = 0);
    BaseContainer(Display &display, const Vec2 &size, bool clip = true,
        uiLayoutFlags_t layoutFlags = 0);
    virtual ~BaseContainer() { }

public:
    void AttachView(Display &disp) override { AttachViewDynamic(disp, this); }

protected:
    class Child
    {
    public:
        Child(BaseContainer &bc, std::shared_ptr<UiViewModel> child) :
            child(std::move(child)), visible(true)
        {
            // Route focus request events back to the container.
            focusRequestedConn.reset(
                new boost::signals2::scoped_connection(
                    this->child->GetFocusRequestedSignal().connect(
                        std::bind(&BaseContainer::OnChildRequestedFocus, &bc,
                            std::placeholders::_1))));
            focusRelinquishedConn.reset(
                new boost::signals2::scoped_connection(
                    this->child->GetFocusRelinquishedSignal().connect(
                        std::bind(&BaseContainer::OnChildRelinquishedFocus, &bc,
                            std::placeholders::_1, std::placeholders::_2))));
        }
        Child(const Child&) = delete;
        Child(Child&&) = default;

        Child &operator=(const Child&) = delete;
        Child &operator=(Child&&) = default;

    public:
        std::shared_ptr<UiViewModel> child;
        bool visible;  
    private:
        // scoped_connection is not movable, so we wrap in a unique_ptr.
        std::unique_ptr<boost::signals2::scoped_connection> focusRequestedConn;
        std::unique_ptr<boost::signals2::scoped_connection> focusRelinquishedConn;
    };

    using children_t = std::vector<std::unique_ptr<Child>>;

    // These are marked as protected so that subclasses can restrict how and
    // what types of widgets can be added / removed from the container.

    template<class T, class... Args>
    typename std::enable_if<std::is_base_of<UiViewModel, T>::value,
        std::shared_ptr<T>>::type
    NewChild(Args&&... args)
    {
        auto sharedChild = std::make_shared<T>(std::forward<Args>(args)...);
        children.emplace_back(new Child(*this, sharedChild));
        sharedChild->AttachView(display);
        return sharedChild;
    }

    template<typename T>
    typename std::enable_if<std::is_base_of<UiViewModel, T>::value, std::shared_ptr<T>>::type
    RemoveChild(const std::shared_ptr<T> &child)
    {
        for (auto iter = children.begin(); iter != children.end(); ++iter) {
            if ((*iter)->child == child) {
                children.erase(iter);
                break;
            }
        }
        return child;
    }

    template<class T>
    typename std::enable_if<std::is_base_of<UiViewModel, T>::value,
        std::shared_ptr<T>
        >::type
    ReorderChild(const std::shared_ptr<T> &child, size_t idx)
    {
        auto sz = children.size();
        if (sz == 0) return child;

        if (idx >= sz) {
            idx = sz - 1;
        }

        for (auto iter = children.begin(); iter != children.end(); ++iter) {
            if ((*iter)->child == child) {
                auto dest = children.begin();
                std::advance(dest, idx);
                if (dest < iter) {
                    std::rotate(dest, iter, iter + 1);
                }
                else if (dest > iter) {
                    std::rotate(iter, iter + 1, dest + 1);
                }
                break;
            }
        }

        return child;
    }

    virtual void Clear()
    {
        children.clear();
    }

    virtual void Reserve(size_t capacity)
    {
        children.reserve(capacity);
    }

private:
    template<typename P, bool(UiViewModel::*F)(P)>
    bool PropagateMouseEvent(P param)
    {
        if (!visible || children.empty()) return false;

        // We iterate over the child widgets in reverse since the widgets
        // are rendered back to front, so we let the ones in front get
        // first chance to handle the events.

        Vec2 oldOrigin(0, 0);
        for (auto iter = children.rbegin();
            iter != children.rend(); ++iter)
        {
            auto &child = (*iter)->child;
            if (!(*iter)->visible) continue;
            oldOrigin = display.AddUiOrigin(child->GetPos());
            bool retv = (child.get()->*F)(param);
            display.SetUiOrigin(oldOrigin);
            if (retv) return true;
        }

        return false;
    }

public:
    bool OnMouseMoved(const Vec2 &pos) override;
    bool OnMousePressed(const Control::Mouse::Click &click) override;
    bool OnMouseReleased(const Control::Mouse::Click &click) override;
    bool OnMouseScrolled(const Control::Mouse::Scroll &scroll) override;

protected:
    virtual void OnChildRequestedFocus(UiViewModel &child) { HR_UNUSED(child); }

    virtual void OnChildRelinquishedFocus(UiViewModel &child,
        const Control::Nav &nav) { HR_UNUSED(child); HR_UNUSED(nav); }

public:
    void ShrinkWrap();

    const Vec2 &GetSize() const { return size; }
    void SetSize(const Vec2 &size);
    void SetSize(double w, double h) { SetSize(Vec2(w, h)); }

    bool IsClip() const { return clip; }
    void SetClip(bool clip);

    double GetOpacity() const { return opacity; }
    void SetOpacity(double opacity);

    bool IsVisible() const { return visible; }
    void SetVisible(bool visible);

    const Vec2 &GetChildOffset() const { return childOffset; }
protected:
    void SetChildOffset(const Vec2 &offset);

public:
    bool IsEmpty() const { return children.empty(); }

    template<class Fn>
    void ForEachChild(Fn fn) const
    {
        for (auto &child : children) {
            fn(child->child);
        }
    }

    template<class Fn>
    void ForEachVisibleChild(Fn fn) const
    {
        for (auto &child : children) {
            if (child->visible) {
                fn(child->child);
            }
        }
    }

protected:
    children_t &GetChildren() { return children; }

public:
    Vec3 Measure() override { return size.Promote(); }

protected:
    bool TestHit(const Vec2 &pos);

protected:
    Display &display;
private:
    Vec2 size;
    bool clip;
    double opacity;
    bool visible;
    Vec2 childOffset;
    children_t children;
};

}  // namespace Display
}  // namespace HoverRace

#undef MR_DllDeclare