View.c

Go to the documentation of this file.

/*
 * ObjectivelyMVC: Object oriented MVC framework for SDL3 and 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 <stdlib.h>
#include <string.h>
 
#include <Objectively.h>
 
#include "Log.h"
#include "View.h"
#include "ViewController.h"
#include "WindowController.h"
#include "Window.h"
 
Uint32 MVC_NOTIFICATION_EVENT;
Uint32 MVC_VIEW_EVENT;
 
static unsigned _renderFrameGeneration;
 
void MVC_InvalidateRenderFrames(void) {
  if (++_renderFrameGeneration == 0) {
    _renderFrameGeneration = 1;
  }
}
 
const EnumName ViewPointerEventsNames[] = MakeEnumNames(
  MakeEnumAlias(ViewPointerEventsAuto, auto),
  MakeEnumAlias(ViewPointerEventsNone, none)
);
 
const EnumName ViewVisibilityNames[] = MakeEnumNames(
  MakeEnumAlias(ViewVisibilityUnspecified, unspecified),
  MakeEnumAlias(ViewVisibilityVisible, visible),
  MakeEnumAlias(ViewVisibilityHidden, hidden)
);
 
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 - Object
 
static bool filterViewEvents(void *data, SDL_Event *event) {
 
  if (event->type == MVC_VIEW_EVENT && event->user.data1 == data) {
    return false;
  }
 
  return true;
}
 
static void nullifySuperview(View *subview, ident data) {
  subview->superview = NULL;
}
 
static void dealloc(Object *self) {
 
  View *this = (View *) self;
 
  SDL_FilterEvents(filterViewEvents, this);
 
  $(this, moveToWindow, NULL);
 
  $(this, enumerateSubviews, nullifySuperview, NULL);
 
  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;
  const SDL_Rect bounds = $(this, bounds);
 
  String *classNames = $((Object *) this->classNames, description);
  String *description = str("%s@%p %s [%d, %d, %d, %d]",
                this->identifier ?: classnameof(self),
                self,
                classNames->chars,
                bounds.x, bounds.y, bounds.w, bounds.h);
 
  release(classNames);
  return description;
}
 
#pragma mark - View
 
static bool acceptsKeyResponder(const View *self) {
  return false;
}
 
static bool acceptsTouchResponder(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, setNeedsLayout);
}
 
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("background-gradient-angle", InletTypeInteger, &self->backgroundGradientAngle, NULL),
    MakeInlet("background-gradient-color", InletTypeColor, &self->backgroundGradientColor, NULL),
    MakeInlet("border-color", InletTypeColor, &self->borderColor, NULL),
    MakeInlet("border-radius", InletTypeInteger, &self->borderRadius, NULL),
    MakeInlet("border-width", InletTypeInteger, &self->borderWidth, NULL),
    MakeInlet("clips-subviews", InletTypeBool, &self->clipsSubviews, NULL),
    MakeInlet("corner-cut", InletTypeRectangle, &self->cornerCut, NULL),
    MakeInlet("corner-cut-top-left", InletTypeInteger, &self->cornerCut.topLeft, NULL),
    MakeInlet("corner-cut-top-right", InletTypeInteger, &self->cornerCut.topRight, NULL),
    MakeInlet("corner-cut-bottom-right", InletTypeInteger, &self->cornerCut.bottomRight, NULL),
    MakeInlet("corner-cut-bottom-left", InletTypeInteger, &self->cornerCut.bottomLeft, 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("pointer-events", InletTypeEnum, &self->pointerEvents, (ident) ViewPointerEventsNames),
    MakeInlet("stretch", InletTypeBool, &self->stretch, NULL),
    MakeInlet("top", InletTypeInteger, &self->frame.y, NULL),
    MakeInlet("visibility", InletTypeEnum, &self->visibility, (ident) ViewVisibilityNames),
    MakeInlet("width", InletTypeInteger, &self->frame.w, NULL)
  );
 
  const ViewVisibility visibility = self->visibility;
  const bool stretch = self->stretch;
 
  $(self, bind, inlets, style->attributes);
 
  if ((self->visibility != visibility || self->stretch != stretch) && self->superview) {
    $(self->superview, setNeedsLayout);
  }
 
  if ((self->alignment & ViewAlignmentMaskHorizontal) &&
      $(style->attributes, objectForKeyPath, "left")) {
    $(self, warn, WarningTypeStyle, "`left` is overruled by the horizontal `alignment`");
  }
 
  if ((self->alignment & ViewAlignmentMaskVertical) &&
      $(style->attributes, objectForKeyPath, "top")) {
    $(self, warn, WarningTypeStyle, "`top` is overruled by the vertical `alignment`");
  }
}
 
static void applyTheme(View *self, const Theme *theme) {
 
  assert(theme);
 
  Style *computedStyle = $(theme, computeStyle, self);
  assert(computedStyle);
 
  if (self->needsApplyStyle || !$(self->computedStyle, isComputedEqual, computedStyle)) {
 
    release(self->computedStyle);
    self->computedStyle = retain(computedStyle);
 
    $(self->computedStyle, addAttributes, self->style->attributes);
    $(self, applyStyle, self->computedStyle);
 
    self->needsApplyStyle = false;
  }
 
  release(computedStyle);
}
 
static void applyThemeIfNeeded(View *self, const Theme *theme);
 
static void _applyThemeIfNeeded(View *view, ident data) {
  applyThemeIfNeeded(view, (const Theme *) data);
}
 
static void applyThemeIfNeeded(View *self, const Theme *theme) {
 
  assert(theme);
 
  if (!self->needsApplyTheme && !self->needsApplyThemeSubviews) {
    return;
  }
 
  // Cleared before descending so that any re-invalidation during the traversal
  // propagates fresh subtree flags and survives to the next frame.
  self->needsApplyThemeSubviews = false;
 
  $(self, enumerateSubviews, _applyThemeIfNeeded, (ident) theme);
 
  if (self->needsApplyTheme) {
 
    $(self, clearWarnings, WarningTypeStyle);
 
    $(self, applyTheme, theme);
 
    self->needsApplyTheme = false;
  }
}
 
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) {
 
  JSONContext *ctx = $(alloc(JSONContext), init);
  Dictionary *dictionary = $(ctx, objectFromData, data, 0);
 
  if (dictionary) {
    $(self, awakeWithDictionary, dictionary);
    release(dictionary);
  } else {
    MVC_LogError("Failed to parse JSON for %s\n", classnameof(self));
  }
 
  release(ctx);
}
 
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 becomeKeyResponder(View *self) {
 
  assert(self->window);
 
  if (!$(self, isKeyResponder)) {
    SDL_PropertiesID props = SDL_GetWindowProperties(self->window);
 
    View *keyResponder = SDL_GetPointerProperty(props, "keyResponder", NULL);
    if (keyResponder) {
      $(keyResponder, resignKeyResponder);
    }
 
    String *path = $(self, path);
    MVC_LogDebug("%s\n", path->chars);
    release(path);
 
    SDL_SetPointerProperty(props, "keyResponder", self);
  }
}
 
static void becomeTouchResponder(View *self) {
 
  assert(self->window);
 
  if (!$(self, isTouchResponder)) {
    SDL_PropertiesID props = SDL_GetWindowProperties(self->window);
 
    View *touchResponder = SDL_GetPointerProperty(props, "touchResponder", NULL);
    if (touchResponder) {
      $(touchResponder, resignTouchResponder);
    }
 
    String *path = $(self, path);
    MVC_LogDebug("%s\n", path->chars);
    release(path);
 
    SDL_SetPointerProperty(props, "touchResponder", self);
  }
}
 
static bool _bind(View *self, const Inlet *inlets, const Dictionary *dictionary) {
 
  if (inlets) {
    if (bindInlets(inlets, dictionary)) {
      $(self, setNeedsApplyTheme);
      $(self, setNeedsLayout);
      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 = max(0, size.w - (self->padding.left + self->padding.right)),
    .h = max(0, 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 bool clearWarnings_predicate(const ident obj, ident data) {
 
  const Warning *warning = obj;
  const WarningType type = *(WarningType *) data;
 
  return (warning->type & type) == 0;
}
 
static void clearWarnings(const View *self, WarningType type) {
  $(self->warnings, filter, clearWarnings_predicate, &type);
}
 
static SDL_Rect clippingFrame(const View *self) {
 
  View *this = (View *) self;
 
  if (_renderFrameGeneration && this->clippingFrameCache.generation == _renderFrameGeneration) {
    return this->clippingFrameCache.frame;
  }
 
  SDL_Rect frame = $(self, renderFrame);
 
  if (self->borderWidth && self->borderColor.a) {
    frame.x -= self->borderWidth;
    frame.y -= self->borderWidth;
    frame.w += self->borderWidth * 2;
    frame.h += self->borderWidth * 2;
  }
 
  // The nearest clipping ancestor's clippingFrame already folds in every outer clip, so a
  // single intersection with it is equivalent to intersecting each clipping ancestor in turn.
  const View *superview = self->superview;
  while (superview && !superview->clipsSubviews) {
    superview = superview->superview;
  }
 
  if (superview) {
    const SDL_Rect clippingFrame = $(superview, clippingFrame);
    if (SDL_GetRectIntersection(&clippingFrame, &frame, &frame) == false) {
      frame.w = frame.h = 0;
    }
  }
 
  this->clippingFrameCache.frame = frame;
  this->clippingFrameCache.generation = _renderFrameGeneration;
 
  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->elements[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);
 
    if (self->superview == NULL) {
      $(self, sizeToFill);
    }
 
    $(self, setNeedsLayout);
  }
}
 
static bool didReceiveEvent(const View *self, const SDL_Event *event) {
 
  if ($(self, isKeyResponder)) {
    switch (event->type) {
      case SDL_EVENT_KEY_DOWN:
      case SDL_EVENT_KEY_UP:
      case SDL_EVENT_TEXT_INPUT:
        return true;
    }
  }
 
  if ($(self, isVisible)) {
 
    SDL_Point point;
 
    switch (event->type) {
      case SDL_EVENT_MOUSE_BUTTON_DOWN:
      case SDL_EVENT_MOUSE_BUTTON_UP:
        point = MakePoint(event->button.x, event->button.y);
        break;
      case SDL_EVENT_MOUSE_MOTION:
        point = MakePoint(event->motion.x, event->motion.y);
        break;
      case SDL_EVENT_MOUSE_WHEEL: {
        float mx, my;
        SDL_GetMouseState(&mx, &my);
        point = MakePoint(mx, my);
        break;
      }
      default:
        return false;
    }
 
    return $(self, containsPoint, &point);
  }
 
  return false;
}
 
static void draw(View *self, Renderer *renderer);
 
static void _draw(View *view, ident data) {
  draw(view, (Renderer *) data);
}
 
static void draw(View *self, Renderer *renderer) {
 
  assert(self->window);
 
  if (self->visibility != ViewVisibilityHidden) {
 
    $(renderer, drawView, self);
 
    $(self, enumerateSubviews, _draw, renderer);
  }
}
 
static void emitViewEvent(View *self, ViewEvent code, ident data) {
  SDL_PushEvent((SDL_Event *) &(const SDL_UserEvent) {
    .type = MVC_VIEW_EVENT,
    .code = code,
    .data1 = self,
    .data2 = data
  });
}
 
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->elements[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->elements[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 void enumerateVisible(View *self, ViewEnumerator enumerator, ident data) {
 
  if ($(self, isVisible) == false) {
    return;
  }
 
  enumerator(self, data);
 
  const Array *subviews = (Array *) self->subviews;
  for (size_t i = 0; i < subviews->count; i++) {
 
    View *subview = subviews->elements[i];
    $(subview, enumerateVisible, enumerator, data);
  }
}
 
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;
}
 
typedef struct {
  SDL_Rect bounds;
  bool hasOverflow;
} Overflow;
 
static void hasOverflow_enumerate(View *view, ident data) {
 
  Overflow *overflow = data;
 
  if (view->visibility != ViewVisibilityHidden) {
 
    const SDL_Rect bounds = $(view, bounds);
 
    if (bounds.x + bounds.w > overflow->bounds.w || bounds.y + bounds.h > overflow->bounds.h) {
 
      overflow->hasOverflow = true;
 
      $(view, warn, WarningTypeLayout, "Exceeds superview bounds [%d %d %d %d]",
        overflow->bounds.x, overflow->bounds.y, overflow->bounds.w, overflow->bounds.h);
    }
  }
}
 
static bool hasOverflow(const View *self) {
 
  Overflow overflow = {
    .bounds = $(self, bounds)
  };
 
  $(self, enumerateSubviews, hasOverflow_enumerate, (ident) &overflow);
 
  return overflow.hasOverflow;
}
 
static View *hitTest(const View *self, const SDL_Point *point) {
 
  if (self->visibility != ViewVisibilityHidden) {
 
    if ($(self, containsPoint, point)) {
 
      const Array *subviews = (Array *) self->subviews;
      for (size_t i = subviews->count; i; i--) {
 
        const View *subview = subviews->elements[i - 1];
        const View *view = $(subview, hitTest, point);
        if (view) {
          return (View *) view;
        }
      }
 
      return self->pointerEvents == ViewPointerEventsAuto ? (View *) self : NULL;
    }
  }
 
  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 = $$(Set, setWithCapacity, 0);
    assert(self->classNames);
 
    self->computedStyle = $(alloc(Style), initWithAttributes, NULL);
    assert(self->computedStyle);
 
    self->subviews = $$(Array, arrayWithCapacity, 0);
    assert(self->subviews);
 
    self->style = $(alloc(Style), initWithAttributes, NULL);
    assert(self->style);
 
    self->warnings = $$(Array, arrayWithCapacity, 0);
    assert(self->warnings);
 
    self->needsApplyTheme = true;
    self->needsLayout = true;
  }
 
  return self;
}
 
static void invalidateStyle_enumerate(View *view, ident data) {
 
  view->needsApplyStyle = true;
 
  $(view, setNeedsApplyTheme);
}
 
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 isKeyResponder(const View *self) {
 
  if (self->window) {
    return SDL_GetPointerProperty(SDL_GetWindowProperties(self->window), "keyResponder", NULL) == self;
  } else {
    return false;
  }
}
 
static bool isTouchResponder(const View *self) {
 
  if (self->window) {
    return SDL_GetPointerProperty(SDL_GetWindowProperties(self->window), "touchResponder", NULL) == self;
  } else {
    return false;
  }
}
 
static bool isVisible(const View *self) {
 
  for (const View *view = self; view; view = view->superview) {
    if (view->visibility == ViewVisibilityHidden) {
      return false;
    }
  }
 
  return true;
}
 
static void layoutIfNeeded_enumerate(View *subview, ident data) {
  $(subview, layoutIfNeeded);
}
 
static void layoutIfNeeded(View *self) {
 
  if (!self->needsLayout && !self->needsLayoutSubviews) {
    return;
  }
 
  // Cleared before laying out so that any re-invalidation during layout (e.g. a resize
  // propagating setNeedsLayout, or a widget marking a sibling) survives to the next frame.
  self->needsLayoutSubviews = false;
 
  // Subviews first, so that a dirty descendant whose layout resizes it marks its ancestors
  // before their own dirty checks below run; the whole tree then converges bottom-up in a
  // single pass, exactly as invalidations propagate.
  $(self, enumerateSubviews, layoutIfNeeded_enumerate, NULL);
 
  if (self->needsLayout) {
 
    // No ancestor is actively arranging self right now, so there's no fresh constraint to
    // consult; treat an existing frame as authoritative per-axis (Equal, not Max -- see
    // ViewConstraintMax), leaving an axis with no frame yet Unspecified.
    const ViewConstraint w = self->frame.w ?
      MakeConstraint(ViewConstraintEqual, self->frame.w) : MakeConstraint(ViewConstraintUnspecified, 0);
    const ViewConstraint h = self->frame.h ?
      MakeConstraint(ViewConstraintEqual, self->frame.h) : MakeConstraint(ViewConstraintUnspecified, 0);
 
    $(self, layoutWithConstraint, w, h);
  }
}
 
static void layoutSubviews(View *self) {
 
  const SDL_Rect bounds = $(self, bounds);
 
  const Array *subviews = (Array *) self->subviews;
  for (size_t i = 0; i < subviews->count; i++) {
 
    View *subview = subviews->elements[i];
 
    const ViewConstraint w = (subview->autoresizingMask & ViewAutoresizingWidth) ?
      MakeConstraint(ViewConstraintEqual, bounds.w) : MakeConstraint(ViewConstraintUnspecified, 0);
 
    const ViewConstraint h = (subview->autoresizingMask & ViewAutoresizingHeight) ?
      MakeConstraint(ViewConstraintEqual, bounds.h) : MakeConstraint(ViewConstraintUnspecified, 0);
 
    $(subview, layoutWithConstraint, w, h);
 
    switch (subview->alignment & ViewAlignmentMaskHorizontal) {
      case ViewAlignmentLeft:
        subview->frame.x = 0;
        break;
      case ViewAlignmentCenter:
        subview->frame.x = (bounds.w - subview->frame.w) * 0.5f;
        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.5f;
        break;
      case ViewAlignmentMaskBottom:
        subview->frame.y = bounds.h - subview->frame.h;
        break;
    }
  }
}
 
static void layoutWithConstraint(View *self, ViewConstraint width, ViewConstraint height) {
 
  $(self, sizeToSatisfy, width, height);
  $(self, clearWarnings, WarningTypeLayout);
  $(self, layoutSubviews);
 
  self->needsLayout = false;
}
 
static void layoutWithSize(View *self, const SDL_Size *size) {
 
  $(self, resize, size);
  $(self, clearWarnings, WarningTypeLayout);
  $(self, layoutSubviews);
 
  self->needsLayout = false;
}
 
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) {
        float mx, my;
        SDL_GetMouseState(&mx, &my);
        SDL_Point point = MakePoint(mx, my);
        return $(self, containsPoint, &point);
      }
      break;
  }
 
  return false;
}
 
static void moveToWindow_enumerate(View *subview, ident data) {
  $(subview, moveToWindow, data);
}
 
static void moveToWindow(View *self, SDL_Window *window) {
 
  $(self, willMoveToWindow, window);
 
  if (self->window && self->window != window) {
    SDL_PropertiesID props = SDL_GetWindowProperties(self->window);
 
    if (SDL_GetPointerProperty(props, "keyResponder", NULL) == self) {
      SDL_SetPointerProperty(props, "keyResponder", NULL);
    }
 
    if (SDL_GetPointerProperty(props, "touchResponder", NULL) == self) {
      SDL_SetPointerProperty(props, "touchResponder", NULL);
    }
  }
 
  self->window = window;
 
  $(self, didMoveToWindow, window);
 
  $(self, enumerateSubviews, moveToWindow_enumerate, window);
}
 
static String *path(const View *self) {
 
  Array *parts = $$(Array, 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, setNeedsLayout);
  }
}
 
static void cornerCutPoints(SDL_Point *points, const SDL_Rect *rect, const ViewCornerCut *cut) {
 
  const int x1 = rect->x, y1 = rect->y;
  const int x2 = rect->x + rect->w, y2 = rect->y + rect->h;
 
  const int w = rect->w;
 
  const int topLeft = clamp(cut->topLeft, 0, w);
  const int topRight = clamp(cut->topRight, 0, w - topLeft);
 
  const int bottomLeft = clamp(cut->bottomLeft, 0, w);
  const int bottomRight = clamp(cut->bottomRight, 0, w - bottomLeft);
 
  points[0] = MakePoint(x1 + topLeft, y1);
  points[1] = MakePoint(x2 - topRight, y1);
  points[2] = MakePoint(x2 - bottomRight, y2);
  points[3] = MakePoint(x1 + bottomLeft, y2);
}
 
static void render(View *self, Renderer *renderer) {
 
  assert(self->window);
 
  if ($(self, hasClassName, "breakpoint")) {
    SDL_TriggerBreakpoint();
  }
  
  const bool cut = !CornerCutIsEmpty(self->cornerCut);
 
  if (self->backgroundColor.a || self->backgroundGradientColor.a) {
 
    const SDL_Rect frame = $(self, renderFrame);
    const SDL_Color *gradient = self->backgroundGradientColor.a ? &self->backgroundGradientColor : NULL;
 
    if (cut) {
      SDL_Point points[4];
      cornerCutPoints(points, &frame, &self->cornerCut);
 
      $(renderer, drawPolygonFilled, points, lengthof(points), self->backgroundGradientAngle,
        &self->backgroundColor, gradient);
 
    } else if (gradient) {
      $(renderer, drawRoundedRectGradientFilled, &frame, self->borderRadius,
        self->backgroundGradientAngle, &self->backgroundColor, gradient);
    } else if (self->borderRadius > 0) {
      $(renderer, drawRoundedRectFilled, &frame, self->borderRadius, &self->backgroundColor);
    } else {
      $(renderer, drawRectFilled, &frame, &self->backgroundColor);
    }
  }
 
  if (self->borderWidth && self->borderColor.a) {
 
    SDL_Rect frame = $(self, renderFrame);
 
    if (cut) {
 
      // The stroke is centered on the outline, so grow by half of it to sit outside the fill
      const int inset = self->borderWidth / 2;
 
      frame.x -= inset;
      frame.y -= inset;
      frame.w += inset * 2;
      frame.h += inset * 2;
 
      SDL_Point points[4];
      cornerCutPoints(points, &frame, &self->cornerCut);
 
      $(renderer, drawPolygon, points, lengthof(points), self->borderWidth, &self->borderColor);
 
    } else if (self->borderRadius > 0) {
 
      // The border grows outward, so its inner edge shares the background's radius
      frame.x -= self->borderWidth;
      frame.y -= self->borderWidth;
      frame.w += self->borderWidth * 2;
      frame.h += self->borderWidth * 2;
 
      $(renderer, drawRoundedRect, &frame, self->borderRadius + self->borderWidth, self->borderWidth, &self->borderColor);
 
    } else {
 
      for (int i = 0; i < self->borderWidth; i++) {
 
        $(renderer, drawRect, &frame, &self->borderColor);
 
        frame.x -= 1;
        frame.y -= 1;
        frame.w += 2;
        frame.h += 2;
      }
    }
  }
}
 
static void renderDeviceDidReset_enumerate(View *subview, ident data) {
  $(subview, renderDeviceDidReset);
}
 
static void renderDeviceDidReset(View *self) {
  $(self, enumerateSubviews, renderDeviceDidReset_enumerate, NULL);
}
 
static void renderDeviceWillReset_enumerate(View *subview, ident data) {
  $(subview, renderDeviceWillReset);
}
 
static void renderDeviceWillReset(View *self) {
  $(self, enumerateSubviews, renderDeviceWillReset_enumerate, NULL);
}
 
static SDL_Rect renderFrame(const View *self) {
 
  View *this = (View *) self;
 
  if (_renderFrameGeneration && this->renderFrameCache.generation == _renderFrameGeneration) {
    return this->renderFrameCache.frame;
  }
 
  SDL_Rect frame = self->frame;
 
  const View *superview = self->superview;
  if (superview) {
 
    const SDL_Rect superFrame = $(superview, renderFrame);
 
    frame.x += superFrame.x;
    frame.y += superFrame.y;
 
    if (self->alignment != ViewAlignmentInternal) {
      frame.x += superview->padding.left;
      frame.y += superview->padding.top;
    }
  }
 
  this->renderFrameCache.frame = frame;
  this->renderFrameCache.generation = _renderFrameGeneration;
 
  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 resignKeyResponder(View *self) {
 
  if (self->window && $(self, isKeyResponder)) {
 
    String *path = $(self, path);
    MVC_LogDebug("%s\n", path->chars);
    release(path);
 
    SDL_SetPointerProperty(SDL_GetWindowProperties(self->window), "keyResponder", NULL);
  }
}
 
static void resignTouchResponder(View *self) {
 
  if (self->window && $(self, isTouchResponder)) {
 
    String *path = $(self, path);
    MVC_LogDebug("%s\n", path->chars);
    release(path);
 
    SDL_SetPointerProperty(SDL_GetWindowProperties(self->window), "touchResponder", NULL);
  }
}
 
static void resize(View *self, const SDL_Size *size) {
 
  const int w = ClampSize(size->w, self->minSize.w, self->maxSize.w);
  const int h = ClampSize(size->h, self->minSize.h, self->maxSize.h);
 
  if (self->frame.w != w || self->frame.h != h) {
 
    self->frame.w = w;
    self->frame.h = h;
 
    $(self, setNeedsLayout);
    
    if (self->superview) {
      if ($(self->superview, isContainer) || self->alignment & ViewAlignmentMaskAny || self->stretch) {
        $(self->superview, setNeedsLayout);
      }
    }
  }
}
 
static void resolve(View *self, Outlet *outlets) {
 
  if (outlets) {
    for (Outlet *outlet = outlets; outlet->identifier; outlet++) {
      *outlet->view = $(self, descendantWithIdentifier, outlet->identifier);
      if (*outlet->view == NULL) {
        String *desc = $((Object *) self, description);
        MVC_LogError("Failed to resolve outlet '%s' for %s", outlet->identifier, desc->chars);
        release(desc);
      }
 
      assert(*outlet->view);
    }
  }
}
 
static void respondToEvent(View *self, const SDL_Event *event) {
 
  assert(event);
 
  ViewEvent code = ViewEventNone;
 
  switch (event->type) {
    case SDL_EVENT_MOUSE_BUTTON_DOWN:
      code = ViewEventMouseButtonDown;
      break;
    case SDL_EVENT_MOUSE_BUTTON_UP:
      code = ViewEventMouseButtonUp;
      $(self, resignTouchResponder);
      break;
    case SDL_EVENT_KEY_DOWN:
      code = ViewEventKeyDown;
      break;
    case SDL_EVENT_KEY_UP:
      code = ViewEventKeyUp;
      break;
    default:
      break;
  }
 
  if (code != ViewEventNone) {
    $(self, emitViewEvent, code, NULL);
 
    if (code == ViewEventMouseButtonUp) {
      if (event->button.clicks) {
        $(self, emitViewEvent, ViewEventClick, NULL);
      }
    }
  }
 
  if (event->type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
    if ($(self, acceptsKeyResponder)) {
      $(self, becomeKeyResponder);
      return;
    }
  }
 
  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 View *selectFirst(View *self, const char *rule) {
 
  Selector *selector = $(alloc(Selector), initWithRule, rule);
  assert(selector);
 
  View *first = $(selector, selectFirst, self);
 
  release(selector);
  return first;
}
 
static void setVisibility(View *self, ViewVisibility visibility) {
 
  if (self->visibility != visibility) {
 
    self->visibility = visibility;
 
    $(self->style, addEnumAttribute, "visibility", ViewVisibilityNames, visibility);
 
    if (self->superview && $(self->superview, isContainer)) {
      $(self->superview, setNeedsLayout);
    }
  }
}
 
static void setNeedsApplyTheme(View *self) {
 
  self->needsApplyTheme = true;
 
  for (View *view = self->superview; view && !view->needsApplyThemeSubviews; view = view->superview) {
    view->needsApplyThemeSubviews = true;
  }
}
 
static void setNeedsLayout(View *self) {
 
  self->needsLayout = true;
 
  for (View *view = self->superview; view && !view->needsLayoutSubviews; view = view->superview) {
    view->needsLayoutSubviews = true;
  }
}
 
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 sizeThatFills(const View *self) {
  SDL_Size size;
 
  if (self->superview == NULL) {
    SDL_GetWindowSize(self->window, &size.w, &size.h);
  } else {
    size = $(self->superview, size);
  }
 
  return size;
}
 
static SDL_Size sizeThatFits(const View *self) {
 
  SDL_Size size = $(self, size);
 
  if ($(self, isContainer)) {
    size = MakeSize(0, 0);
 
    Array *subviews = $(self, visibleSubviews);
    for (size_t i = 0; i < subviews->count; i++) {
 
      View *subview = subviews->elements[i];
 
      const ViewConstraint unspecified = MakeConstraint(ViewConstraintUnspecified, 0);
      const SDL_Size subviewSize = $(subview, sizeThatSatisfies, unspecified, unspecified);
 
      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 = ClampSize(size.w, self->minSize.w, self->maxSize.w);
  size.h = ClampSize(size.h, self->minSize.h, self->maxSize.h);
 
  return size;
}
 
static int resolveViewConstraint(int hasAutoresizingBit, ViewConstraint constraint, int intrinsic) {
 
  if (!hasAutoresizingBit) {
    return intrinsic;
  }
 
  switch (constraint.mode) {
    case ViewConstraintEqual:
      return constraint.value;
    case ViewConstraintMax:
      return min(intrinsic, constraint.value);
    default:
      return intrinsic;
  }
}
 
static SDL_Size sizeThatSatisfies(View *self, ViewConstraint width, ViewConstraint height) {
 
  SDL_Size size = $(self, sizeThatFits);
 
  size.w = resolveViewConstraint(self->autoresizingMask & ViewAutoresizingWidth, width, size.w);
  size.h = resolveViewConstraint(self->autoresizingMask & ViewAutoresizingHeight, height, size.h);
 
  size.w = ClampSize(size.w, self->minSize.w, self->maxSize.w);
  size.h = ClampSize(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 sizeToFill(View *self) {
 
  const SDL_Size size = $(self, sizeThatFills);
 
  $(self, resize, &size);
}
 
static void sizeToFit(View *self) {
 
  const SDL_Size size = $(self, sizeThatFits);
 
  $(self, resize, &size);
}
 
static void sizeToSatisfy(View *self, ViewConstraint width, ViewConstraint height) {
 
  const SDL_Size size = $(self, sizeThatSatisfies, width, height);
 
  $(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->elements[i];
    if (subview->identifier) {
 
      if (strcmp(identifier, subview->identifier) == 0) {
        return subview;
      }
    }
  }
 
  return NULL;
}
 
static void updateBindings_enumerate(View *subview, ident data) {
  $(subview, updateBindings, data);
}
 
static void updateBindings(View *self, ident data) {
  $(self, enumerateSubviews, updateBindings_enumerate, data);
}
 
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) {
 
  JSONContext *ctx = $(alloc(JSONContext), init);
  Dictionary *dictionary = $(ctx, objectFromData, data, 0);
 
  View *view = NULL;
  if (dictionary) {
    view = $$(View, viewWithDictionary, dictionary, outlets);
    release(dictionary);
  } else {
    MVC_LogError("Failed to parse JSON\n");
  }
 
  release(ctx);
  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->visibility != ViewVisibilityHidden && view->alignment != ViewAlignmentInternal;
}
 
static Array *visibleSubviews(const View *self) {
  return $((Array *) self->subviews, filteredArray, visibleSubviews_filter, NULL);
}
 
static void warn(View *self, WarningType type, const char *fmt, ...) {
 
  va_list args;
  va_start(args, fmt);
 
  Warning *warning = $(alloc(Warning), initWithVaList, type, fmt, args);
 
  va_end(args);
 
  String *description = $((Object *) self, description);
  MVC_LogWarn("%s:: %s\n", description->chars, warning->message->chars);
  release(description);
 
  $(self->warnings, addObject, warning);
 
  release(warning);
}
 
static void willMoveToWindow(View *self, SDL_Window *window) {
 
  if (self->window) {
    $(self, resignKeyResponder);
    $(self, resignTouchResponder);
    $(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)->acceptsKeyResponder = acceptsKeyResponder;
  ((ViewInterface *) clazz->interface)->acceptsTouchResponder = acceptsTouchResponder;
  ((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)->becomeKeyResponder = becomeKeyResponder;
  ((ViewInterface *) clazz->interface)->becomeTouchResponder = becomeTouchResponder;
  ((ViewInterface *) clazz->interface)->bind = _bind;
  ((ViewInterface *) clazz->interface)->bounds = bounds;
  ((ViewInterface *) clazz->interface)->bringSubviewToFront = bringSubviewToFront;
  ((ViewInterface *) clazz->interface)->clearWarnings = clearWarnings;
  ((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)->emitViewEvent = emitViewEvent;
  ((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)->enumerateVisible = enumerateVisible;
  ((ViewInterface *) clazz->interface)->hasClassName = hasClassName;
  ((ViewInterface *) clazz->interface)->hasOverflow = hasOverflow;
  ((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)->isKeyResponder = isKeyResponder;
  ((ViewInterface *) clazz->interface)->isTouchResponder = isTouchResponder;
  ((ViewInterface *) clazz->interface)->isVisible = isVisible;
  ((ViewInterface *) clazz->interface)->layoutIfNeeded = layoutIfNeeded;
  ((ViewInterface *) clazz->interface)->layoutSubviews = layoutSubviews;
  ((ViewInterface *) clazz->interface)->layoutWithConstraint = layoutWithConstraint;
  ((ViewInterface *) clazz->interface)->layoutWithSize = layoutWithSize;
  ((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)->resignKeyResponder = resignKeyResponder;
  ((ViewInterface *) clazz->interface)->resignTouchResponder = resignTouchResponder;
  ((ViewInterface *) clazz->interface)->resize = resize;
  ((ViewInterface *) clazz->interface)->resolve = resolve;
  ((ViewInterface *) clazz->interface)->respondToEvent = respondToEvent;
  ((ViewInterface *) clazz->interface)->select = _select;
  ((ViewInterface *) clazz->interface)->selectFirst = selectFirst;
  ((ViewInterface *) clazz->interface)->setVisibility = setVisibility;
  ((ViewInterface *) clazz->interface)->setNeedsApplyTheme = setNeedsApplyTheme;
  ((ViewInterface *) clazz->interface)->setNeedsLayout = setNeedsLayout;
  ((ViewInterface *) clazz->interface)->size = size;
  ((ViewInterface *) clazz->interface)->sizeThatContains = sizeThatContains;
  ((ViewInterface *) clazz->interface)->sizeThatFills = sizeThatFills;
  ((ViewInterface *) clazz->interface)->sizeThatFits = sizeThatFits;
  ((ViewInterface *) clazz->interface)->sizeThatSatisfies = sizeThatSatisfies;
  ((ViewInterface *) clazz->interface)->sizeToContain = sizeToContain;
  ((ViewInterface *) clazz->interface)->sizeToFill = sizeToFill;
  ((ViewInterface *) clazz->interface)->sizeToFit = sizeToFit;
  ((ViewInterface *) clazz->interface)->sizeToSatisfy = sizeToSatisfy;
  ((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;
 
  MVC_NOTIFICATION_EVENT = SDL_RegisterEvents(1);
  assert(MVC_NOTIFICATION_EVENT != 0);
  
  MVC_VIEW_EVENT = SDL_RegisterEvents(1);
  assert(MVC_VIEW_EVENT != 0);
}
 
Class *_View(void) {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "View",
      .superclass = _Object(),
      .instanceSize = sizeof(View),
      .interfaceSize = sizeof(ViewInterface),
      .initialize = initialize,
    });
  });
 
  return clazz;
}
 
#undef _Class