View.c

Go to the documentation of this file.

/*
 * ObjectivelyMVC: Object oriented MVC framework for OpenGL, SDL2 and GNU C.
 * Copyright (C) 2014 Jay Dolan <jay@jaydolan.com>
 *
 * 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.
 */
 
#include <assert.h>
#include <string.h>
 
#include <Objectively.h>
 
#include "Log.h"
#include "View.h"
#include "ViewController.h"
#include "Window.h"
 
const EnumName ViewAlignmentNames[] = MakeEnumNames(
    MakeEnumAlias(ViewAlignmentNone, none),
    MakeEnumAlias(ViewAlignmentTop, top),
    MakeEnumAlias(ViewAlignmentMiddle, middle),
    MakeEnumAlias(ViewAlignmentBottom, bottom),
    MakeEnumAlias(ViewAlignmentLeft, left),
    MakeEnumAlias(ViewAlignmentCenter, center),
    MakeEnumAlias(ViewAlignmentRight, right),
    MakeEnumAlias(ViewAlignmentTopLeft, top-left),
    MakeEnumAlias(ViewAlignmentTopCenter, top-center),
    MakeEnumAlias(ViewAlignmentTopRight, top-right),
    MakeEnumAlias(ViewAlignmentMiddleLeft, middle-left),
    MakeEnumAlias(ViewAlignmentMiddleCenter, middle-center),
    MakeEnumAlias(ViewAlignmentMiddleRight, middle-right),
    MakeEnumAlias(ViewAlignmentBottomLeft, bottom-left),
    MakeEnumAlias(ViewAlignmentBottomCenter, bottom-center),
    MakeEnumAlias(ViewAlignmentBottomRight, bottom-right),
    MakeEnumAlias(ViewAlignmentInternal, internal)
);
 
const EnumName ViewAutoresizingNames[] = MakeEnumNames(
    MakeEnumAlias(ViewAutoresizingNone, none),
    MakeEnumAlias(ViewAutoresizingWidth, width),
    MakeEnumAlias(ViewAutoresizingHeight, height),
    MakeEnumAlias(ViewAutoresizingFill, fill),
    MakeEnumAlias(ViewAutoresizingFit, fit),
    MakeEnumAlias(ViewAutoresizingContain, contain)
);
 
#define _Class _View
 
#pragma mark - ObjectInterface
 
static void dealloc(Object *self) {
 
    View *this = (View *) self;
 
    free(this->identifier);
 
    release(this->classNames);
    release(this->computedStyle);
    release(this->style);
    release(this->stylesheet);
    release(this->subviews);
    release(this->warnings);
 
    this->superview = NULL;
 
    super(Object, self, dealloc);
}
 
static String *description(const Object *self) {
 
    View *this = (View *) self;
 
    String *classNames = $((Object *) this->classNames, description);
    String *description = str("%s@%p %s [%d, %d, %d, %d]",
                              classnameof(self),
                              self,
                              classNames->chars,
                              this->frame.x, this->frame.y, this->frame.w, this->frame.h);
 
    release(classNames);
    return description;
}
 
#pragma mark - View
 
static _Bool acceptsFirstResponder(const View *self) {
    return false;
}
 
static void addClassName(View *self, const char *className) {
 
    if (className) {
 
        String *string = $$(String, stringWithCharacters, className);
        assert(string);
 
        $(self->classNames, addObject, string);
        release(string);
 
        $(self, invalidateStyle);
    }
}
 
static void addSubview(View *self, View *subview) {
    $(self, addSubviewRelativeTo, subview, NULL, ViewPositionAfter);
}
 
static void addSubviewRelativeTo(View *self, View *subview, View *other, ViewPosition position) {
 
    assert(subview);
    assert(subview != other);
 
    retain(subview);
 
    $(subview, removeFromSuperview);
 
    if (other && other->superview == self) {
 
        const Array *subviews = (Array *) self->subviews;
        const ssize_t index = $(subviews, indexOfObject, other);
 
        if (position == ViewPositionAfter) {
            if (index == (ssize_t) (subviews->count - 1)) {
                $(self->subviews, addObject, subview);
            } else {
                $(self->subviews, insertObjectAtIndex, subview, index + 1);
            }
        } else {
            $(self->subviews, insertObjectAtIndex, subview, index);
        }
    } else {
        $(self->subviews, addObject, subview);
    }
 
    release(subview);
 
    subview->superview = self;
 
    $(subview, moveToWindow, self->window);
 
    $(subview, invalidateStyle);
 
    self->needsLayout = true;
}
 
static View *ancestorWithIdentifier(const View *self, const char *identifier) {
 
    assert(identifier);
 
    View *view = (View *) self;
    while (view) {
        if (view->identifier) {
            if (strcmp(identifier, view->identifier) == 0) {
                return view;
            }
        }
        view = view->superview;
    }
 
    return NULL;
}
 
static void applyStyle(View *self, const Style *style) {
 
    assert(style);
 
    const Inlet inlets[] = MakeInlets(
        MakeInlet("alignment", InletTypeEnum, &self->alignment, (ident) ViewAlignmentNames),
        MakeInlet("autoresizing-mask", InletTypeEnum, &self->autoresizingMask, (ident) ViewAutoresizingNames),
        MakeInlet("background-color", InletTypeColor, &self->backgroundColor, NULL),
        MakeInlet("border-color", InletTypeColor, &self->borderColor, NULL),
        MakeInlet("border-width", InletTypeInteger, &self->borderWidth, NULL),
        MakeInlet("clips-subviews", InletTypeBool, &self->clipsSubviews, NULL),
        MakeInlet("frame", InletTypeRectangle, &self->frame, NULL),
        MakeInlet("hidden", InletTypeBool, &self->hidden, NULL),
        MakeInlet("height", InletTypeInteger, &self->frame.h, NULL),
        MakeInlet("left", InletTypeInteger, &self->frame.x, NULL),
        MakeInlet("max-height", InletTypeInteger, &self->maxSize.h, NULL),
        MakeInlet("max-size", InletTypeSize, &self->maxSize, NULL),
        MakeInlet("max-width", InletTypeInteger, &self->maxSize.w, NULL),
        MakeInlet("min-height", InletTypeInteger, &self->minSize.h, NULL),
        MakeInlet("min-size", InletTypeSize, &self->minSize, NULL),
        MakeInlet("min-width", InletTypeInteger, &self->minSize.w, NULL),
        MakeInlet("padding", InletTypeRectangle, &self->padding, NULL),
        MakeInlet("padding-top", InletTypeInteger, &self->padding.top, NULL),
        MakeInlet("padding-right", InletTypeInteger, &self->padding.right, NULL),
        MakeInlet("padding-bottom", InletTypeInteger, &self->padding.bottom, NULL),
        MakeInlet("padding-left", InletTypeInteger, &self->padding.left, NULL),
        MakeInlet("top", InletTypeInteger, &self->frame.y, NULL),
        MakeInlet("width", InletTypeInteger, &self->frame.w, NULL)
    );
 
    $(self, bind, inlets, style->attributes);
}
 
static void applyTheme(View *self, const Theme *theme) {
 
    assert(theme);
 
    Style *computedStyle = $(theme, computeStyle, self);
    assert(computedStyle);
 
    if (!$(self->computedStyle, isComputedEqual, computedStyle)) {
 
        release(self->computedStyle);
        self->computedStyle = retain(computedStyle);
 
        $(self->computedStyle, addAttributes, self->style->attributes);
        $(self, applyStyle, self->computedStyle);
    }
 
    release(computedStyle);
}
 
static void applyThemeIfNeeded(View *self, const Theme *theme) {
 
    assert(theme);
 
    if (self->needsApplyTheme) {
        $(self, applyTheme, theme);
    }
 
    self->needsApplyTheme = false;
 
    $(self, enumerateSubviews, (ViewEnumerator) applyThemeIfNeeded, (ident) theme);
}
 
static void attachStylesheet(View *self, SDL_Window *window) {
 
    assert(window);
 
    if (self->stylesheet) {
        Theme *theme = $$(Theme, theme, window);
        if (theme) {
            $(theme, addStylesheet, self->stylesheet);
        }
    }
}
 
static void awakeWithCharacters(View *self, const char *chars) {
 
    Data *data = $$(Data, dataWithConstMemory, (uint8_t *) chars, strlen(chars));
 
    $(self, awakeWithData, data);
 
    release(data);
}
 
static void awakeWithData(View *self, const Data *data) {
 
    Dictionary *dictionary = $$(JSONSerialization, objectFromData, data, 0);
 
    $(self, awakeWithDictionary, dictionary);
 
    release(dictionary);
}
 
static void awakeWithDictionary(View *self, const Dictionary *dictionary) {
 
    assert(dictionary);
 
    const Inlet inlets[] = MakeInlets(
        MakeInlet("identifier", InletTypeCharacters, &self->identifier, NULL),
        MakeInlet("classNames", InletTypeClassNames, &self, NULL),
        MakeInlet("style", InletTypeStyle, &self, NULL),
        MakeInlet("subviews", InletTypeSubviews, &self, NULL)
    );
 
    $(self, bind, inlets, dictionary);
}
 
static void awakeWithResource(View *self, const Resource *resource) {
 
    assert(resource);
 
    $(self, awakeWithData, resource->data);
}
 
static void awakeWithResourceName(View *self, const char *name) {
 
    Resource *resource = $$(Resource, resourceWithName, name);
 
    $(self, awakeWithResource, resource);
 
    release(resource);
}
 
static void becomeFirstResponder(View *self) {
    $$(View, setFirstResponder, self->window, self);
}
 
static _Bool _bind(View *self, const Inlet *inlets, const Dictionary *dictionary) {
 
    if (inlets) {
        if (bindInlets(inlets, dictionary)) {
            self->needsLayout = true;
            return true;
        }
    }
 
    return false;
}
 
static SDL_Rect bounds(const View *self) {
 
    const SDL_Size size = $(self, size);
 
    const SDL_Rect bounds = {
        .x = self->padding.left,
        .y = self->padding.top,
        .w = size.w - (self->padding.left + self->padding.right),
        .h = size.h - (self->padding.top + self->padding.bottom),
    };
 
    return bounds;
}
 
static void bringSubviewToFront(View *self, View *subview) {
 
    assert(subview);
 
    if (subview->superview == self) {
 
        View *last = $((Array *) self->subviews, lastObject);
        if (last != subview) {
            $(self, addSubviewRelativeTo, subview, last, ViewPositionAfter);
        }
    }
}
 
static SDL_Rect clippingFrame(const View *self) {
 
    SDL_Rect frame = $(self, renderFrame);
 
    if (self->borderWidth && self->borderColor.a) {
        for (int i = 0; i < self->borderWidth; i++) {
            frame.x -= 1;
            frame.y -= 1;
            frame.w += 2;
            frame.h += 2;
        }
    }
 
    const View *superview = self->superview;
    while (superview) {
        if (superview->clipsSubviews) {
            const SDL_Rect clippingFrame = $(superview, clippingFrame);
            if (SDL_IntersectRect(&clippingFrame, &frame, &frame) == false) {
 
                if (MVC_LogEnabled(SDL_LOG_PRIORITY_VERBOSE)) {
                    String *desc = $((Object *) self, description);
                    String *superdesc = $((Object *) superview, description);
 
                    MVC_LogVerbose("%s is clipped by %s\n", desc->chars, superdesc->chars);
 
                    release(desc);
                    release(superdesc);
                }
 
                frame.w = frame.h = 0;
                break;
            }
        }
        superview = superview->superview;
    }
 
    return frame;
}
 
static _Bool containsPoint(const View *self, const SDL_Point *point) {
 
    const SDL_Rect frame = $(self, clippingFrame);
 
    return (_Bool) !!SDL_PointInRect(point, &frame);
}
 
static int depth(const View *self) {
    return (self->superview ? $(self->superview, depth) + 1 : 0);
}
 
static View *descendantWithIdentifier(const View *self, const char *identifier) {
 
    assert(identifier);
 
    if (self->identifier) {
        if (strcmp(identifier, self->identifier) == 0) {
            return (View *) self;
        }
    }
 
    const Array *subviews = (Array *) self->subviews;
    for (size_t i = 0; i < subviews->count; i++) {
        const View *subview = $(subviews, objectAtIndex, i);
        View *descendant = $(subview, descendantWithIdentifier, identifier);
        if (descendant) {
            return descendant;
        }
    }
 
    return NULL;
}
 
static void detachStylesheet(View *self, SDL_Window *window) {
 
    assert(window);
 
    if (self->stylesheet) {
        Theme *theme = $$(Theme, theme, window);
        if (theme) {
            $(theme, removeStylesheet, self->stylesheet);
        }
    }
}
 
static void didMoveToWindow(View *self, SDL_Window *window) {
 
    if (window) {
        $(self, attachStylesheet, window);
 
        self->needsLayout = true;
    }
}
 
static _Bool didReceiveEvent(const View *self, const SDL_Event *event) {
 
    if ($(self, isVisible)) {
 
        SDL_Point point;
 
        if (event->type == SDL_MOUSEBUTTONDOWN || event->type == SDL_MOUSEBUTTONUP) {
            point = MakePoint(event->button.x, event->button.y);
        } else if (event->type == SDL_MOUSEMOTION) {
            point = MakePoint(event->motion.x, event->motion.y);
        } else if (event->type == SDL_MOUSEWHEEL) {
            SDL_GetMouseState(&point.x, &point.y);
        } else {
            return false;
        }
 
        return $(self, containsPoint, &point);
    }
 
    return false;
}
 
static void draw(View *self, Renderer *renderer) {
 
    assert(self->window);
 
    if (self->hidden == false) {
 
        $(renderer, drawView, self);
 
        $(self, enumerateSubviews, (ViewEnumerator) draw, renderer);
    }
}
 
static void enumerate(View *self, ViewEnumerator enumerator, ident data) {
 
    assert(enumerator);
 
    enumerator(self, data);
 
    $(self, enumerateDescendants, enumerator, data);
}
 
static void enumerateAdjacent(const View *self, ViewEnumerator enumerator, ident data) {
 
    assert(enumerator);
 
    if (self->superview) {
        const Array *siblings = (Array *) self->superview->subviews;
        const ssize_t index = $(siblings, indexOfObject, (const ident) self);
        if (index > 0) {
            enumerator($(siblings, objectAtIndex, index - 1), data);
        }
        if (index < (ssize_t) (siblings->count - 1)) {
            enumerator($(siblings, objectAtIndex, index + 1), data);
        }
    }
}
 
static void enumerateAncestors(const View *self, ViewEnumerator enumerator, ident data) {
 
    assert(enumerator);
 
    for (View *view = self->superview; view; view = view->superview) {
        enumerator(view, data);
    }
}
 
static void enumerateSelection(View *self, const char *rule, ViewEnumerator enumerator, ident data) {
 
    Selector *selector = $(alloc(Selector), initWithRule, rule);
    assert(selector);
 
    $(selector, enumerateSelection, self, enumerator, data);
    release(selector);
}
 
static void enumerateDescendants(const View *self, ViewEnumerator enumerator, ident data) {
 
    assert(enumerator);
 
    const Array *subviews = (Array *) self->subviews;
    for (size_t i = 0; i < subviews->count; i++) {
 
        View *subview = $(subviews, objectAtIndex, i);
        enumerator(subview, data);
 
        $(subview, enumerateDescendants, enumerator, data);
    }
}
 
static void enumerateSiblings(const View *self, ViewEnumerator enumerator, ident data) {
 
    assert(enumerator);
 
    if (self->superview) {
 
        const Array *siblings = (Array *) self->superview->subviews;
        for (size_t i = 0; i < siblings->count; i++) {
            View *sibling = $(siblings, objectAtIndex, i);
            if (sibling != self) {
                enumerator(sibling, data);
            }
        }
    }
}
 
static void enumerateSubviews(const View *self, ViewEnumerator enumerator, ident data) {
 
    assert(enumerator);
 
    const Array *subviews = (Array *) self->subviews;
    for (size_t i = 0; i < subviews->count; i++) {
        enumerator((View *) subviews->elements[i], data);
    }
}
 
static void enumerateSuperview(const View *self, ViewEnumerator enumerator, ident data) {
 
    assert(enumerator);
 
    if (self->superview) {
        enumerator(self->superview, data);
    }
}
 
static View *firstResponder(SDL_Window *window) {
 
    assert(window);
 
    return SDL_GetWindowData(window, "firstResponder");
}
 
static _Bool hasClassName_predicate(const ident obj, ident data) {
    return strcmp(((String *) obj)->chars, (const char *) data) == 0;
}
 
static _Bool hasClassName(const View *self, const char *className) {
 
    if (className) {
        return $((Set *) self->classNames, containsObjectMatching, hasClassName_predicate, (ident) className);
    }
 
    return false;
}
 
static View *hitTest(const View *self, const SDL_Point *point) {
 
    if (self->hidden == false) {
 
        if ($(self, containsPoint, point)) {
 
            const Array *subviews = (Array *) self->subviews;
            for (size_t i = subviews->count; i; i--) {
 
                const View *subview = $(subviews, objectAtIndex, i - 1);
                const View *view = $(subview, hitTest, point);
                if (view) {
                    return (View *) view;
                }
            }
 
            return (View *) self;
        }
    }
 
    return NULL;
}
 
static View *init(View *self) {
    return $(self, initWithFrame, NULL);
}
 
static View *initWithFrame(View *self, const SDL_Rect *frame) {
 
    self = (View *) super(Object, self, init);
    if (self) {
 
        if (frame) {
            self->frame = *frame;
        }
 
        self->classNames = $$(MutableSet, setWithCapacity, 0);
        assert(self->classNames);
 
        self->computedStyle = $(alloc(Style), initWithAttributes, NULL);
        assert(self->computedStyle);
 
        self->subviews = $$(MutableArray, arrayWithCapacity, 0);
        assert(self->subviews);
 
        self->style = $(alloc(Style), initWithAttributes, NULL);
        assert(self->style);
 
        self->warnings = $$(MutableArray, arrayWithCapacity, 0);
        assert(self->warnings);
 
        self->maxSize = MakeSize(INT32_MAX, INT32_MAX);
 
        self->needsApplyTheme = true;
        self->needsLayout = true;
    }
 
    return self;
}
 
static void invalidateStyle_enumerate(View *view, ident data) {
    view->needsApplyTheme = true;
}
 
static void invalidateStyle(View *self) {
    $(self, enumerate, invalidateStyle_enumerate, NULL);
}
 
static _Bool isContainer(const View *self) {
    return self->autoresizingMask & (ViewAutoresizingFit | ViewAutoresizingContain);
}
 
static _Bool isDescendantOfView(const View *self, const View *view) {
 
    assert(view);
 
    while (self) {
        if (self == view) {
            return true;
        }
        self = self->superview;
    }
 
    return false;
}
 
static _Bool isFirstResponder(const View *self) {
 
    if (self->window) {
        return $$(View, firstResponder, self->window) == self;
    } else {
        return false;
    }
}
 
static _Bool isVisible(const View *self) {
 
    for (const View *view = self; view; view = view->superview) {
        if (view->hidden) {
            return false;
        }
    }
 
    return true;
}
 
static void layoutIfNeeded_recurse(View *subview, ident data) {
    $(subview, layoutIfNeeded);
}
 
static void layoutIfNeeded(View *self) {
 
    if (self->needsLayout) {
        $(self, layoutSubviews);
 
        if (MVC_LogEnabled(SDL_LOG_PRIORITY_DEBUG)) {
 
            if (self->hidden == false && self->superview && self->superview->clipsSubviews) {
 
                const SDL_Rect bounds = $(self, bounds);
                const SDL_Rect superviewBounds = $(self->superview, bounds);
 
                if (bounds.x + bounds.w > superviewBounds.w ||
                    bounds.y + bounds.h > superviewBounds.h) {
 
                    String *this = $((Object *) self, description);
                    String *that = $((Object *) self->superview, description);
 
                    MVC_LogDebug("%s exceeds superview bounds %s\n", this->chars, that->chars);
 
                    $(self, warn, "%s exceeds superview bounds %s\n", this->chars, that->chars);
 
                    release(this);
                    release(that);
                }
            }
        }
    }
 
    self->needsLayout = false;
 
    $(self, enumerateSubviews, layoutIfNeeded_recurse, NULL);
}
 
static void layoutSubviews(View *self) {
 
    if (self->superview == NULL) {
        if (self->autoresizingMask & ViewAutoresizingFill) {
 
            SDL_Size size;
            SDL_GetWindowSize(self->window, &size.w, &size.h);
 
            $(self, resize, &size);
        }
    }
 
    if (self->autoresizingMask & ViewAutoresizingFit) {
        $(self, sizeToFit);
    }
 
    if (self->autoresizingMask & ViewAutoresizingContain) {
        $(self, sizeToContain);
    }
 
    const SDL_Rect bounds = $(self, bounds);
 
    const Array *subviews = (Array *) self->subviews;
    for (size_t i = 0; i < subviews->count; i++) {
 
        View *subview = (View *) $(subviews, objectAtIndex, i);
 
        SDL_Size subviewSize;
        if (subview->autoresizingMask & ViewAutoresizingFit) {
            subviewSize = $(subview, sizeThatFits);
        } else {
            subviewSize = $(subview, sizeThatContains);
        }
 
        if (subview->autoresizingMask & ViewAutoresizingWidth) {
            subviewSize.w = bounds.w;
        }
 
        if (subview->autoresizingMask & ViewAutoresizingHeight) {
            subviewSize.h = bounds.h;
        }
 
        $(subview, resize, &subviewSize);
 
        switch (subview->alignment & ViewAlignmentMaskHorizontal) {
            case ViewAlignmentLeft:
                subview->frame.x = 0;
                break;
            case ViewAlignmentCenter:
                subview->frame.x = (bounds.w - subview->frame.w) * 0.5;
                break;
            case ViewAlignmentRight:
                subview->frame.x = bounds.w - subview->frame.w;
                break;
        }
 
        switch (subview->alignment & ViewAlignmentMaskVertical) {
            case ViewAlignmentMaskTop:
                subview->frame.y = 0;
                break;
            case ViewAlignmentMaskMiddle:
                subview->frame.y = (bounds.h - subview->frame.h) * 0.5;
                break;
            case ViewAlignmentMaskBottom:
                subview->frame.y = bounds.h - subview->frame.h;
                break;
        }
    }
}
 
static _Bool matchesSelector(const View *self, const SimpleSelector *simpleSelector) {
 
    assert(simpleSelector);
 
    const char *pattern = simpleSelector->pattern;
 
    switch (simpleSelector->type) {
        case SimpleSelectorTypeNone:
            return false;
 
        case SimpleSelectorTypeUniversal:
            return true;
 
        case SimpleSelectorTypeType: {
            const Class *clazz = classForName(pattern);
            if (clazz) {
                return $((Object *) self, isKindOfClass, clazz);
            }
        }
            break;
 
        case SimpleSelectorTypeClass:
            return $(self, hasClassName, pattern);
 
        case SimpleSelectorTypeId:
            if (self->identifier) {
                return strcmp(self->identifier, pattern) == 0;
            } else {
                return false;
            }
 
        case SimpleSelectorTypePseudo:
            if (strcmp("first-child", pattern) == 0) {
                if (self->superview) {
                    return $((Array *) self->superview->subviews, firstObject) == self;
                }
            } else if (strcmp("last-child", pattern) == 0) {
                if (self->superview) {
                    return $((Array *) self->superview->subviews, lastObject) == self;
                }
            } else if (strcmp("nth-child(even)", pattern) == 0) {
                if (self->superview) {
                    return ($((Array *) self->superview->subviews, indexOfObject, (ident) self) & 1) == 0;
                }
            }  else if (strcmp("nth-child(odd)", pattern) == 0) {
                if (self->superview) {
                    return $((Array *) self->superview->subviews, indexOfObject, (ident) self) & 1;
                }
            } else if (strcmp("hover", pattern) == 0) {
                SDL_Point point;
                SDL_GetMouseState(&point.x, &point.y);
                return $(self, containsPoint, &point);
            }
            break;
    }
 
    return false;
}
 
static void moveToWindow_recurse(View *subview, ident data) {
    $(subview, moveToWindow, data);
}
 
static void moveToWindow(View *self, SDL_Window *window) {
 
    if (self->window != window) {
 
        $(self, willMoveToWindow, window);
 
        self->window = window;
 
        $(self, didMoveToWindow, window);
 
        $(self, enumerateSubviews, moveToWindow_recurse, window);
    }
}
 
static String *path(const View *self) {
 
    MutableArray *parts = $$(MutableArray, array);
 
    const View *view = self;
    while (view) {
 
        Array *classNames = $((Set *) view->classNames, allObjects);
 
        String *part;
        if (view->identifier) {
            part = str("#%s", view->identifier);
        } else if (classNames->count) {
            part = str(".%s", ((String *) $(classNames, firstObject))->chars);
        } else {
            part = str("%s", classnameof(view));
        }
 
        release(classNames);
 
        $(parts, insertObjectAtIndex, part, 0);
        release(part);
 
        if (view->viewController) {
            break;
        }
 
        view = view->superview;
    }
 
    String *path = $((Array *) parts, componentsJoinedByCharacters, " > ");
 
    release(parts);
 
    return path;
}
 
static void removeAllClassNames(View *self) {
 
    $(self->classNames, removeAllObjects);
 
    $(self, invalidateStyle);
}
 
static void removeAllSubviews_enumerate(const Array *array, ident obj, ident data) {
    $((View *) data, removeSubview, obj);
}
 
static void removeAllSubviews(View *self) {
    $(self->subviews, removeAllObjectsWithEnumerator, removeAllSubviews_enumerate, self);
}
 
static void removeClassName(View *self, const char *className) {
 
    if (className) {
        String *string = $$(String, stringWithCharacters, className);
        assert(string);
 
        $(self->classNames, removeObject, string);
        release(string);
 
        $(self, invalidateStyle);
    }
}
 
static void removeFromSuperview(View *self) {
 
    if (self->superview) {
        $(self->superview, removeSubview, self);
    }
}
 
static void removeSubview(View *self, View *subview) {
 
    assert(subview);
 
    if (subview->superview == self) {
        
        subview->superview = NULL;
 
        $(subview, moveToWindow, NULL);
 
        $(self->subviews, removeObject, subview);
 
        self->needsLayout = true;
    }
}
 
static void render(View *self, Renderer *renderer) {
 
    assert(self->window);
 
    if ($(self, hasClassName, "breakpoint")) {
        SDL_TriggerBreakpoint();
    }
    
    if (self->backgroundColor.a) {
 
        $(renderer, setDrawColor, &self->backgroundColor);
 
        const SDL_Rect frame = $(self, renderFrame);
        $(renderer, drawRectFilled, &frame);
    }
 
    if (self->borderWidth && self->borderColor.a) {
 
        $(renderer, setDrawColor, &self->borderColor);
 
        SDL_Rect frame = $(self, renderFrame);
        for (int i = 0; i < self->borderWidth; i++) {
 
            $(renderer, drawRect, &frame);
 
            frame.x -= 1;
            frame.y -= 1;
            frame.w += 2;
            frame.h += 2;
        }
    }
 
    $(renderer, setDrawColor, &Colors.White);
}
 
static void renderDeviceDidReset_recurse(View *subview, ident data) {
    $(subview, renderDeviceDidReset);
}
 
static void renderDeviceDidReset(View *self) {
    $(self, enumerateSubviews, renderDeviceDidReset_recurse, NULL);
}
 
static void renderDeviceWillReset_recurse(View *subview, ident data) {
    $(subview, renderDeviceWillReset);
}
 
static void renderDeviceWillReset(View *self) {
    $(self, enumerateSubviews, renderDeviceWillReset_recurse, NULL);
}
 
static SDL_Rect renderFrame(const View *self) {
 
    SDL_Rect frame = self->frame;
 
    const View *view = self;
    const View *superview = view->superview;
    while (superview) {
 
        frame.x += superview->frame.x;
        frame.y += superview->frame.y;
 
        if (view->alignment != ViewAlignmentInternal) {
            frame.x += superview->padding.left;
            frame.y += superview->padding.top;
        }
 
        view = superview;
        superview = view->superview;
    }
 
    return frame;
}
 
static void replaceSubview(View *self, View *subview, View *replacement) {
 
    assert(subview);
    assert(replacement);
 
    $(self, addSubviewRelativeTo, replacement, subview, ViewPositionAfter);
    $(self, removeSubview, subview);
}
 
static void resignFirstResponder(View *self) {
 
    if ($(self, isFirstResponder)) {
        $$(View, setFirstResponder, self->window, NULL);
    }
}
 
static void resize(View *self, const SDL_Size *size) {
 
    if (self->frame.w != size->w || self->frame.h != size->h) {
 
        self->frame.w = clamp(size->w, self->minSize.w, self->maxSize.w);
        self->frame.h = clamp(size->h, self->minSize.h, self->maxSize.h);
 
        self->needsLayout = true;
 
        if (self->superview) {
            self->superview->needsLayout = true;
        }
    }
}
 
static void resolve(View *self, Outlet *outlets) {
 
    if (outlets) {
        for (Outlet *outlet = outlets; outlet->identifier; outlet++) {
            *outlet->view = $(self, descendantWithIdentifier, outlet->identifier);
            assert(*outlet->view);
        }
    }
}
 
static void respondToEvent(View *self, const SDL_Event *event) {
 
    assert(event);
 
    if (self->viewController) {
        $(self->viewController, respondToEvent, event);
    }
 
    if (self->nextResponder) {
        $(self->nextResponder, respondToEvent, event);
    } else if (self->superview) {
        $(self->superview, respondToEvent, event);
    }
}
 
static Set *_select(View *self, const char *rule) {
 
    Selector *selector = $(alloc(Selector), initWithRule, rule);
    assert(selector);
 
    Set *selection = $(selector, select, self);
 
    release(selector);
    return selection;
}
 
static void setFirstResponder(SDL_Window *window, View *view) {
 
    assert(window);
 
    if (view) {
        assert(view->window == window);
        SDL_SetWindowData(window, "firstResponder", view);
        if (MVC_LogEnabled(SDL_LOG_PRIORITY_DEBUG)) {
            String *desc = $((Object *) view, description);
            SDL_LogDebug(LOG_CATEGORY_MVC, "%s: %s\n", __func__, desc->chars);
            release(desc);
        }
    } else {
        SDL_SetWindowData(window, "firstResponder", NULL);
        SDL_LogDebug(LOG_CATEGORY_MVC, "%s: NULL\n", __func__);
    }
}
 
static SDL_Size size(const View *self) {
    return MakeSize(self->frame.w, self->frame.h);
}
 
static SDL_Size sizeThatContains(const View *self) {
 
    const SDL_Size size = $(self, size);
    const SDL_Size sizeThatFits = $(self, sizeThatFits);
 
    return MakeSize(max(size.w, sizeThatFits.w), max(size.h, sizeThatFits.h));
}
 
static SDL_Size sizeThatFits(const View *self) {
 
    SDL_Size size = $(self, size);
 
    if (self->autoresizingMask & ViewAutoresizingWidth) {
        size.w = 0;
    }
 
    if (self->autoresizingMask & ViewAutoresizingHeight) {
        size.h = 0;
    }
 
    if ($(self, isContainer)) {
        size = MakeSize(0, 0);
 
        Array *subviews = $(self, visibleSubviews);
        for (size_t i = 0; i < subviews->count; i++) {
 
            const View *subview = $(subviews, objectAtIndex, i);
            const SDL_Size subviewSize = $(subview, sizeThatContains);
 
            SDL_Point subviewOrigin = MakePoint(0, 0);
            switch (subview->alignment) {
                case ViewAlignmentNone:
                    subviewOrigin = MakePoint(subview->frame.x, subview->frame.y);
                    break;
                default:
                    break;
            }
 
            size.w = max(size.w, subviewOrigin.x + subviewSize.w);
            size.h = max(size.h, subviewOrigin.y + subviewSize.h);
        }
 
        size.w += self->padding.left + self->padding.right;
        size.h += self->padding.top + self->padding.bottom;
 
        release(subviews);
    }
 
    size.w = clamp(size.w, self->minSize.w, self->maxSize.w);
    size.h = clamp(size.h, self->minSize.h, self->maxSize.h);
 
    return size;
}
 
static void sizeToContain(View *self) {
 
    const SDL_Size size = $(self, sizeThatContains);
 
    $(self, resize, &size);
}
 
static void sizeToFit(View *self) {
 
    const SDL_Size size = $(self, sizeThatFits);
 
    $(self, resize, &size);
}
 
static View *subviewWithIdentifier(const View *self, const char *identifier) {
 
    assert(identifier);
 
    const Array *subviews = (Array *) self->subviews;
    for (size_t i = 0; i < subviews->count; i++) {
 
        View *subview = $(subviews, objectAtIndex, i);
        if (subview->identifier) {
 
            if (strcmp(identifier, subview->identifier) == 0) {
                return subview;
            }
        }
    }
 
    return NULL;
}
 
static void updateBindings_recurse(View *subview, ident data) {
    $(subview, updateBindings);
}
 
static void updateBindings(View *self) {
    $(self, enumerateSubviews, updateBindings_recurse, NULL);
}
 
static SDL_Rect viewport(const View *self) {
 
    assert(self->window);
 
    const SDL_Rect frame =  $(self, renderFrame);
 
    return MVC_TransformToWindow(self->window, &frame);
}
 
static View *viewWithCharacters(const char *chars, Outlet *outlets) {
 
    Data *data = $$(Data, dataWithConstMemory, (ident) chars, strlen(chars));
 
    View *view = $$(View, viewWithData, data, outlets);
 
    release(data);
 
    return view;
}
 
static View *viewWithData(const Data *data, Outlet *outlets) {
 
    Dictionary *dictionary = $$(JSONSerialization, objectFromData, data, 0);
 
    View *view = $$(View, viewWithDictionary, dictionary, outlets);
 
    release(dictionary);
 
    return view;
}
 
static View *viewWithDictionary(const Dictionary *dictionary, Outlet *outlets) {
 
    View *view = NULL;
 
    BindInlet(&MakeInlet(NULL, InletTypeView, &view, NULL), dictionary);
 
    $(view, resolve, outlets);
 
    return view;
}
 
static View *viewWithResource(const Resource *resource, Outlet *outlets) {
 
    assert(resource);
 
    return $$(View, viewWithData, resource->data, outlets);
}
 
static View *viewWithResourceName(const char *name, Outlet *outlets) {
 
    Resource *resource = $$(Resource, resourceWithName, name);
 
    View *view = $$(View, viewWithResource, resource, outlets);
 
    release(resource);
 
    return view;
}
 
static _Bool visibleSubviews_filter(ident obj, ident data) {
 
    const View *view = (View *) obj;
 
    return view->hidden == false && view->alignment != ViewAlignmentInternal;
}
 
static Array *visibleSubviews(const View *self) {
    return $((Array *) self->subviews, filteredArray, visibleSubviews_filter, NULL);
}
 
static void warn(View *self, const char *fmt, ...) {
    va_list args;
    va_start(args, fmt);
 
    String *warning = $(alloc(String), initWithVaList, fmt, args);
    assert(warning);
 
    va_end(args);
 
    $(self->warnings, addObject, warning);
    release(warning);
}
 
static void willMoveToWindow(View *self, SDL_Window *window) {
 
    if (self->window) {
        $(self, resignFirstResponder);
        $(self, detachStylesheet, self->window);
    }
}
 
#pragma mark - View class methods
 
static void initialize(Class *clazz) {
 
    ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
    ((ObjectInterface *) clazz->interface)->description = description;
 
    ((ViewInterface *) clazz->interface)->acceptsFirstResponder = acceptsFirstResponder;
    ((ViewInterface *) clazz->interface)->addClassName = addClassName;
    ((ViewInterface *) clazz->interface)->addSubview = addSubview;
    ((ViewInterface *) clazz->interface)->addSubviewRelativeTo = addSubviewRelativeTo;
    ((ViewInterface *) clazz->interface)->ancestorWithIdentifier = ancestorWithIdentifier;
    ((ViewInterface *) clazz->interface)->applyStyle = applyStyle;
    ((ViewInterface *) clazz->interface)->applyTheme = applyTheme;
    ((ViewInterface *) clazz->interface)->applyThemeIfNeeded = applyThemeIfNeeded;
    ((ViewInterface *) clazz->interface)->attachStylesheet = attachStylesheet;
    ((ViewInterface *) clazz->interface)->awakeWithCharacters = awakeWithCharacters;
    ((ViewInterface *) clazz->interface)->awakeWithData = awakeWithData;
    ((ViewInterface *) clazz->interface)->awakeWithDictionary = awakeWithDictionary;
    ((ViewInterface *) clazz->interface)->awakeWithResource = awakeWithResource;
    ((ViewInterface *) clazz->interface)->awakeWithResourceName = awakeWithResourceName;
    ((ViewInterface *) clazz->interface)->becomeFirstResponder = becomeFirstResponder;
    ((ViewInterface *) clazz->interface)->bind = _bind;
    ((ViewInterface *) clazz->interface)->bounds = bounds;
    ((ViewInterface *) clazz->interface)->bringSubviewToFront = bringSubviewToFront;
    ((ViewInterface *) clazz->interface)->clippingFrame = clippingFrame;
    ((ViewInterface *) clazz->interface)->containsPoint = containsPoint;
    ((ViewInterface *) clazz->interface)->depth = depth;
    ((ViewInterface *) clazz->interface)->descendantWithIdentifier = descendantWithIdentifier;
    ((ViewInterface *) clazz->interface)->detachStylesheet = detachStylesheet;
    ((ViewInterface *) clazz->interface)->didMoveToWindow = didMoveToWindow;
    ((ViewInterface *) clazz->interface)->didReceiveEvent = didReceiveEvent;
    ((ViewInterface *) clazz->interface)->draw = draw;
    ((ViewInterface *) clazz->interface)->enumerate = enumerate;
    ((ViewInterface *) clazz->interface)->enumerateAdjacent = enumerateAdjacent;
    ((ViewInterface *) clazz->interface)->enumerateAncestors = enumerateAncestors;
    ((ViewInterface *) clazz->interface)->enumerateDescendants = enumerateDescendants;
    ((ViewInterface *) clazz->interface)->enumerateSelection = enumerateSelection;
    ((ViewInterface *) clazz->interface)->enumerateSiblings = enumerateSiblings;
    ((ViewInterface *) clazz->interface)->enumerateSubviews = enumerateSubviews;
    ((ViewInterface *) clazz->interface)->enumerateSuperview = enumerateSuperview;
    ((ViewInterface *) clazz->interface)->firstResponder = firstResponder;
    ((ViewInterface *) clazz->interface)->hasClassName = hasClassName;
    ((ViewInterface *) clazz->interface)->hitTest = hitTest;
    ((ViewInterface *) clazz->interface)->init = init;
    ((ViewInterface *) clazz->interface)->initWithFrame = initWithFrame;
    ((ViewInterface *) clazz->interface)->invalidateStyle = invalidateStyle;
    ((ViewInterface *) clazz->interface)->isContainer = isContainer;
    ((ViewInterface *) clazz->interface)->isDescendantOfView = isDescendantOfView;
    ((ViewInterface *) clazz->interface)->isFirstResponder = isFirstResponder;
    ((ViewInterface *) clazz->interface)->isVisible = isVisible;
    ((ViewInterface *) clazz->interface)->layoutIfNeeded = layoutIfNeeded;
    ((ViewInterface *) clazz->interface)->layoutSubviews = layoutSubviews;
    ((ViewInterface *) clazz->interface)->matchesSelector = matchesSelector;
    ((ViewInterface *) clazz->interface)->moveToWindow = moveToWindow;
    ((ViewInterface *) clazz->interface)->path = path;
    ((ViewInterface *) clazz->interface)->removeAllClassNames = removeAllClassNames;
    ((ViewInterface *) clazz->interface)->removeAllSubviews = removeAllSubviews;
    ((ViewInterface *) clazz->interface)->removeClassName = removeClassName;
    ((ViewInterface *) clazz->interface)->removeFromSuperview = removeFromSuperview;
    ((ViewInterface *) clazz->interface)->removeSubview = removeSubview;
    ((ViewInterface *) clazz->interface)->render = render;
    ((ViewInterface *) clazz->interface)->renderDeviceDidReset = renderDeviceDidReset;
    ((ViewInterface *) clazz->interface)->renderDeviceWillReset = renderDeviceWillReset;
    ((ViewInterface *) clazz->interface)->renderFrame = renderFrame;
    ((ViewInterface *) clazz->interface)->replaceSubview = replaceSubview;
    ((ViewInterface *) clazz->interface)->resignFirstResponder = resignFirstResponder;
    ((ViewInterface *) clazz->interface)->resize = resize;
    ((ViewInterface *) clazz->interface)->resolve = resolve;
    ((ViewInterface *) clazz->interface)->respondToEvent = respondToEvent;
    ((ViewInterface *) clazz->interface)->select = _select;
    ((ViewInterface *) clazz->interface)->setFirstResponder = setFirstResponder;
    ((ViewInterface *) clazz->interface)->size = size;
    ((ViewInterface *) clazz->interface)->sizeThatContains = sizeThatContains;
    ((ViewInterface *) clazz->interface)->sizeThatFits = sizeThatFits;
    ((ViewInterface *) clazz->interface)->sizeToContain = sizeToContain;
    ((ViewInterface *) clazz->interface)->sizeToFit = sizeToFit;
    ((ViewInterface *) clazz->interface)->subviewWithIdentifier = subviewWithIdentifier;
    ((ViewInterface *) clazz->interface)->updateBindings = updateBindings;
    ((ViewInterface *) clazz->interface)->viewport = viewport;
    ((ViewInterface *) clazz->interface)->viewWithCharacters = viewWithCharacters;
    ((ViewInterface *) clazz->interface)->viewWithData = viewWithData;
    ((ViewInterface *) clazz->interface)->viewWithDictionary = viewWithDictionary;
    ((ViewInterface *) clazz->interface)->viewWithResource = viewWithResource;
    ((ViewInterface *) clazz->interface)->viewWithResourceName = viewWithResourceName;
    ((ViewInterface *) clazz->interface)->visibleSubviews = visibleSubviews;
    ((ViewInterface *) clazz->interface)->warn = warn;
    ((ViewInterface *) clazz->interface)->willMoveToWindow = willMoveToWindow;
}
 
Class *_View(void) {
    static Class *clazz;
    static Once once;
 
    do_once(&once, {
        clazz = _initialize(&(const ClassDef) {
            .name = "View",
            .superclass = _Object(),
            .instanceSize = sizeof(View),
            .interfaceOffset = offsetof(View, interface),
            .interfaceSize = sizeof(ViewInterface),
            .initialize = initialize,
        });
    });
 
    return clazz;
}
 
#undef _Class