Panel.h

Go to the documentation of this file.

#pragma once
 
#include "../UI/ComponentStackWidget.h"
#include "../UI/WidgetContainer.h"
#include "../Property.h"
#include "../Input/KeyRepeater.h"
#include "Registry.h"
#include "Scrollbar.h"
 
namespace Gorgon { namespace Widgets {
    
    class Panel : public UI::ComponentStackWidget, public UI::WidgetContainer {
    public:
        
        Panel(const Panel &) = delete;
        
        explicit Panel(const UI::Template &temp);
        
        explicit Panel(Registry::TemplateType type = Registry::Panel_Regular) : Panel(Registry::Active()[type]) { }
 
        using Widget::Resize;
        
        using Widget::Remove;
        
        using WidgetContainer::Remove;
        
        virtual void Resize(const Geometry::Size &size) override;
        
        using Widget::Move;
        
        virtual void Move(const Geometry::Point &location) override;
        
 
        virtual bool Activate() override;
 
 
        virtual bool KeyEvent(Input::Key, float) override;
 
 
        virtual bool CharacterEvent(Char) override;
 
 
        virtual bool IsVisible() const override;
 
 
        virtual Geometry::Size GetInteriorSize() const override;
 
 
        virtual bool ResizeInterior(Geometry::Size size) override;
        
        void EnableScroll(bool vertical, bool horizontal);
        
        bool IsVerticalScrollEnabled() const {
            return vscroll;
        }
        
        bool IsHorizontalScrollEnabled() const {
            return hscroll;
        }
        
        
        void ScrollTo(Geometry::Point location, bool clip = false) {
            ScrollTo(location.X, location.Y, clip);
        }
        
        void ScrollTo(int x, int y, bool clip = true);
 
        void ScrollTo(int y, bool clip = true) {
            ScrollTo(ScrollOffset().X, y, clip);
        }
 
        void ScrollBy(int y, bool clip = true) {
            ScrollTo(ScrollOffset().X, ScrollOffset().Y + y, clip);
        }
 
        void ScrollBy(int x, int y, bool clip = true) {
            ScrollTo(ScrollOffset().X + x, ScrollOffset().Y + y, clip);
        }
        
        Geometry::Point ScrollOffset() const;
        
        Geometry::Point MaxScrollOffset() const;
        
        void SetOverscroll(int value);
        
        int GetOverscroll() const {
            return overscroll;
        }
        
        void SetScrollDistance(int vert) {
            scrolldist.Y = vert;
        }
        
        void SetScrollDistance(int hor, int vert) {
            SetScrollDistance({hor, vert});
        }
        
        void SetScrollDistance(Geometry::Point dist) {
            scrolldist = dist;
        }
        
        Geometry::Point GetScrollDistance() const {
            return scrolldist;
        }
        
        void DisableSmoothScroll() {
            SetSmoothScrollSpeed(0);
        }
        
        void SetSmoothScrollSpeed(int value);
        
        int GetSmoothScrollSpeed() const {
            return scrollspeed;
        }
        
        bool IsSmoothScrollEnabled() const {
            return scrollspeed != 0;
        }
        
        using Widget::EnsureVisible;
        
        bool EnsureVisible(const UI::Widget &widget) override;
 
        using Widget::Enable;
        using Widget::Disable;
        using Widget::ToggleEnabled;
 
        virtual void SetEnabled(bool value) override {
            if(value != IsEnabled()) {
                ComponentStackWidget::SetEnabled(value);
                distributeparentenabled(value);
            }
        }
 
        virtual bool IsEnabled() const override {
            return ComponentStackWidget::IsEnabled();
        }
        
        virtual UI::ExtenderRequestResponse RequestExtender(const Gorgon::Layer &self) override;
        
    protected:
        virtual bool allowfocus() const override;
        
        virtual void focused() override;
 
        virtual void focuslost() override;
 
        virtual Layer &getlayer() override;
        
        void focuschanged() override;
        
        virtual void childboundschanged(Widget *source) override;
        
        void updatecontent();
        
        void updatescroll();
        
        void updatebars();
        
        bool updaterequired = false;
        
        void scrolltox(int x) {
            ScrollTo(x, ScrollOffset().Y);
        }
        
        void scrolltoy(int y) {
            ScrollTo(y);
        }
        
        Input::KeyRepeater repeater;
        
        FocusStrategy getparentfocusstrategy() const override {
            if(HasParent())
                return GetParent().CurrentFocusStrategy();
            else
                return AllowAll;
        }
 
        virtual void parentenabledchanged(bool state) override {
            ComponentStackWidget::parentenabledchanged(state);
 
            if(!state && IsEnabled())
                distributeparentenabled(state);
            else if(state && IsEnabled())
                distributeparentenabled(state);
        }
        
        virtual UI::Widget *createvscroll(const UI::Template &temp);
        
        virtual UI::Widget *createhscroll(const UI::Template &temp);
        
        int overscroll = 0;
        bool scrollclipped = true;
        Geometry::Point scrolldist = {80, 45};
        Geometry::Point scrolloffset = {0, 0};
        int scrollspeed = 500;
        Geometry::Point target = {0, 0};
        bool isscrolling = false;
        float scrollleftover = 0;
        bool vscroll = true, hscroll = false;
    };
    
} }