UIView.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "UIAppearance.hpp"
#include "UIEvent.hpp"
#include "UILayout.hpp"
#include "UIResponder.hpp"
#include "UIUtility.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/InitializerList.hpp"
#include "CeresEngine/Foundation/Container/Optional.hpp"
#include "CeresEngine/Foundation/Container/Span.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Math/Rect.hpp"
 
#include <optional>
 
namespace CeresEngine {
 
    class UIWindow;
 
    class UIView;
    class UIViewController;
 
    class UIScrollView;
 
    template<typename T> using UIPtr = RC<T>;
 
    using UIViewPtr = UIPtr<UIView>;
 
    enum class UIViewState : UInt8 {
        NeedsTransformsUpdate = (1u << 0u),
        NeedsDisplay = (1u << 1u),
        NeedsLayout = (1u << 2u),
        NeedsConstraintUpdate = (1u << 3u),
        NeedsIntrinsicContentSizeUpdate = (1u << 4u),
        Visible = (1u << 5u),
        Active = (1u << 6u),
        AutoResize = (1u << 7u),
    };
 
    using UIViewStateFlags = Flags<UIViewState>;
    CE_FLAGS_OPERATORS(UIViewState);
 
    enum class UIViewAutoResizing : UInt8 {
        None = 0,
 
        FlexibleLeft = 1 << 0,
 
        Width = 1 << 1,
 
        FlexibleRight = 1 << 2,
 
        FlexibleBottom = 1 << 3,
 
        Height = 1 << 4,
 
        FlexibleTop = 1 << 5,
 
        Size = Width | Height,
 
        Position = FlexibleLeft | FlexibleRight | FlexibleTop | FlexibleBottom,
 
        All = Size | Position,
    };
    using UIViewAutoresizingMask = Flags<UIViewAutoResizing>;
    CE_FLAGS_OPERATORS(UIViewAutoResizing);
 
    extern const UISize UILayoutFittingCompressedSize;
 
    extern const UISize UILayoutFittingExpandedSize;
 
    class UIView : public UIResponder, public RefCounted<UIView, RefCounter<false>> {
        friend UIWindow;
        friend UIViewController;
 
    private:
        UIView* mSuperView = nullptr;
 
        Vector<UIView*> mSubViews;
 
        UIWindow* mWindow = nullptr;
 
        UIRect mFrame;
 
        UIRect mBounds;
 
        Optional<double> mContentScaleFactor = nullopt;
 
        bool mCustomBounds = false;
 
        UIViewStateFlags mFlags = UIViewState::NeedsDisplay | UIViewState::NeedsLayout | UIViewState::Visible | UIViewState::AutoResize |
            UIViewState::NeedsIntrinsicContentSizeUpdate;
 
        UIAppearancePtr mAppearance = nullptr;
 
        Optional<UIColor> mTintColor = std::nullopt;
 
        UIColor mBackgroundColor = UIColor::white;
 
        UICornerRadius mCornerRadius;
 
        bool mOpaque = false;
 
        UIViewAutoresizingMask mResizingMask = UIViewAutoResizing::Height | UIViewAutoResizing::Width;
 
        String mName;
 
        UIView* mNextKeyView = nullptr;
 
        UIView* mPreviousKeyView = nullptr;
 
        AffineTransform mTransformToWindow;
 
        AffineTransform mTransformFromWindow;
 
        AffineTransform mTransformToBacking;
 
        AffineTransform mTransformFromBacking;
 
        Vector<UIRect> mTrackingRects;
 
        UISize mIntrinsicContentSize;
 
        UIEdgeInsets mLayoutMargins;
 
        Vector<UIRect> mInvalidRects;
 
        mutable Vector<UIRect> mRectsBeingDrawn;
 
        UIViewController* mViewController = nullptr;
 
        UILayerPtr mLayer;
 
    private: // Layout & constraints
        UPtr<UILayoutSolver> mLayoutSolver;
 
        Vector<UILayoutAnchor> mLayoutAnchors;
 
    public:
        static const double kNoInstrinsicMetric;
 
        static const UISize kNoIntrinsicSize;
 
        static const UInt32 kInvalidViewIndex;
 
        static const UIRect kDefaultFrame;
 
    public:
        UIView();
 
        explicit UIView(const String& name);
 
        explicit UIView(const UIRect& frame, const String& name = "");
 
        explicit UIView(const UISize& size, const String& name = "") : UIView(UIPoint(0, 0), size, name) {}
 
        explicit UIView(const UIPoint& origin, const UISize& size, const String& name = "") : UIView(UIRect(origin, size), name) {}
 
        explicit UIView(const double x, const double y, const double width, const double height, const String& name = "")
                : UIView(UIRect(x, y, width, height), name) {}
 
        ~UIView() override;
 
    public: // View Hierarchy
        [[nodiscard]] UIView* getSuperView() const { return mSuperView; }
 
        [[nodiscard]] const Vector<UIView*>& getSubViews() const { return mSubViews; }
 
        void setSubViews(const Vector<UIView*>& subViews);
 
        [[nodiscard]] UInt32 getSubViewCount() const noexcept { return UInt32(mSubViews.size()); }
 
        [[nodiscard]] UIView* getSubView(UInt32 index) const;
 
        [[nodiscard]] UInt32 getSubViewIndex(const UIView* view) const;
 
        void addSubView(UIView* view);
 
        void addSubView(const UIViewPtr& view) { addSubView(view.get()); }
 
        template<typename T, typename... Args> T* addSubView(Args&&... args) {
            RC<T> subView = ce_counted_new<T>(std::forward<Args>(args)...);
            addSubView(static_cast<UIView*>(subView.get()));
            return subView.get();
        }
 
        void replaceSubView(UIView* view, UIView* replacement);
 
        void removeFromSuperview();
 
        [[nodiscard]] bool isDescendant(const UIView* view) const;
 
        UIView* getOpaqueAncestor() const;
 
        [[nodiscard]] virtual UIWindow* getWindow() const { return mWindow; }
 
    protected:
        virtual void didAddSubview(UIView& view);
 
        virtual void willRemoveSubview(UIView& view);
 
        virtual void didRemoveSubview(UIView& view);
 
        virtual void willMoveToSuperView(UIView* superView);
 
        virtual void didMoveToSuperView(UIView* superView);
 
        virtual void willMoveToWindow(UIWindow* window);
 
        virtual void didMoveToWindow(UIWindow* window);
 
        virtual void didHide();
 
        virtual void didUnhide();
 
        virtual void willDraw();
 
        virtual void tintColorDidChange();
 
    public: // Frame & Bounds Rectangle
        [[nodiscard]] UIRect getFrame() const { return mFrame; }
 
        virtual void setFrame(const UIRect& frame);
 
        void setFrame(const UIPoint& point, const UISize& size) { setFrame(UIRect(point, size)); }
 
        void setFrame(const UIPoint& point, const double width, const double height) { setFrame(UIRect(point, UISize(width, height))); }
 
        void setFrame(const double x, const double y, const UISize& size) { setFrame(UIRect(UIPoint(x, y), size)); }
 
        void setFrame(const double x, const double y, const double width, const double height) { setFrame(UIRect(UIPoint(x, y), UISize(width, height))); }
 
        void setFrameOrigin(const UIPoint& point) {
            UIRect newFrame = mFrame;
            newFrame.origin = point;
            setFrame(newFrame);
        }
 
        void setFrameOrigin(const double x, const double y) { setFrameOrigin(UIPoint(x, y)); }
 
        void setFrameSize(const UISize& size) {
            UIRect newFrame = mFrame;
            newFrame.size = size;
            setFrame(newFrame);
        }
 
        void setFrameSize(const double width, const double height) { setFrameSize(UISize(width, height)); }
 
        [[nodiscard]] UIRect getBounds() const { return mBounds; }
 
        virtual void setBounds(const UIRect& bounds);
 
        void setBounds(const UIPoint& point, const UISize& size) { setBounds(UIRect(point, size)); }
 
        void setBounds(const UIPoint& point, const double width, const double height) { setBounds(UIRect(point, UISize(width, height))); }
 
        void setBounds(const double x, const double y, const UISize& size) { setBounds(UIRect(UIPoint(x, y), size)); }
 
        void setBounds(const double x, const double y, const double width, const double height) { setBounds(UIRect(UIPoint(x, y), UISize(width, height))); }
 
        void setBoundsOrigin(const UIPoint& point) {
            UIRect newBounds = mBounds;
            newBounds.origin = point;
            setBounds(newBounds);
        }
 
        void setBoundsOrigin(const double x, const double y) { setBoundsOrigin(UIPoint(x, y)); }
 
        void setBoundsSize(const UISize& size) {
            UIRect newBounds = mBounds;
            newBounds.size = size;
            setBounds(newBounds);
        }
 
        void setBoundsSize(const double width, const double height) { setBoundsSize(UISize(width, height)); }
 
    protected:
        virtual void didChangeFrame(const UIRect& oldFrame) {}
 
        virtual void didChangeBounds(const UIRect& oldBounds) {}
 
    public: // Event Handling
        [[nodiscard]] virtual bool acceptsFirstMouse(const UIEvent& theEvent) { return false; }
 
        [[nodiscard]] UIView* hitTest(UIPoint aPoint, const Optional<const UIEvent&>& event = nullopt);
 
        [[nodiscard]] virtual bool isPointInside(const UIPoint& point, const Optional<const UIEvent&>& event = nullopt);
 
        [[nodiscard]] bool isMousePoint(const UIPoint& aPoint, const UIRect& aRect);
 
        [[nodiscard]] virtual bool getMouseDownCanMoveWindow() const { return !isOpaque(); }
 
    public:
        [[nodiscard]] const UIAppearance& getAppearance() const noexcept;
 
        void setAppearance(UIAppearance* appearance);
 
        [[nodiscard]] UIColor getTintColor() const;
 
        void setTintColor(const UIColor& color);
 
        void clearTintColor();
 
        [[nodiscard]] const UIColor& getBackgroundColor() const noexcept { return mBackgroundColor; }
 
        void setBackgroundColor(const UIColor& color);
 
        [[nodiscard]] const UICornerRadius& getCornerRadius() const noexcept { return mCornerRadius; }
 
        void setCornerRadius(const UICornerRadius& color);
 
        [[nodiscard]] double getAlpha() const noexcept { return mBackgroundColor.a; }
 
        void setAlpha(double alpha);
 
        [[nodiscard]] bool isOpaque() const noexcept { return mOpaque; }
 
        void setOpaque(bool isOpaque);
 
        [[nodiscard]] UIRect getVisibleRect() const;
 
        [[nodiscard]] bool isVisible() const;
 
        void setVisible(bool visible);
 
        [[nodiscard]] bool isHidden() const { return !isVisible(); }
 
        void setHidden(const bool hidden) { setVisible(!hidden); }
 
        [[nodiscard]] bool isHiddenOrHasHiddenAncestor() const;
 
        [[nodiscard]] bool isActive() const;
 
        void setActive(bool active);
 
    public: // Resizing Subviews
        [[nodiscard]] bool getAutoresizesSubViews() const;
 
        void setAutoresizesSubViews(bool state);
 
        [[nodiscard]] const UIViewAutoresizingMask& getAutoresizingMask() const { return mResizingMask; }
 
        void setAutoresizingMask(const UIViewAutoresizingMask& autoresizingMask);
 
        virtual void resizeSubviews(const UISize& oldBoundsSize);
 
        virtual void resize(const UISize& oldBoundsSize);
 
        [[nodiscard]] virtual UISize getIntrinsicContentSize() const;
 
    protected:
        void invalidateIntrinsicContentSize();
 
        void updateIntrinsicContentSize();
 
    public: // Layout
        [[nodiscard]] bool getNeedsLayout() const;
 
        void setNeedsLayout();
 
        void setNeedsLayout(bool state);
 
        void layout();
 
        void layoutIfNeeded();
 
        virtual void layoutSubviews();
 
        [[nodiscard]] virtual UISize calculateFittingLayoutSize(const UISize& targetSize) const;
 
        [[nodiscard]] UISize calculateMinimumLayoutSize() const { return calculateFittingLayoutSize(UILayoutFittingCompressedSize); }
 
        [[nodiscard]] UISize calculateMaximumLayoutSize() const { return calculateFittingLayoutSize(UILayoutFittingExpandedSize); }
 
    public: // Managing the View's Constraints
        [[nodiscard]] bool getNeedsUpdateConstraints() const;
 
        void setNeedsUpdateConstraints();
 
        void setNeedsUpdateConstraints(bool state);
 
        virtual void updateConstraints();
 
        void updateConstraintsIfNeeded();
 
        [[nodiscard]] Span<const UILayoutConstraint> getConstraints() const;
 
        void setConstraints(Vector<UILayoutConstraint>&& constraints);
 
        void setConstraints(const Span<const UILayoutConstraint>& constraints);
 
        void addConstraint(const UILayoutConstraint& constraint);
 
        void addConstraints(const Span<const UILayoutConstraint>& constraints);
 
        void addConstraints(const InitializerList<UILayoutConstraint> constraints) {
            return addConstraints(Span<const UILayoutConstraint>(constraints.begin(), constraints.end()));
        }
 
        void removeConstraint(const UILayoutConstraint& constraint);
 
        void removeConstraints(const Span<const UILayoutConstraint>& constraints);
 
        void removeConstraints(const InitializerList<UILayoutConstraint> constraints) {
            return removeConstraints(Span<const UILayoutConstraint>(constraints.begin(), constraints.end()));
        }
 
        [[nodiscard]] const UIEdgeInsets& getLayoutMargins() const { return mLayoutMargins; }
 
        void setLayoutMargins(const UIEdgeInsets& layoutMargins);
 
        [[nodiscard]] double getLayoutTopMargin() const { return mLayoutMargins.top; }
 
        void setTopLayoutMargin(double topLayoutMargin);
 
        [[nodiscard]] double getBottomLayoutMargin() const { return mLayoutMargins.bottom; }
 
        void setBottomLayoutMargin(double bottomLayoutMargin);
 
        [[nodiscard]] double getLeftLayoutMargin() const { return mLayoutMargins.left; }
 
        void setLeftLayoutMargin(double leftLayoutMargin);
 
        [[nodiscard]] double getRightLayoutMargin() const { return mLayoutMargins.right; }
 
        void setRightLayoutMargin(double rightLayoutMargin);
 
        const UILayoutAnchor left;
 
        const UILayoutAnchor right;
 
        const UILayoutAnchor top;
 
        const UILayoutAnchor bottom;
 
        const UILayoutAnchor width;
 
        const UILayoutAnchor height;
 
        const UILayoutAnchor centerX;
 
        const UILayoutAnchor centerY;
 
        const UILayoutAnchor lastBaseline;
 
        const UILayoutAnchor firstBaseline;
 
        const UILayoutAnchor leftMargin;
 
        const UILayoutAnchor rightMargin;
 
        const UILayoutAnchor topMargin;
 
        const UILayoutAnchor bottomMargin;
 
        const UILayoutAnchor centerXWithinMargins;
 
        const UILayoutAnchor centerYWithinMargins;
 
    private:
        friend class UILayoutAnchorVariable;
 
        [[nodiscard]] UILayoutSolver& ensureLayoutSolver();
 
        void registerLayoutAnchor(const UILayoutAnchor& layoutAnchor);
 
    public: // Display & View Dirty State
        void setNeedsDisplay();
 
        void setNeedsDisplay(const UIRect& invalidRect);
 
        [[nodiscard]] bool getNeedsDisplay() const;
 
        void display(UIGraphicsContext& context);
 
        void display(UIGraphicsContext& context, const UIRect& aRect);
 
        void displayIgnoringOpacity(UIGraphicsContext& context);
 
        virtual void displayIgnoringOpacity(UIGraphicsContext& context, const UIRect& aRect);
 
        void displayIfNeeded(UIGraphicsContext& context);
 
        void displayIfNeeded(UIGraphicsContext& context, const UIRect& aRect);
 
        void displayIfNeededIgnoringOpacity(UIGraphicsContext& context);
 
        void displayIfNeededIgnoringOpacity(UIGraphicsContext& context, const UIRect& aRect);
 
    public: // Drawing
        bool canDraw() const;
 
        virtual void draw(UIGraphicsContext& context, const UIRect& dirtyRect);
 
        [[nodiscard]] const Vector<UIRect>& getRectsBeingDrawn() const;
 
        [[nodiscard]] bool needsToDraw(const UIRect& aRect) const noexcept;
 
        [[nodiscard]] virtual bool getClearsContextBeforeDrawing() const noexcept { return true; }
 
        [[nodiscard]] virtual bool getClipsToBounds() const { return true; }
 
        [[nodiscard]] double getContentScaleFactor() const;
 
        void setContentScaleFactor(const Optional<double>& contentScaleFactor);
 
    public: // First responder state
        [[nodiscard]] bool isFirstResponder() const noexcept;
 
    public: // UIScrollView accessor
        [[nodiscard]] virtual UIScrollView* getScrollView() const;
 
    public: // Key-view Loop Management
        [[nodiscard]] virtual bool canBecomeKeyView() const { return false; }
 
        [[nodiscard]] virtual bool needsPanelToBecomeKey() const { return false; }
 
        [[nodiscard]] UIView* getNextKeyView() const { return mNextKeyView; }
 
        void setNextKeyView(UIView* nextKeyView);
 
        [[nodiscard]] UIView* getNextValidKeyView() const;
 
        [[nodiscard]] UIView* getPreviousKeyView() const { return mPreviousKeyView; }
 
        [[nodiscard]] UIView* getPreviousValidKeyView() const;
 
    public: // Converting Coordinate Values
        [[nodiscard]] AffineTransform getTransformFrom(const UIView* aView = nullptr) const;
 
        [[nodiscard]] const AffineTransform& getTransformFromWindow() const;
 
        [[nodiscard]] AffineTransform getTransformFromSuperView() const { return getTransformFrom(mSuperView); }
 
        [[nodiscard]] const AffineTransform& getTransformFromBacking() const;
 
        [[nodiscard]] AffineTransform getTransformTo(const UIView* aView = nullptr) const;
 
        [[nodiscard]] const AffineTransform& getTransformToWindow() const;
 
        [[nodiscard]] AffineTransform getTransformToSuperView() const { return getTransformTo(mSuperView); }
 
        [[nodiscard]] const AffineTransform& getTransformToBacking() const;
 
        [[nodiscard]] UIPoint convertFrom(const UIPoint& aPoint, const UIView* aView = nullptr) const;
 
        [[nodiscard]] UIPoint convertFromWindow(const UIPoint& aPoint) const { return convertFrom(aPoint); }
 
        [[nodiscard]] UIPoint convertFromSuperView(const UIPoint& aPoint) const { return convertFrom(aPoint, mSuperView); }
 
        [[nodiscard]] UIPoint convertFromBacking(const UIPoint& aPoint) const;
 
        [[nodiscard]] UIPoint convertTo(const UIPoint& aPoint, const UIView* aView = nullptr) const;
 
        [[nodiscard]] UIPoint convertToWindow(const UIPoint& aPoint) const { return convertTo(aPoint); }
 
        [[nodiscard]] UIPoint convertToSuperView(const UIPoint& aPoint) const { return convertTo(aPoint, mSuperView); }
 
        [[nodiscard]] UIPoint convertToBacking(const UIPoint& aPoint) const;
 
        [[nodiscard]] UISize convertFrom(const UISize& aSize, const UIView* aView = nullptr) const;
 
        [[nodiscard]] UISize convertFromWindow(const UISize& aSize) const { return convertFrom(aSize); }
 
        [[nodiscard]] UISize convertFromSuperView(const UISize& aSize) const { return convertFrom(aSize, mSuperView); }
 
        [[nodiscard]] UISize convertFromBacking(const UISize& aSize) const;
 
        [[nodiscard]] UISize convertTo(const UISize& aSize, const UIView* aView = nullptr) const;
 
        [[nodiscard]] UISize convertToWindow(const UISize& aSize) const { return convertTo(aSize); }
 
        [[nodiscard]] UISize convertToSuperView(const UISize& aSize) const { return convertTo(aSize, mSuperView); }
 
        [[nodiscard]] UISize convertToBacking(const UISize& aSize) const;
 
        [[nodiscard]] UIRect convertFrom(const UIRect& aRect, const UIView* aView = nullptr) const;
 
        [[nodiscard]] UIRect convertFromWindow(const UIRect& aRect) const { return convertFrom(aRect); }
 
        [[nodiscard]] UIRect convertFromSuperView(const UIRect& aRect) const { return convertFrom(aRect, mSuperView); }
 
        [[nodiscard]] UIRect convertFromBacking(const UIRect& aRect) const;
 
        [[nodiscard]] UIRect convertTo(const UIRect& aRect, const UIView* aView = nullptr) const;
 
        [[nodiscard]] UIRect convertToWindow(const UIRect& aRect) const { return convertTo(aRect); }
 
        [[nodiscard]] UIRect convertToSuperView(const UIRect& aRect) const { return convertTo(aRect, mSuperView); }
 
        [[nodiscard]] UIRect convertToBacking(const UIRect& aRect) const;
 
    private:
        void invalidateTransforms();
 
        void updateTransformsIfNeeded();
 
        void invalidateBackingStore();
 
    private: // Hierarchy management
        void setWindow(UIWindow* window);
        void setSuperView(UIView* superView);
        void insertSubView(UIView* view, UInt32 index);
 
    public: // UIViewController
        [[nodiscard]] UIViewController* getViewController() const noexcept { return mViewController; }
 
    private:
        void setViewController(UIViewController* viewController);
 
    public: // Debugging helpers
        [[nodiscard]] const String& getName() const { return mName; }
 
        void setName(const String& name);
 
        [[nodiscard]] virtual StringView getTypeName() const;
 
        //    public: // Context Menus
        //        /// Overridden by subclasses to return a context-sensitive pop-up menu
        //        /// for a given mouse-down event.
        //        virtual UIMenu getMenu(const UIEvent& event);
        //
        //        /// Called just before a contextual menu for a view is opened on screen.
        //        virtual void willOpenMenu(UIMenu& menu, const UIEvent& event);
        //
        //        /// Called after a contextual menu that was displayed from the receiving
        //        /// view has been closed.
        //        virtual void didCloseMenu(UIMenu& menu, const UIEvent& event);
 
    public: // UIResponder
        [[nodiscard]] UIResponder* getNextResponder() const final;
 
    public: // Appearance properties
        static const UIColorAppearanceProperty tintColorProperty;
 
    public: // Semantic Appearance Properties
 
        static const UIPaintAppearanceProperty labelPaintProperty;
 
        static const UIPaintAppearanceProperty secondaryLabelPaintProperty;
 
        static const UIPaintAppearanceProperty tertiaryLabelPaintProperty;
 
        static const UIPaintAppearanceProperty quaternaryLabelPaintProperty;
 
 
        static const UIPaintAppearanceProperty textPaintProperty;
 
        static const UIPaintAppearanceProperty placeholderTextPaintProperty;
 
        static const UIPaintAppearanceProperty selectedTextPaintProperty;
 
        static const UIPaintAppearanceProperty textBackgroundPaintProperty;
 
        static const UIPaintAppearanceProperty selectedTextBackgroundPaintProperty;
 
        static const UIPaintAppearanceProperty keyboardFocusIndicatorPaintProperty;
 
        static const UIPaintAppearanceProperty unemphasizedSelectedTextPaintProperty;
 
        static const UIPaintAppearanceProperty unemphasizedSelectedTextBackgroundPaintProperty;
 
 
        static const UIPaintAppearanceProperty linkPaintProperty;
 
        static const UIPaintAppearanceProperty separatorPaintProperty;
 
        static const UIPaintAppearanceProperty selectedContentBackgroundPaintProperty;
 
        static const UIPaintAppearanceProperty unemphasizedSelectedContentBackgroundPaintProperty;
 
 
        static const UIPaintAppearanceProperty selectedMenuItemTextPaintProperty;
 
 
        static const UIPaintAppearanceProperty gridPaintProperty;
 
        static const UIPaintAppearanceProperty headerTextPaintProperty;
 
        static const UIPaintAppearanceProperty alternatingContentBackgroundColorsProperty;
 
 
        static const UIPaintAppearanceProperty controlAccentPaintProperty;
 
        static const UIPaintAppearanceProperty controlPaintProperty;
 
        static const UIPaintAppearanceProperty controlBackgroundPaintProperty;
 
        static const UIPaintAppearanceProperty controlTextPaintProperty;
 
        static const UIPaintAppearanceProperty disabledControlTextPaintProperty;
 
        static const UIPaintAppearanceProperty currentControlTintProperty;
 
        static const UIPaintAppearanceProperty selectedControlPaintProperty;
 
        static const UIPaintAppearanceProperty selectedControlTextPaintProperty;
 
        static const UIPaintAppearanceProperty alternateSelectedControlTextPaintProperty;
 
        static const UIPaintAppearanceProperty scrubberTexturedBackgroundPaintProperty;
 
 
        static const UIPaintAppearanceProperty windowBackgroundPaintProperty;
 
        static const UIPaintAppearanceProperty windowFrameTextPaintProperty;
 
        static const UIPaintAppearanceProperty underPageBackgroundPaintProperty;
 
 
        static const UIPaintAppearanceProperty findHighlightPaintProperty;
 
        static const UIPaintAppearanceProperty highlightPaintProperty;
 
        static const UIPaintAppearanceProperty shadowPaintProperty;
 
    public: // Font and sizes
        static const UIFontAppearanceProperty fontProperty;
 
        static const UIFloatAppearanceProperty fontSizeProperty;
    };
 
} // namespace CeresEngine