view.hpp

Go to the documentation of this file.

/*
    Copyright 2019-2021 natinusala
    Copyright 2019 p-sam
 
    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 <nanovg.h>
#include <stdio.h>
#include <algorithm>
#include <array>
#include <functional>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#include <aurore/core/actions.hpp>
#include <aurore/core/animation.hpp>
#include <aurore/core/event.hpp>
#include <aurore/core/frame_context.hpp>
#include <aurore/core/geometry.hpp>
#include <aurore/core/gesture.hpp>
#include <aurore/core/util.hpp>
#include <aurore/core/view_style.hpp>
#ifdef USE_LIBROMFS
#include <romfs/romfs.hpp>
#endif
 
#define AURORE_REGISTER_ENUM_XML_ATTRIBUTE(name, enumType, method, ...) \
    this->registerStringXMLAttribute(name, [this](std::string value) {                   \
        std::unordered_map<std::string, enumType> enumMap = __VA_ARGS__;                 \
        if (enumMap.count(value) > 0)                                                    \
            method(enumMap[value]);                                                      \
        else                                                                             \
            aurore::View::fatalXML("Illegal value \"" + value + "\" for XML attribute \"" + name + "\"; expected " + aurore::View::listXMLValues(enumMap)); })
 
#define AURORE_REGISTER_CLICK_BY_ID(id, method) \
    this->getView(id)->registerClickAction([this](aurore::View* view) { return method(view); })
 
// Avoid conflicts with macro definitions in windows.h
#undef RGB
#undef TRANSPARENT
#undef RELATIVE
#undef ABSOLUTE
 
namespace tinyxml2
{
class XMLDocument;
class XMLElement;
}
struct YGNode;
struct YGConfig;
 
namespace aurore
{
 
const NVGcolor TRANSPARENT = nvgRGBA(0, 0, 0, 0);
 
void nameXMLDocument(const tinyxml2::XMLDocument* document, const std::string& name);
struct ReadingXMLElement
{
    explicit ReadingXMLElement(const tinyxml2::XMLElement* element);
    ~ReadingXMLElement();
    ReadingXMLElement(const ReadingXMLElement&)            = delete;
    ReadingXMLElement& operator=(const ReadingXMLElement&) = delete;
 
  private:
    const tinyxml2::XMLElement* previous;
};
 
enum class FocusDirection
{
    UP,
    DOWN,
    LEFT,
    RIGHT
};
 
enum class ViewBackground
{
    NONE,
    SIDEBAR,
    BACKDROP,
    SHAPE_COLOR,
    VERTICAL_LINEAR,
    HORIZONTAL_LINEAR,
};
 
enum class AlignSelf
{
    AUTO,
    FLEX_START,
    CENTER,
    FLEX_END,
    STRETCH,
    BASELINE,
    SPACE_BETWEEN,
    SPACE_AROUND,
};
 
enum class Visibility
{
    VISIBLE, 
    INVISIBLE, 
    GONE, 
};
 
enum class PositionType
{
    RELATIVE, 
    ABSOLUTE, 
    STATIC, 
};
 
enum class BoxSizing
{
    BORDER_BOX, 
    CONTENT_BOX, 
};
 
enum class TransitionAnimation
{
    FADE, 
    SLIDE_LEFT, 
    SLIDE_RIGHT, 
    NONE,
    LINEAR,
};
 
enum class ShadowType
{
    NONE, 
    GENERIC, 
    CUSTOM, 
};
 
struct AppletFrameItem
{
    std::string title;
    std::string iconPath;
 
    void setIconFromRes(std::string name)
    {
#ifdef USE_LIBROMFS
        iconPath = "@res/" + name;
#else
        iconPath = std::string(AURORE_RESOURCES) + name;
#endif
    }
 
    void setIconFromFile(std::string path)
    {
        iconPath = path;
    }
 
    void setHintView(View* hintView);
    View* getHintView() { return hintView; }
 
    ~AppletFrameItem();
 
  private:
    View* hintView = nullptr;
};
 
extern const NVGcolor transparent;
 
class View;
class Box;
class AppletFrame;
class Subscription;
class Activity;
 
typedef Event<View*> GenericEvent;
typedef Event<> VoidEvent;
 
typedef std::function<void(void)> AutoAttributeHandler;
typedef std::function<void(int)> IntAttributeHandler;
typedef std::function<void(float)> FloatAttributeHandler;
typedef std::function<void(std::string)> StringAttributeHandler;
typedef std::function<void(NVGcolor)> ColorAttributeHandler;
typedef std::function<void(bool)> BoolAttributeHandler;
typedef std::function<void(std::string)> FilePathAttributeHandler;
 
float ntz(float value);
 
class View
{
  private:
    ViewBackground background = ViewBackground::NONE;
 
    void drawBackground(NVGcontext* vg, FrameContext* ctx, Style style, Rect frame);
    void drawShadow(NVGcontext* vg, FrameContext* ctx, Style style, Rect frame);
    void drawThemeUnderlay(FrameContext* ctx, const Rect& frame);
    void drawThemeBackdrop(FrameContext* ctx, const Rect& frame);
    void drawBorder(NVGcontext* vg, FrameContext* ctx, Style style, Rect frame);
    void drawHighlight(NVGcontext* vg, Theme theme, float alpha, Style style, bool background);
    void drawClickAnimation(NVGcontext* vg, FrameContext* ctx, Rect frame);
    void drawWireframe(FrameContext* ctx, Rect frame);
    void drawLine(FrameContext* ctx, Rect frame);
 
    Animatable highlightAlpha   = 0.0f;
    float highlightPadding      = 0.0f;
    float highlightCornerRadius = 0.0f;
 
    Animatable clickAlpha = 0.0f; 
 
    bool highlightShaking = false;
    Time highlightShakeStart;
    FocusDirection highlightShakeDirection;
    float highlightShakeAmplitude;
 
    bool fadeIn          = false; 
    bool inFadeAnimation = false; 
 
    Theme* themeOverride = nullptr;
 
    bool hidden    = false;
    bool focusable = false;
 
    enum Sound focusSound = SOUND_FOCUS_CHANGE;
 
    bool hideHighlightBackground = false;
    bool hideHighlightBorder     = false;
    bool hideHighlight           = false;
    bool hideClickAnimation      = false;
 
    bool detached = false;
    Point detachedOrigin;
 
    Point translation;
 
    bool wireframeEnabled = false;
    bool clipsToBounds    = false;
    float scaleX          = 1.0f;
    float scaleY          = 1.0f;
 
    void applyScale(NVGcontext* vg, const Rect& frame);
 
    std::vector<std::shared_ptr<Action>> actions;
    std::vector<GestureRecognizer*> gestureRecognizers;
 
    void* parentUserdata = nullptr;
 
    bool culled = true; 
 
    float aspectRatio = 0;
 
    std::unordered_map<std::string, AutoAttributeHandler> autoAttributes;
    std::unordered_map<std::string, FloatAttributeHandler> percentageAttributes;
    std::unordered_map<std::string, FloatAttributeHandler> floatAttributes;
    std::unordered_map<std::string, StringAttributeHandler> stringAttributes;
    std::unordered_map<std::string, ColorAttributeHandler> colorAttributes;
    std::unordered_map<std::string, BoolAttributeHandler> boolAttributes;
    std::unordered_map<std::string, FilePathAttributeHandler> filePathAttributes;
 
    std::set<std::string> knownAttributes;
 
    void registerCommonAttributes();
 
    void ensureCommonAttributes();
    bool commonAttributesRegistered  = false;
    bool registeringCommonAttributes = false;
    void printXMLAttributeErrorMessage(tinyxml2::XMLElement* element, std::string name, std::string value);
 
    unsigned maximumAllowedXMLElements = UINT_MAX;
 
    NVGcolor lineColor = TRANSPARENT;
    float lineTop      = 0;
    float lineRight    = 0;
    float lineBottom   = 0;
    float lineLeft     = 0;
 
    Visibility visibility = Visibility::VISIBLE;
 
    NVGcolor backgroundColor = TRANSPARENT;
 
    NVGcolor backgroundStartColor = TRANSPARENT;
    NVGcolor backgroundEndColor   = nvgRGBA(0, 0, 0, 200);
    std::vector<float> backgroundRadius { 0.0f, 0.0f, 0.0f, 0.0f };
 
    NVGcolor borderColor             = TRANSPARENT;
    float borderThickness            = 0.0f;
    float cornerRadius               = 0.0f;
    std::array<float, 4> cornerRadii = { 0.0f, 0.0f, 0.0f, 0.0f }; // TL, TR, BR, BL
    ShadowType shadowType            = ShadowType::NONE;
    bool showShadow                  = true;
    ThemeArea themeArea              = ThemeArea::NONE;
 
    std::unordered_map<FocusDirection, std::string> customFocusById;
    std::unordered_map<FocusDirection, View*> customFocusByPtr;
 
    AppletFrameItem appletFrameItem;
 
    int ptrLockCounter = 0;
 
  protected:
    Animatable collapseState = 1.0f;
 
    bool focused = false;
 
    Activity* parentActivity = nullptr;
    Box* parent              = nullptr;
 
    GenericEvent focusEvent;
    GenericEvent focusLostEvent;
 
    YGNode* ygNode;
 
    std::string id = "";
 
    NVGcolor a(NVGcolor color);
    NVGpaint a(NVGpaint paint);
 
    NVGcolor RGB(unsigned r, unsigned g, unsigned b)
    {
        return this->a(nvgRGB(r, g, b));
    }
 
    NVGcolor RGBA(unsigned r, unsigned g, unsigned b, unsigned a)
    {
        return this->a(nvgRGBA(r, g, b, a));
    }
 
    NVGcolor RGBf(float r, float g, float b)
    {
        return this->a(nvgRGBf(r, g, b));
    }
 
    NVGcolor RGBAf(float r, float g, float b, float a)
    {
        return this->a(nvgRGBAf(r, g, b, a));
    }
 
    NVGcolor shadowColor(NVGcolor color, float opacity);
 
    virtual bool animateHint()
    {
        return false;
    }
 
  public:
    static void setHighlightGlide(bool glide);
 
    void setScale(float scale);
    void setScaleX(float scale);
    void setScaleY(float scale);
    float getScaleX() const { return scaleX; }
    float getScaleY() const { return scaleY; }
 
    static constexpr float AUTO = NAN;
 
    inline static std::string CUSTOM_RESOURCES_PATH;
 
    View();
    virtual ~View();
 
    void setBackground(ViewBackground background);
 
    void setBackgroundLinearGradient(NVGcolor start, NVGcolor end, ViewBackground direction = ViewBackground::VERTICAL_LINEAR);
 
    void shakeHighlight(FocusDirection direction);
 
    Rect getFrame();
    float getX();
    float getY();
 
    Rect getLocalFrame();
    float getLocalX();
    float getLocalY();
 
    float getWidth();
    float getHeight(bool includeCollapse = true);
 
    virtual void invalidate();
 
    virtual void onLayout() {};
 
    virtual View* getView(std::string id);
 
    // -----------------------------------------------------------
    // Flex layout properties
    // -----------------------------------------------------------
 
    void setWidth(float width);
 
    void setHeight(float height);
 
    void setSize(Size size);
 
    void setDimensions(float width, float height);
 
    void setWidthPercentage(float percentage);
 
    void setHeightPercentage(float percentage);
 
    void setMinWidth(float minWidth);
 
    void setMinHeight(float minHeight);
 
    void setMinWidthPercentage(float percentage);
 
    void setMinHeightPercentage(float percentage);
 
    void setMaxWidth(float maxWidth);
 
    void setMaxHeight(float maxHeight);
 
    void setMaxWidthPercentage(float percentage);
 
    void setMaxHeightPercentage(float percentage);
 
    void setGrow(float grow);
 
    void setShrink(float shrink);
 
    void setMargins(float top, float right, float bottom, float left);
 
    void setMarginTop(float top);
 
    void setMarginRight(float right);
 
    float getMarginRight();
    float getMarginLeft();
 
    void setMarginBottom(float right);
 
    void setMarginLeft(float left);
 
    void setVisibility(Visibility visibility);
 
    Visibility getVisibility();
 
    void setPositionTop(float pos);
 
    void setPositionRight(float pos);
 
    void setPositionBottom(float pos);
 
    void setPositionLeft(float pos);
 
    void setPositionTopPercentage(float percentage);
 
    void setPositionRightPercentage(float percentage);
 
    void setPositionBottomPercentage(float percentage);
 
    void setPositionLeftPercentage(float percentage);
 
    void setPositionType(PositionType type);
 
    void setId(std::string id);
 
    const std::string& getId() const
    {
        return this->id;
    }
 
    void setAlignSelf(AlignSelf align);
 
    void setBoxSizing(BoxSizing sizing);
 
    // -----------------------------------------------------------
    // Styling and view shape properties
    // -----------------------------------------------------------
 
    inline void setLineColor(NVGcolor color)
    {
        if (this->transitionStyle("lineColor", StyleValue::of(color)))
            return;
        this->lineColor = color;
    }
 
    inline void setLineTop(float thickness)
    {
        this->lineTop = thickness;
    }
 
    inline void setLineRight(float thickness)
    {
        this->lineRight = thickness;
    }
 
    inline void setLineBottom(float thickness)
    {
        this->lineBottom = thickness;
    }
 
    inline void setLineLeft(float thickness)
    {
        this->lineLeft = thickness;
    }
 
    inline void setBackgroundColor(NVGcolor color)
    {
        if (this->transitionStyle("backgroundColor", StyleValue::of(color)))
            return;
        this->backgroundColor = color;
        this->setBackground(ViewBackground::SHAPE_COLOR);
    }
 
    inline void setBorderColor(NVGcolor color)
    {
        if (this->transitionStyle("borderColor", StyleValue::of(color)))
            return;
        this->borderColor = color;
    }
 
    ViewBackground getBackground() const { return this->background; }
    NVGcolor getBackgroundColor() const { return this->backgroundColor; }
    NVGcolor getBorderColor() const { return this->borderColor; }
 
    inline void setBorderThickness(float thickness)
    {
        if (this->transitionStyle("borderThickness", StyleValue::of(thickness)))
            return;
        this->borderThickness = thickness;
    }
 
    inline float getBorderThickness()
    {
        return this->borderThickness;
    }
 
    inline void setCornerRadius(float radius)
    {
        if (this->transitionStyle("cornerRadius", StyleValue::of(radius)))
            return;
        this->cornerRadius   = radius;
        this->cornerRadii[0] = radius;
        this->cornerRadii[1] = radius;
        this->cornerRadii[2] = radius;
        this->cornerRadii[3] = radius;
    }
 
    inline void setCornerRadius(float topLeft, float topRight, float bottomRight, float bottomLeft)
    {
        this->cornerRadii[0] = topLeft;
        this->cornerRadii[1] = topRight;
        this->cornerRadii[2] = bottomRight;
        this->cornerRadii[3] = bottomLeft;
        this->cornerRadius   = (topLeft == topRight && topRight == bottomRight && bottomRight == bottomLeft) ? topLeft : 0.0f;
    }
 
    inline float getCornerRadius()
    {
        return this->cornerRadius;
    }
 
    void setThemeArea(ThemeArea area) { this->themeArea = area; }
    ThemeArea getThemeArea() const { return this->themeArea; }
 
    inline void setShadowType(ShadowType type)
    {
        this->shadowType = type;
    }
 
    inline void setShadowVisibility(bool visible)
    {
        this->showShadow = visible;
    }
 
    inline void setHideHighlightBackground(bool hide)
    {
        this->hideHighlightBackground = hide;
    }
 
    inline void setHideHighlightBorder(bool hide)
    {
        this->hideHighlightBorder = hide;
    }
 
    inline void setHideHighlight(bool hide)
    {
        this->hideHighlight = hide;
    }
 
    inline void setHideClickAnimation(bool hide)
    {
        this->hideClickAnimation = hide;
    }
 
    inline void setHighlightPadding(float padding)
    {
        this->highlightPadding = padding;
    }
 
    inline void setHighlightCornerRadius(float radius)
    {
        this->highlightCornerRadius = radius;
    }
 
    // -----------------------------------------------------------
 
    virtual View* getNearestView(std::string id);
 
    static View* createFromXMLString(std::string_view xml);
 
    static View* createFromXMLElement(tinyxml2::XMLElement* element);
 
    static View* createFromXMLFile(std::string path);
 
    static View* createFromXMLResource(std::string name);
 
    virtual void handleXMLElement(tinyxml2::XMLElement* element);
 
    virtual void applyXMLAttributes(tinyxml2::XMLElement* element);
 
    virtual bool applyXMLAttribute(std::string name, std::string value);
 
    void registerAutoXMLAttribute(std::string name, AutoAttributeHandler handler);
 
    void registerPercentageXMLAttribute(std::string name, FloatAttributeHandler handler);
 
    void registerFloatXMLAttribute(std::string name, FloatAttributeHandler handler);
 
    void registerStringXMLAttribute(std::string name, StringAttributeHandler handler);
 
    void registerColorXMLAttribute(std::string name, ColorAttributeHandler handler);
 
    void registerBoolXMLAttribute(std::string name, BoolAttributeHandler handler);
 
    void registerFilePathXMLAttribute(std::string name, FilePathAttributeHandler handler);
 
    static std::shared_ptr<tinyxml2::XMLDocument> getXMLCache(std::string_view path);
 
    static void forgetXMLCache(const std::string& path);
 
    bool isXMLAttributeValid(std::string attributeName);
 
    static std::string describeXMLError(tinyxml2::XMLDocument* document, const std::string& source = "");
 
    static std::string currentXMLResource;
 
    static std::string describeXMLLocation(const tinyxml2::XMLElement* element);
 
    [[noreturn]] static void fatalXML(const std::string& message);
 
    static std::string closestXMLName(const std::string& name, const std::vector<std::string>& known);
 
    template <typename T>
    static std::string listXMLValues(const std::unordered_map<std::string, T>& values)
    {
        std::vector<std::string> names;
        for (const auto& entry : values)
            names.push_back(entry.first);
        std::sort(names.begin(), names.end());
        std::string list;
        for (const std::string& name : names)
            list += (list.empty() ? "" : ", ") + name;
        return list;
    }
 
    void setMaximumAllowedXMLElements(unsigned max);
 
    unsigned getMaximumAllowedXMLElements();
 
    void setInFadeAnimation(bool translucent);
 
    inline void setFocusable(bool focusable)
    {
        this->focusable = focusable;
    }
 
    bool isFocusable();
 
    void removeFromSuperView(bool free = true);
 
    inline void setFocusSound(enum Sound sound)
    {
        this->focusSound = sound;
    }
 
    virtual enum Sound getFocusSound();
 
    void detach();
 
    bool isDetached();
 
    void setDetachedPosition(float x, float y);
 
    void setDetachedPositionX(float x);
 
    void setDetachedPositionY(float y);
 
    Point getDetachedPosition() const
    {
        return detachedOrigin;
    }
 
    void setParent(Box* parent, void* parentUserdata = nullptr);
    Box* getParent();
    bool hasParent();
 
    void* getParentUserData();
 
    typedef std::vector<std::shared_ptr<Action>>::iterator ActionIterator;
 
    template <class ButtonType>
    ActionIterator getAction(ButtonType button);
 
    ActionIterator getAction(ActionIdentifier identifier);
 
    template <class ButtonType, class ActionType>
    ActionIdentifier registerAction(const std::string& hintText, ButtonType button, const ActionListener& actionListener, bool hidden = false, bool allowRepeating = false, enum Sound sound = SOUND_NONE);
 
    ActionIdentifier registerAction(const std::string& hintText, ControllerButton button, const ActionListener& actionListener, bool hidden = false, bool allowRepeating = false, enum Sound sound = SOUND_NONE);
 
    ActionIdentifier registerAction(AuroreKeyCombination key, const ActionListener& actionListener, bool allowRepeating = false);
 
    void func(AuroreKeyCombination key);
 
    void unregisterAction(ActionIdentifier identifier);
 
    void registerClickAction(const ActionListener& actionListener);
 
    void updateActionHint(enum ControllerButton button, const std::string& hintText);
    void setActionAvailable(enum ControllerButton button, bool available);
    void setActionsAvailable(bool available) const;
 
    void setActionHidden(enum ControllerButton button, bool hidden);
 
    void resetClickAnimation();
    void playClickAnimation(bool reverse = false, bool animateBack = true, bool force = false);
 
    std::string getClassString() const;
 
    std::string describe() const;
 
    YGNode* getYGNode();
 
    const std::vector<std::shared_ptr<Action>>& getActions();
 
    const std::vector<GestureRecognizer*>& getGestureRecognizers();
 
    void interruptGestures(bool onlyIfUnsureState);
 
    void addGestureRecognizer(GestureRecognizer* recognizer);
 
    bool removeGestureRecognizer(GestureRecognizer* recognizer);
 
    Sound gestureRecognizerRequest(TouchState touch, MouseState mouse, View* firstResponder);
 
    virtual void frame(FrameContext* ctx);
 
    void frameHighlight(FrameContext* ctx);
 
    virtual void draw(NVGcontext* vg, float x, float y, float width, float height, Style style, FrameContext* ctx) = 0;
 
    virtual void willAppear(bool resetState = false)
    {
        // Nothing to do
    }
 
    virtual void willDisappear(bool resetState = false)
    {
        // Nothing to do
    }
 
    virtual void onShowAnimationEnd() {};
 
    virtual void show(std::function<void(void)> cb);
 
    virtual void show(std::function<void(void)> cb, bool animate, float animationDuration);
 
    virtual float getShowAnimationDuration(TransitionAnimation animation);
 
    void collapse(bool animated = true);
 
    bool isCollapsed();
 
    void setAlpha(float alpha);
 
    void expand(bool animated = true);
 
    virtual void hide(std::function<void(void)> cb);
 
    virtual void hide(std::function<void(void)> cb, bool animate, float animationDuration);
 
    bool isHidden();
 
    virtual bool isTranslucent();
 
    bool isFocused();
 
    virtual View* getDefaultFocus();
 
    virtual View* hitTest(Point point);
 
    virtual View* getNextFocus(FocusDirection direction, View* currentView);
 
    void setCustomNavigationRoute(FocusDirection direction, View* target);
 
    void setCustomNavigationRoute(FocusDirection direction, std::string targetId);
 
    bool hasCustomNavigationRouteByPtr(FocusDirection direction);
    bool hasCustomNavigationRouteById(FocusDirection direction);
 
    View* getCustomNavigationRoutePtr(FocusDirection direction);
    std::string getCustomNavigationRouteId(FocusDirection direction);
 
    virtual void onFocusGained();
 
    virtual void onFocusLost();
 
    virtual void onParentFocusGained(View* focusedView);
 
    virtual void onParentFocusLost(View* focusedView);
 
    virtual void onWindowSizeChanged()
    {
        // Nothing by default
    }
 
    GenericEvent* getFocusEvent();
    GenericEvent* getFocusLostEvent();
 
    Animatable alpha = 1.0f;
 
    virtual float getAlpha(bool child = false);
 
    float getClickAlpha() { return this->clickAlpha; }
 
    void overrideTheme(Theme* newTheme);
 
    void setCulled(bool culled)
    {
        this->culled = culled;
    }
 
    bool isCulled()
    {
        return this->culled;
    }
 
    void setAspectRatio(float value);
 
    float getAspectRatio();
 
    void setBackgroundCornerRadii(float topLeft, float topRight, float bottomRight, float bottomLeft)
    {
        this->backgroundRadius = { topLeft, topRight, bottomRight, bottomLeft };
    }
 
    void setTranslationY(float translateY);
 
    void setTranslationX(float translateX);
 
    void setWireframeEnabled(bool wireframe);
 
    bool isWireframeEnabled();
 
    static std::string getStringXMLAttributeValue(std::string value);
 
    static std::string getFilePathXMLAttributeValue(std::string value);
 
    AppletFrameItem* getAppletFrameItem()
    {
        return &this->appletFrameItem;
    }
 
    void updateAppletFrameItem();
 
    bool getClipsToBounds() const
    {
        return clipsToBounds;
    }
 
    void setClipsToBounds(bool value)
    {
        clipsToBounds = value;
    }
 
    virtual AppletFrame* getAppletFrame();
 
    void present(View* view);
    virtual void dismiss(std::function<void(void)> cb = [] {});
 
    std::weak_ptr<void> aliveToken();
    void ptrLock();
    void ptrUnlock();
    bool isPtrLocked();
    void freeView();
 
    Activity* getParentActivity();
    void setParentActivity(Activity* activity);
 
    // -----------------------------------------------------------
    // State styles, transitions, bindings, accessibility
    // (docs/styles.md). Nothing is kept for a view that uses none.
    // -----------------------------------------------------------
 
    bool setStateStyle(StyleState state, const std::string& property, const std::string& value);
 
    void setStyleState(StyleState state, bool on);
    bool hasStyleState(StyleState state);
 
    bool setTransition(const std::string& spec);
 
    virtual bool getStyleProperty(const std::string& name, StyleValue* value);
    virtual bool setStyleProperty(const std::string& name, const StyleValue& value);
 
    void keepSubscription(Subscription&& subscription);
 
    bool bind(const std::string& spec);
 
    virtual bool setBoundText(const std::string& text) { return false; }
 
    void setAccessibilityRole(AccessibilityRole role);
    AccessibilityRole getAccessibilityRole();
    void setAccessibilityLabel(const std::string& label);
    std::string getAccessibilityLabel();
 
    void setAccessibilityValue(const std::string& value);
    std::string getAccessibilityValue();
 
    void setAccessibilitySelected(bool selected);
    bool isAccessibilitySelected();
 
    virtual bool getAccessibilityPosition(int* index, int* count);
 
    virtual std::string getAccessibilityDescription();
 
    std::string getAccessibilityText();
 
    void announceAccessibilityValue();
 
    void resolveBindings(Activity* activity = nullptr);
 
    virtual void onTextScaleChanged() { }
 
    bool setThemeColor(const std::string& property, const std::string& key);
 
    std::string getThemeColor(const std::string& property);
 
    virtual void onThemeChanged();
 
  protected:
    virtual AccessibilityRole getDefaultAccessibilityRole() { return AccessibilityRole::NONE; }
    virtual std::string getDefaultAccessibilityLabel() { return ""; }
    virtual std::string getDefaultAccessibilityValue() { return ""; }
    virtual bool getDefaultAccessibilitySelected() { return false; }
 
    bool transitionStyle(const char* name, const StyleValue& to)
    {
        return this->extras && this->startTransition(name, to);
    }
 
  private:
    friend class Application;
    std::shared_ptr<void> alive; 
    struct Extras;
    struct ExtrasDeleter
    {
        void operator()(Extras* extras) const;
    };
    std::unique_ptr<Extras, ExtrasDeleter> extras;
    Extras& getExtras();
    void noteStyleState(StyleState state, bool on);
    void notePress(bool pressed, bool releaseLater);
    void applyPendingStyles();
    bool hasStateStyle(StyleState state);
    bool startTransition(const char* name, const StyleValue& to);
    void updateStateStyles();
    bool bindOne(const std::string& property, const std::string& path, Activity* activity);
    static bool parseStyleValue(const std::string& text, StyleValue::Type type, StyleValue* value);
    static unsigned pendingBindings;
 
    struct ThemeColor
    {
        std::string property;
        std::string key;
        NVGcolor applied;
    };
    std::unique_ptr<std::vector<ThemeColor>> themeColors;
};
 
} // namespace aurore