view.h

/*
**  UICore
**  Copyright (c) 1997-2015 The UICore Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries UICore may link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
*/

#pragma once

#include "../../Core/Math/mat4.h"
#include "../../Core/Math/rect.h"
#include "../../Core/Math/easing.h"
#include "../../Core/Signals/signal.h"
#include "../../UI/Events/event.h"
#include "../Style/style.h"
#include "../Style/style_cascade.h"
#include "../Style/style_get_value.h"
#include "view_event_handler.h"
#include "view_geometry.h"
#include "focus_policy.h"
#include <vector>
#include <memory>
#include <functional>

namespace uicore
{
    class Style;
    class StyleCascade;
    class Canvas;
    typedef std::shared_ptr<Canvas> CanvasPtr;
    class EventUI;
    class ActivationChangeEvent;
    class CloseEvent;
    class FocusChangeEvent;
    class PointerEvent;
    class ResizeEvent;
    class KeyEvent;
    class ViewImpl;
    class CursorDescription;
    enum class StandardCursor;
    class DisplayWindow;
    typedef std::shared_ptr<DisplayWindow> DisplayWindowPtr;
    class ViewTree;
    class ViewAction;

    class View : public std::enable_shared_from_this<View>, public ViewEventHandler
    {
    public:
        View();
        virtual ~View();
        
        const StyleCascade &style_cascade() const;

        const std::shared_ptr<Style> &style(const std::string &state = std::string()) const;
        
        bool state(const std::string &name) const;

        void set_state(const std::string &name, bool value);

        void set_state_cascade(const std::string &name, bool value);

        View *parent() const;

        const std::vector<std::shared_ptr<View>> &children() const;

        void add_child(const std::shared_ptr<View> &view);

        template<typename T, typename... Types>
        std::shared_ptr<T> add_child(Types &&... args)
        {
            auto child = std::make_shared<T>(std::forward<Types>(args)...);
            add_child(child);
            return child;
        }

        std::shared_ptr<View> add_child()
        {
            return add_child<View>();
        }

        void remove_from_parent();

        void add_action(const std::shared_ptr<ViewAction> &action);

        template<typename T, typename... Types>
        std::shared_ptr<T> add_action(Types &&... args)
        {
            auto action = std::make_shared<T>(std::forward<Types>(args)...);
            add_action(action);
            return action;
        }

        const std::vector<std::shared_ptr<ViewAction>> &actions() const;

        bool hidden() const;

        void set_hidden(bool value = true);

        bool is_static_position_and_visible() const;

        bool needs_layout() const;

        void set_needs_layout();

        const ViewGeometry &geometry() const;

        void set_geometry(const ViewGeometry &geometry);

        CanvasPtr canvas() const;

        void set_needs_render();

        bool render_exception_encountered() const;

        void clear_exception_encountered();

        const Mat4f &view_transform() const;

        void set_view_transform(const Mat4f &transform);

        bool content_clipped() const;

        void set_content_clipped(bool clipped);

        float preferred_width(const CanvasPtr &canvas);

        float preferred_height(const CanvasPtr &canvas, float width);

        float first_baseline_offset(const CanvasPtr &canvas, float width);

        float last_baseline_offset(const CanvasPtr &canvas, float width);

        virtual void layout_children(const CanvasPtr &canvas);

        const ViewTree *view_tree() const;
        ViewTree *view_tree();

        View *focus_view() const;

        std::shared_ptr<View> find_view_at(const Pointf &pos) const;

        FocusPolicy focus_policy() const;

        void set_focus_policy(FocusPolicy policy);

        unsigned int tab_index() const;

        void set_tab_index(unsigned int index);

        void set_focus();

        void remove_focus();

        bool has_focus() const { return focus_view() == this; }

        void prev_focus();

        void next_focus();

        void animate(float from, float to, const std::function<void(float)> &setter, int duration_ms = 400, const std::function<float(float)> &easing = Easing::linear, std::function<void()> animation_end = std::function<void()>());

        void stop_animations();

        void set_cursor(const CursorDescription &cursor);
        void set_cursor(StandardCursor type);

        void set_inherit_cursor();

        Signal<void(PointerEvent *)> &sig_pointer_press();
        Signal<void(PointerEvent *)> &sig_pointer_double_click();
        Signal<void(PointerEvent *)> &sig_pointer_release();
        Signal<void(PointerEvent *)> &sig_pointer_move();
        Signal<void(PointerEvent *)> &sig_pointer_enter();
        Signal<void(PointerEvent *)> &sig_pointer_leave();
        Signal<void(PointerEvent *)> &sig_pointer_proximity_change();
        Signal<void(ActivationChangeEvent *)> &sig_activated();
        Signal<void(ActivationChangeEvent *)> &sig_deactivated();
        Signal<void(FocusChangeEvent *)> &sig_focus_gained();
        Signal<void(FocusChangeEvent *)> &sig_focus_lost();
        Signal<void(KeyEvent *)> &sig_key_press();
        Signal<void(KeyEvent *)> &sig_key_release();
        Signal<void(CloseEvent *)> &sig_close();

        void pointer_press(PointerEvent *e) override { sig_pointer_press()(e); }
        void pointer_double_click(PointerEvent *e) override { sig_pointer_double_click()(e); }
        void pointer_release(PointerEvent *e) override { sig_pointer_release()(e); }
        void pointer_move(PointerEvent *e) override { sig_pointer_move()(e); }
        void pointer_enter(PointerEvent *e) override { sig_pointer_enter()(e); }
        void pointer_leave(PointerEvent *e) override { sig_pointer_leave()(e); }
        void pointer_proximity_change(PointerEvent *e) override { sig_pointer_proximity_change()(e); }
        void activated(ActivationChangeEvent *e) override { sig_activated()(e); }
        void deactivated(ActivationChangeEvent *e) override { sig_deactivated()(e); }
        void focus_gained(FocusChangeEvent *e) override { sig_focus_gained()(e); }
        void focus_lost(FocusChangeEvent *e) override { sig_focus_lost()(e); }
        void key_press(KeyEvent *e) override { sig_key_press()(e); }
        void key_release(KeyEvent *e) override { sig_key_release()(e); }
        void close(CloseEvent *e) override { sig_close()(e); }

        void dispatch_event(EventUI *e, bool no_propagation = false);
        void dispatch_event(EventUI *e, const View *until_parent_view);

        static View *common_parent(View *view1, View *view2);

        void update_cursor(const DisplayWindowPtr &window);

        Pointf to_screen_pos(const Pointf &pos);

        Pointf from_screen_pos(const Pointf &pos);

        Pointf to_root_pos(const Pointf &pos);

        Pointf from_root_pos(const Pointf &pos);

        SlotContainer slots;

    protected:
        virtual void render_content(const CanvasPtr &canvas) { }

        virtual void child_added(const std::shared_ptr<View> &view) { }

        virtual void child_removed(const std::shared_ptr<View> &view) { }

        virtual float calculate_preferred_width(const CanvasPtr &canvas);

        virtual float calculate_preferred_height(const CanvasPtr &canvas, float width);

        virtual float calculate_first_baseline_offset(const CanvasPtr &canvas, float width);

        virtual float calculate_last_baseline_offset(const CanvasPtr &canvas, float width);

    private:
        View(const View &) = delete;
        View &operator=(const View &) = delete;

        std::unique_ptr<ViewImpl> impl;

        friend class ViewTree;
        friend class ViewImpl;
        friend class ViewAction;
    };
}