box.hpp

Go to the documentation of this file.

/*
    Copyright 2020-2021 natinusala
    Copyright 2021 XITRIX
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
        http://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    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 <aurore/core/view.hpp>
 
namespace aurore
{
 
enum class JustifyContent
{
    FLEX_START,
    CENTER,
    FLEX_END,
    SPACE_BETWEEN,
    SPACE_AROUND,
    SPACE_EVENLY,
};
 
enum class AlignItems
{
    AUTO,
    FLEX_START,
    CENTER,
    FLEX_END,
    STRETCH,
    BASELINE,
    SPACE_BETWEEN,
    SPACE_AROUND,
};
 
enum class Axis
{
    ROW,
    COLUMN,
};
 
enum class Wrap
{
    NO_WRAP,
    WRAP,
    WRAP_REVERSE,
};
 
enum class Direction
{
    INHERIT,
    LEFT_TO_RIGHT,
    RIGHT_TO_LEFT,
};
 
class Box : public View
{
  public:
    Box(Axis flexDirection);
    Box();
    ~Box();
 
    void draw(NVGcontext* vg, float x, float y, float width, float height, Style style, FrameContext* ctx) override;
    View* getDefaultFocus() override;
    View* hitTest(Point point) override;
    View* getNextFocus(FocusDirection direction, View* currentView) override;
    void willAppear(bool resetState) override;
    void willDisappear(bool resetState) override;
    void onWindowSizeChanged() override;
    void onThemeChanged() override;
    void onFocusGained() override;
    void onFocusLost() override;
    void onParentFocusGained(View* focusedView) override;
    void onParentFocusLost(View* focusedView) override;
    bool applyXMLAttribute(std::string name, std::string value) override;
 
    static View* create();
 
    virtual View* getParentNavigationDecision(View* from, View* newFocus, FocusDirection direction);
 
    virtual void addView(View* view);
 
    virtual void addView(View* view, size_t position);
 
    virtual void removeView(View* view, bool free = true);
 
    virtual void clearViews(bool free = true);
 
    virtual void setPadding(float padding);
 
    virtual void setPadding(float top, float right, float bottom, float left);
 
    virtual void setPaddingTop(float top);
 
    float getPaddingTop();
 
    virtual void setPaddingRight(float right);
 
    float getPaddingRight();
 
    virtual void setPaddingBottom(float bottom);
 
    float getPaddingBottom();
 
    virtual void setPaddingLeft(float left);
 
    float getPaddingLeft();
 
    virtual void setGap(float gap);
 
    float getGap();
 
    void setRowGap(float gap);
    float getRowGap();
 
    void setColumnGap(float gap);
    float getColumnGap();
 
    void setJustifyContent(JustifyContent justify);
 
    void setAlignItems(AlignItems alignment);
 
    void setDirection(Direction direction);
 
    void setAxis(Axis axis);
    Axis getAxis() const;
 
    void setWrap(Wrap wrap);
 
    Wrap getWrap() const;
 
    std::vector<View*>& getChildren();
 
    virtual void getCullingBounds(float* top, float* right, float* bottom, float* left);
 
    void forwardXMLAttribute(std::string attributeName, View* target);
 
    void forwardXMLAttribute(std::string attributeName, View* target, std::string targetAttributeName);
 
    virtual void onChildFocusGained(View* directChild, View* focusedView);
 
    virtual void onChildFocusLost(View* directChild, View* focusedView);
 
    View* getView(std::string id) override;
 
    void setLastFocusedView(View* view);
 
    void setDefaultFocusedIndex(int index);
 
    size_t getDefaultFocusedIndex() const;
 
    View* getLastFocusedView() const;
 
    virtual bool isChildFocused();
 
  private:
    Axis axis;
 
    std::vector<View*> children;
 
    size_t defaultFocusedIndex = 0;
    View* lastFocusedView      = nullptr;
 
    std::unordered_map<std::string, std::pair<std::string, View*>> forwardedAttributes;
 
  protected:
    std::string getDefaultAccessibilityLabel() override;
 
    void inflateFromXMLString(std::string_view xml);
 
    void inflateFromXMLElement(tinyxml2::XMLElement* element);
 
    void inflateFromXMLRes(const std::string& res);
 
    void inflateFromXMLFile(const std::string& path);
 
    void handleXMLElement(tinyxml2::XMLElement* element) override;
};
 
class Padding : public View
{
  public:
    Padding();
 
    void draw(NVGcontext* vg, float x, float y, float width, float height, Style style, FrameContext* ctx) override;
 
    static View* create();
};
 
} // namespace aurore