View.c File Reference

#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"

Go to the source code of this file.

Data Structures
struct	Overflow

Macros
#define	_Class   _View

Functions
static void	_applyThemeIfNeeded (View *view, ident data)
	ViewEnumerator adapter for applyThemeIfNeeded.
static bool	_bind (View *self, const Inlet *inlets, const Dictionary *dictionary)
static void	_draw (View *view, ident data)
	ViewEnumerator adapter for draw.
static Set *	_select (View *self, const char *rule)
Class *	_View (void)
static bool	acceptsKeyResponder (const View *self)
static bool	acceptsTouchResponder (const View *self)
static void	addClassName (View *self, const char *className)
static void	addSubview (View *self, View *subview)
static void	addSubviewRelativeTo (View *self, View *subview, View *other, ViewPosition position)
static View *	ancestorWithIdentifier (const View *self, const char *identifier)
static void	applyStyle (View *self, const Style *style)
static void	applyTheme (View *self, const Theme *theme)
static void	applyThemeIfNeeded (View *self, const Theme *theme)
static void	attachStylesheet (View *self, SDL_Window *window)
static void	awakeWithCharacters (View *self, const char *chars)
static void	awakeWithData (View *self, const Data *data)
static void	awakeWithDictionary (View *self, const Dictionary *dictionary)
static void	awakeWithResource (View *self, const Resource *resource)
static void	awakeWithResourceName (View *self, const char *name)
static void	becomeKeyResponder (View *self)
static void	becomeTouchResponder (View *self)
static SDL_Rect	bounds (const View *self)
static void	bringSubviewToFront (View *self, View *subview)
static void	clearWarnings (const View *self, WarningType type)
static bool	clearWarnings_predicate (const ident obj, ident data)
	Filter Predicate for clearWarnings.
static SDL_Rect	clippingFrame (const View *self)
static bool	containsPoint (const View *self, const SDL_Point *point)
static void	cornerCutPoints (SDL_Point *points, const SDL_Rect *rect, const ViewCornerCut *cut)
	Writes the four corners of rect, inset by cut, in clockwise order.
static void	dealloc (Object *self)
static int	depth (const View *self)
static View *	descendantWithIdentifier (const View *self, const char *identifier)
static String *	description (const Object *self)
static void	detachStylesheet (View *self, SDL_Window *window)
static void	didMoveToWindow (View *self, SDL_Window *window)
static bool	didReceiveEvent (const View *self, const SDL_Event *event)
static void	draw (View *self, Renderer *renderer)
static void	emitViewEvent (View *self, ViewEvent code, ident data)
static void	enumerate (View *self, ViewEnumerator enumerator, ident data)
static void	enumerateAdjacent (const View *self, ViewEnumerator enumerator, ident data)
static void	enumerateAncestors (const View *self, ViewEnumerator enumerator, ident data)
static void	enumerateDescendants (const View *self, ViewEnumerator enumerator, ident data)
static void	enumerateSelection (View *self, const char *rule, ViewEnumerator enumerator, ident data)
static void	enumerateSiblings (const View *self, ViewEnumerator enumerator, ident data)
static void	enumerateSubviews (const View *self, ViewEnumerator enumerator, ident data)
static void	enumerateSuperview (const View *self, ViewEnumerator enumerator, ident data)
static void	enumerateVisible (View *self, ViewEnumerator enumerator, ident data)
static bool	filterViewEvents (void *data, SDL_Event *event)
static bool	hasClassName (const View *self, const char *className)
static bool	hasClassName_predicate (const ident obj, ident data)
	Predicate for hasClassName.
static bool	hasOverflow (const View *self)
static void	hasOverflow_enumerate (View *view, ident data)
	ViewEnumerator for hasOverflow.
static View *	hitTest (const View *self, const SDL_Point *point)
static View *	init (View *self)
static void	initialize (Class *clazz)
static View *	initWithFrame (View *self, const SDL_Rect *frame)
static void	invalidateStyle (View *self)
static void	invalidateStyle_enumerate (View *view, ident data)
	ViewEnumerator for invalidateStyle.
static bool	isContainer (const View *self)
static bool	isDescendantOfView (const View *self, const View *view)
static bool	isKeyResponder (const View *self)
static bool	isTouchResponder (const View *self)
static bool	isVisible (const View *self)
static void	layoutIfNeeded (View *self)
static void	layoutIfNeeded_enumerate (View *subview, ident data)
	ViewEnumerator for layoutIfNeeded recursion.
static void	layoutSubviews (View *self)
static void	layoutWithConstraint (View *self, ViewConstraint width, ViewConstraint height)
static void	layoutWithSize (View *self, const SDL_Size *size)
static bool	matchesSelector (const View *self, const SimpleSelector *simpleSelector)
static void	moveToWindow (View *self, SDL_Window *window)
static void	moveToWindow_enumerate (View *subview, ident data)
	ViewEnumerator for moveToWindow recursion.
void	MVC_InvalidateRenderFrames (void)
	Invalidates every View's cached View::renderFrame and View::clippingFrame.
static void	nullifySuperview (View *subview, ident data)
	ViewEnumerator to null out superview pointers during parent dealloc.
static String *	path (const View *self)
static void	removeAllClassNames (View *self)
static void	removeAllSubviews (View *self)
static void	removeAllSubviews_enumerate (const Array *array, ident obj, ident data)
	ArrayEnumerator for removeAllSubviews.
static void	removeClassName (View *self, const char *className)
static void	removeFromSuperview (View *self)
static void	removeSubview (View *self, View *subview)
static void	render (View *self, Renderer *renderer)
static void	renderDeviceDidReset (View *self)
static void	renderDeviceDidReset_enumerate (View *subview, ident data)
	ViewEnumerator for renderDeviceDidReset recursion.
static void	renderDeviceWillReset (View *self)
static void	renderDeviceWillReset_enumerate (View *subview, ident data)
	ViewEnumerator for renderDeviceWillReset recursion.
static SDL_Rect	renderFrame (const View *self)
static void	replaceSubview (View *self, View *subview, View *replacement)
static void	resignKeyResponder (View *self)
static void	resignTouchResponder (View *self)
static void	resize (View *self, const SDL_Size *size)
static void	resolve (View *self, Outlet *outlets)
static int	resolveViewConstraint (int hasAutoresizingBit, ViewConstraint constraint, int intrinsic)
	Resolves an axis's sizeThatFits value against an offered ViewConstraint, if the View has opted into that axis's autoresizing bit; otherwise returns the value unmodified.
static void	respondToEvent (View *self, const SDL_Event *event)
static View *	selectFirst (View *self, const char *rule)
static void	setNeedsApplyTheme (View *self)
static void	setNeedsLayout (View *self)
static void	setVisibility (View *self, ViewVisibility visibility)
static SDL_Size	size (const View *self)
static SDL_Size	sizeThatContains (const View *self)
static SDL_Size	sizeThatFills (const View *self)
static SDL_Size	sizeThatFits (const View *self)
static SDL_Size	sizeThatSatisfies (View *self, ViewConstraint width, ViewConstraint height)
static void	sizeToContain (View *self)
static void	sizeToFill (View *self)
static void	sizeToFit (View *self)
static void	sizeToSatisfy (View *self, ViewConstraint width, ViewConstraint height)
static View *	subviewWithIdentifier (const View *self, const char *identifier)
static void	updateBindings (View *self, ident data)
static void	updateBindings_enumerate (View *subview, ident data)
	ViewEnumerator for updateBindings recursion.
static SDL_Rect	viewport (const View *self)
static View *	viewWithCharacters (const char *chars, Outlet *outlets)
static View *	viewWithData (const Data *data, Outlet *outlets)
static View *	viewWithDictionary (const Dictionary *dictionary, Outlet *outlets)
static View *	viewWithResource (const Resource *resource, Outlet *outlets)
static View *	viewWithResourceName (const char *name, Outlet *outlets)
static Array *	visibleSubviews (const View *self)
static bool	visibleSubviews_filter (ident obj, ident data)
	Predicate for visibleSubviews.
static void	warn (View *self, WarningType type, const char *fmt,...)
static void	willMoveToWindow (View *self, SDL_Window *window)

Variables
static unsigned	_renderFrameGeneration
	The render frame generation; per-View renderFrame and clippingFrame caches are valid only while their generation matches this. Zero disables caching entirely, for callers that never invalidate (e.g. unit tests).
Uint32	MVC_NOTIFICATION_EVENT
Uint32	MVC_VIEW_EVENT
const EnumName	ViewAlignmentNames []
const EnumName	ViewAutoresizingNames []
const EnumName	ViewPointerEventsNames []
const EnumName	ViewVisibilityNames []

Macro Definition Documentation

_Class

#define _Class   _View

Definition at line 92 of file View.c.

Function Documentation

_applyThemeIfNeeded()

static void _applyThemeIfNeeded ( View *  view, ident  data  )

static

ViewEnumerator adapter for applyThemeIfNeeded.

Definition at line 365 of file View.c.

                                                        {
  applyThemeIfNeeded(view, (const Theme *) data);
}

_bind()

static bool _bind ( View *  self, const Inlet *  inlets, const Dictionary *  dictionary  )

static

Definition at line 535 of file View.c.

                                                                                 {
 
  if (inlets) {
    if (bindInlets(inlets, dictionary)) {
      $(self, setNeedsApplyTheme);
      $(self, setNeedsLayout);
      return true;
    }
  }
 
  return false;
}

_draw()

static void _draw ( View *  view, ident  data  )

static

ViewEnumerator adapter for draw.

Definition at line 774 of file View.c.

                                          {
  draw(view, (Renderer *) data);
}

_select()

static Set * _select ( View *  self, const char *  rule  )

static

Definition at line 1804 of file View.c.

                                                  {
 
  Selector *selector = $(alloc(Selector), initWithRule, rule);
  assert(selector);
 
  Set *selection = $(selector, select, self);
 
  release(selector);
  return selection;
}

_View()

Class * _View

(

void

)

Definition at line 2336 of file View.c.

                   {
  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;
}

acceptsKeyResponder()

static bool acceptsKeyResponder ( const View *  self )

static

Definition at line 167 of file View.c.

                                                  {
  return false;
}

acceptsTouchResponder()

static bool acceptsTouchResponder ( const View *  self )

static

Definition at line 175 of file View.c.

                                                    {
  return false;
}

addClassName()

static void addClassName ( View *  self, const char *  className  )

static

Definition at line 183 of file View.c.

                                                            {
 
  if (className) {
 
    String *string = $$(String, stringWithCharacters, className);
    assert(string);
 
    $(self->classNames, addObject, string);
    release(string);
 
    $(self, invalidateStyle);
  }
}

addSubview()

static void addSubview ( View *  self, View *  subview  )

static

Definition at line 201 of file View.c.

                                                  {
  $(self, addSubviewRelativeTo, subview, NULL, ViewPositionAfter);
}

addSubviewRelativeTo()

static void addSubviewRelativeTo ( View *  self, View *  subview, View *  other, ViewPosition  position  )

static

Definition at line 209 of file View.c.

                                                                                                {
 
  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);
}

ancestorWithIdentifier()

static View * ancestorWithIdentifier ( const View *  self, const char *  identifier  )

static

Definition at line 251 of file View.c.

                                                                              {
 
  assert(identifier);
 
  View *view = (View *) self;
  while (view) {
    if (view->identifier) {
      if (strcmp(identifier, view->identifier) == 0) {
        return view;
      }
    }
    view = view->superview;
  }
 
  return NULL;
}

applyStyle()

static void applyStyle ( View *  self, const Style *  style  )

static

Definition at line 272 of file View.c.

                                                       {
 
  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`");
  }
}

applyTheme()

static void applyTheme ( View *  self, const Theme *  theme  )

static

Definition at line 335 of file View.c.

                                                       {
 
  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);
}

applyThemeIfNeeded()

static void applyThemeIfNeeded ( View *  self, const Theme *  theme  )

static

Definition at line 369 of file View.c.

                                                               {
 
  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;
  }
}

attachStylesheet()

static void attachStylesheet ( View *  self, SDL_Window *  window  )

static

Definition at line 397 of file View.c.

                                                             {
 
  assert(window);
 
  if (self->stylesheet) {
    Theme *theme = $$(Theme, theme, window);
    if (theme) {
      $(theme, addStylesheet, self->stylesheet);
    }
  }
}

awakeWithCharacters()

static void awakeWithCharacters ( View *  self, const char *  chars  )

static

Definition at line 413 of file View.c.

                                                               {
 
  Data *data = $$(Data, dataWithConstMemory, (uint8_t *) chars, strlen(chars));
 
  $(self, awakeWithData, data);
 
  release(data);
}

awakeWithData()

static void awakeWithData ( View *  self, const Data *  data  )

static

Definition at line 426 of file View.c.

                                                        {
 
  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);
}

awakeWithDictionary()

static void awakeWithDictionary ( View *  self, const Dictionary *  dictionary  )

static

Definition at line 445 of file View.c.

                                                                          {
 
  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);
}

awakeWithResource()

static void awakeWithResource ( View *  self, const Resource *  resource  )

static

Definition at line 463 of file View.c.

                                                                    {
 
  assert(resource);
 
  $(self, awakeWithData, resource->data);
}

awakeWithResourceName()

static void awakeWithResourceName ( View *  self, const char *  name  )

static

Definition at line 474 of file View.c.

                                                                {
 
  Resource *resource = $$(Resource, resourceWithName, name);
 
  $(self, awakeWithResource, resource);
 
  release(resource);
}

becomeKeyResponder()

static void becomeKeyResponder ( View *  self )

static

Definition at line 487 of file View.c.

                                           {
 
  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);
  }
}

becomeTouchResponder()

static void becomeTouchResponder ( View *  self )

static

Definition at line 511 of file View.c.

                                             {
 
  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);
  }
}

bounds()

static SDL_Rect bounds ( const View *  self )

static

Definition at line 552 of file View.c.

                                         {
 
  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;
}

bringSubviewToFront()

static void bringSubviewToFront ( View *  self, View *  subview  )

static

Definition at line 570 of file View.c.

                                                           {
 
  assert(subview);
 
  if (subview->superview == self) {
 
    View *last = $((Array *) self->subviews, lastObject);
    if (last != subview) {
      $(self, addSubviewRelativeTo, subview, last, ViewPositionAfter);
    }
  }
}

clearWarnings()

static void clearWarnings ( const View *  self, WarningType  type  )

static

Definition at line 598 of file View.c.

                                                              {
  $(self->warnings, filter, clearWarnings_predicate, &type);
}

clearWarnings_predicate()

static bool clearWarnings_predicate ( const ident  obj, ident  data  )

static

Filter Predicate for clearWarnings.

Definition at line 586 of file View.c.

                                                                 {
 
  const Warning *warning = obj;
  const WarningType type = *(WarningType *) data;
 
  return (warning->type & type) == 0;
}

clippingFrame()

static SDL_Rect clippingFrame ( const View *  self )

static

Definition at line 606 of file View.c.

                                                {
 
  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;
}

containsPoint()

static bool containsPoint ( const View *  self, const SDL_Point *  point  )

static

Definition at line 647 of file View.c.

                                                                    {
 
  const SDL_Rect frame = $(self, clippingFrame);
 
  return (bool) SDL_PointInRect(point, &frame);
}

cornerCutPoints()

static void cornerCutPoints ( SDL_Point *  points, const SDL_Rect *  rect, const ViewCornerCut *  cut  )

static

Writes the four corners of rect, inset by cut, in clockwise order.

Each inset pulls its corner in along the x axis, so an inset on one of a pair of vertically adjacent corners slants the edge between them. The two insets on an edge are clamped against each other as well as the width, so however large a cut is the edge closes to a point rather than crossing over itself.

Definition at line 1496 of file View.c.

                                                                                               {
 
  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);
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 118 of file View.c.

                                  {
 
  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);
}

depth()

static int depth ( const View *  self )

static

Definition at line 658 of file View.c.

                                   {
  return (self->superview ? $(self->superview, depth) + 1 : 0);
}

descendantWithIdentifier()

static View * descendantWithIdentifier ( const View *  self, const char *  identifier  )

static

Definition at line 666 of file View.c.

                                                                                {
 
  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;
}

description()

static String * description ( const Object *  self )

static

See also

Object::description(const Object *)

Definition at line 145 of file View.c.

                                               {
 
  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;
}

detachStylesheet()

static void detachStylesheet ( View *  self, SDL_Window *  window  )

static

Definition at line 693 of file View.c.

                                                             {
 
  assert(window);
 
  if (self->stylesheet) {
    Theme *theme = $$(Theme, theme, window);
    if (theme) {
      $(theme, removeStylesheet, self->stylesheet);
    }
  }
}

didMoveToWindow()

static void didMoveToWindow ( View *  self, SDL_Window *  window  )

static

Definition at line 709 of file View.c.

                                                            {
 
  if (window) {
    $(self, attachStylesheet, window);
 
    if (self->superview == NULL) {
      $(self, sizeToFill);
    }
 
    $(self, setNeedsLayout);
  }
}

didReceiveEvent()

static bool didReceiveEvent ( const View *  self, const SDL_Event *  event  )

static

Definition at line 726 of file View.c.

                                                                      {
 
  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;
}

draw()

static void draw ( View *  self, Renderer *  renderer  )

static

Definition at line 778 of file View.c.

                                                 {
 
  assert(self->window);
 
  if (self->visibility != ViewVisibilityHidden) {
 
    $(renderer, drawView, self);
 
    $(self, enumerateSubviews, _draw, renderer);
  }
}

emitViewEvent()

static void emitViewEvent ( View *  self, ViewEvent  code, ident  data  )

static

Definition at line 794 of file View.c.

                                                                  {
  SDL_PushEvent((SDL_Event *) &(const SDL_UserEvent) {
    .type = MVC_VIEW_EVENT,
    .code = code,
    .data1 = self,
    .data2 = data
  });
}

enumerate()

static void enumerate ( View *  self, ViewEnumerator  enumerator, ident  data  )

static

Definition at line 807 of file View.c.

                                                                         {
 
  assert(enumerator);
 
  enumerator(self, data);
 
  $(self, enumerateDescendants, enumerator, data);
}

enumerateAdjacent()

static void enumerateAdjacent ( const View *  self, ViewEnumerator  enumerator, ident  data  )

static

Definition at line 820 of file View.c.

                                                                                       {
 
  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);
    }
  }
}

enumerateAncestors()

static void enumerateAncestors ( const View *  self, ViewEnumerator  enumerator, ident  data  )

static

Definition at line 840 of file View.c.

                                                                                        {
 
  assert(enumerator);
 
  for (View *view = self->superview; view; view = view->superview) {
    enumerator(view, data);
  }
}

enumerateDescendants()

static void enumerateDescendants ( const View *  self, ViewEnumerator  enumerator, ident  data  )

static

Definition at line 866 of file View.c.

                                                                                          {
 
  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);
  }
}

enumerateSelection()

static void enumerateSelection ( View *  self, const char *  rule, ViewEnumerator  enumerator, ident  data  )

static

Definition at line 853 of file View.c.

                                                                                                    {
 
  Selector *selector = $(alloc(Selector), initWithRule, rule);
  assert(selector);
 
  $(selector, enumerateSelection, self, enumerator, data);
  release(selector);
}

enumerateSiblings()

static void enumerateSiblings ( const View *  self, ViewEnumerator  enumerator, ident  data  )

static

Definition at line 884 of file View.c.

                                                                                       {
 
  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);
      }
    }
  }
}

enumerateSubviews()

static void enumerateSubviews ( const View *  self, ViewEnumerator  enumerator, ident  data  )

static

Definition at line 904 of file View.c.

                                                                                       {
 
  assert(enumerator);
 
  const Array *subviews = (Array *) self->subviews;
  for (size_t i = 0; i < subviews->count; i++) {
    enumerator((View *) subviews->elements[i], data);
  }
}

enumerateSuperview()

static void enumerateSuperview ( const View *  self, ViewEnumerator  enumerator, ident  data  )

static

Definition at line 918 of file View.c.

                                                                                        {
 
  assert(enumerator);
 
  if (self->superview) {
    enumerator(self->superview, data);
  }
}

enumerateVisible()

static void enumerateVisible ( View *  self, ViewEnumerator  enumerator, ident  data  )

static

Definition at line 931 of file View.c.

                                                                                {
 
  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);
  }
}

filterViewEvents()

static bool filterViewEvents ( void *  data, SDL_Event *  event  )

static

SDL_EventFilter to purge any MVC_VIEW_EVENTs for this View.

Definition at line 99 of file View.c.

                                                           {
 
  if (event->type == MVC_VIEW_EVENT && event->user.data1 == data) {
    return false;
  }
 
  return true;
}

hasClassName()

static bool hasClassName ( const View *  self, const char *  className  )

static

Definition at line 958 of file View.c.

                                                                  {
 
  if (className) {
    return $((Set *) self->classNames, containsObjectMatching, hasClassName_predicate, (ident) className);
  }
 
  return false;
}

hasClassName_predicate()

static bool hasClassName_predicate ( const ident  obj, ident  data  )

static

Predicate for hasClassName.

Definition at line 950 of file View.c.

                                                                {
  return strcmp(((String *) obj)->chars, (const char *) data) == 0;
}

hasOverflow()

static bool hasOverflow ( const View *  self )

static

Definition at line 997 of file View.c.

                                          {
 
  Overflow overflow = {
    .bounds = $(self, bounds)
  };
 
  $(self, enumerateSubviews, hasOverflow_enumerate, (ident) &overflow);
 
  return overflow.hasOverflow;
}

hasOverflow_enumerate()

static void hasOverflow_enumerate ( View *  view, ident  data  )

static

ViewEnumerator for hasOverflow.

Definition at line 975 of file View.c.

                                                          {
 
  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);
    }
  }
}

hitTest()

static View * hitTest ( const View *  self, const SDL_Point *  point  )

static

Definition at line 1012 of file View.c.

                                                               {
 
  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;
}

init()

static View * init ( View *  self )

static

Definition at line 1039 of file View.c.

                              {
  return $(self, initWithFrame, NULL);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 2222 of file View.c.

                                     {
 
  ((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);
}

initWithFrame()

static View * initWithFrame ( View *  self, const SDL_Rect *  frame  )

static

Definition at line 1047 of file View.c.

                                                              {
 
  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;
}

invalidateStyle()

static void invalidateStyle ( View *  self )

static

Definition at line 1092 of file View.c.

                                        {
  $(self, enumerate, invalidateStyle_enumerate, NULL);
}

invalidateStyle_enumerate()

static void invalidateStyle_enumerate ( View *  view, ident  data  )

static

ViewEnumerator for invalidateStyle.

Definition at line 1081 of file View.c.

                                                              {
 
  view->needsApplyStyle = true;
 
  $(view, setNeedsApplyTheme);
}

isContainer()

static bool isContainer ( const View *  self )

static

Definition at line 1100 of file View.c.

                                          {
  return self->autoresizingMask & (ViewAutoresizingFit | ViewAutoresizingContain);
}

isDescendantOfView()

static bool isDescendantOfView ( const View *  self, const View *  view  )

static

Definition at line 1108 of file View.c.

                                                                   {
 
  assert(view);
 
  while (self) {
    if (self == view) {
      return true;
    }
    self = self->superview;
  }
 
  return false;
}

isKeyResponder()

static bool isKeyResponder ( const View *  self )

static

Definition at line 1126 of file View.c.

                                             {
 
  if (self->window) {
    return SDL_GetPointerProperty(SDL_GetWindowProperties(self->window), "keyResponder", NULL) == self;
  } else {
    return false;
  }
}

isTouchResponder()

static bool isTouchResponder ( const View *  self )

static

Definition at line 1139 of file View.c.

                                               {
 
  if (self->window) {
    return SDL_GetPointerProperty(SDL_GetWindowProperties(self->window), "touchResponder", NULL) == self;
  } else {
    return false;
  }
}

isVisible()

static bool isVisible ( const View *  self )

static

Definition at line 1152 of file View.c.

                                        {
 
  for (const View *view = self; view; view = view->superview) {
    if (view->visibility == ViewVisibilityHidden) {
      return false;
    }
  }
 
  return true;
}

layoutIfNeeded()

static void layoutIfNeeded ( View *  self )

static

Definition at line 1174 of file View.c.

                                       {
 
  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);
  }
}

layoutIfNeeded_enumerate()

static void layoutIfNeeded_enumerate ( View *  subview, ident  data  )

static

ViewEnumerator for layoutIfNeeded recursion.

Definition at line 1166 of file View.c.

                                                                {
  $(subview, layoutIfNeeded);
}

layoutSubviews()

static void layoutSubviews ( View *  self )

static

Definition at line 1207 of file View.c.

                                       {
 
  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;
    }
  }
}

layoutWithConstraint()

static void layoutWithConstraint ( View *  self, ViewConstraint  width, ViewConstraint  height  )

static

Definition at line 1254 of file View.c.

                                                                                          {
 
  $(self, sizeToSatisfy, width, height);
  $(self, clearWarnings, WarningTypeLayout);
  $(self, layoutSubviews);
 
  self->needsLayout = false;
}

layoutWithSize()

static void layoutWithSize ( View *  self, const SDL_Size *  size  )

static

Definition at line 1267 of file View.c.

                                                             {
 
  $(self, resize, size);
  $(self, clearWarnings, WarningTypeLayout);
  $(self, layoutSubviews);
 
  self->needsLayout = false;
}

matchesSelector()

static bool matchesSelector ( const View *  self, const SimpleSelector *  simpleSelector  )

static

Definition at line 1280 of file View.c.

                                                                                    {
 
  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;
}

moveToWindow()

static void moveToWindow ( View *  self, SDL_Window *  window  )

static

Definition at line 1351 of file View.c.

                                                         {
 
  $(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);
}

moveToWindow_enumerate()

static void moveToWindow_enumerate ( View *  subview, ident  data  )

static

ViewEnumerator for moveToWindow recursion.

Definition at line 1343 of file View.c.

                                                              {
  $(subview, moveToWindow, data);
}

MVC_InvalidateRenderFrames()

void MVC_InvalidateRenderFrames

(

void

)

Invalidates every View's cached View::renderFrame and View::clippingFrame.

WindowController::renderTo invokes this after layout, before drawing, so that drawing and subsequent hit-testing observe post-layout frames; both methods memoize their result until the next invocation. Callers that mutate View frames outside of a layout pass MUST invoke this afterwards if hit-testing precision is required before the next render.

Definition at line 46 of file View.c.

                                      {
  if (++_renderFrameGeneration == 0) {
    _renderFrameGeneration = 1;
  }
}

nullifySuperview()

static void nullifySuperview ( View *  subview, ident  data  )

static

ViewEnumerator to null out superview pointers during parent dealloc.

Definition at line 111 of file View.c.

                                                        {
  subview->superview = NULL;
}

path()

static String * path ( const View *  self )

static

Definition at line 1378 of file View.c.

                                      {
 
  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;
}

removeAllClassNames()

static void removeAllClassNames ( View *  self )

static

Definition at line 1419 of file View.c.

                                            {
 
  $(self->classNames, removeAllObjects);
 
  $(self, invalidateStyle);
}

removeAllSubviews()

static void removeAllSubviews ( View *  self )

static

Definition at line 1437 of file View.c.

                                          {
  $(self->subviews, removeAllObjectsWithEnumerator, removeAllSubviews_enumerate, self);
}

removeAllSubviews_enumerate()

static void removeAllSubviews_enumerate ( const Array *  array, ident  obj, ident  data  )

static

ArrayEnumerator for removeAllSubviews.

Definition at line 1429 of file View.c.

                                                                                   {
  $((View *) data, removeSubview, obj);
}

removeClassName()

static void removeClassName ( View *  self, const char *  className  )

static

Definition at line 1445 of file View.c.

                                                               {
 
  if (className) {
    String *string = $$(String, stringWithCharacters, className);
    assert(string);
 
    $(self->classNames, removeObject, string);
    release(string);
 
    $(self, invalidateStyle);
  }
}

removeFromSuperview()

static void removeFromSuperview ( View *  self )

static

Definition at line 1462 of file View.c.

                                            {
 
  if (self->superview) {
    $(self->superview, removeSubview, self);
  }
}

removeSubview()

static void removeSubview ( View *  self, View *  subview  )

static

Definition at line 1473 of file View.c.

                                                     {
 
  assert(subview);
 
  if (subview->superview == self) {
    
    subview->superview = NULL;
 
    $(subview, moveToWindow, NULL);
 
    $(self->subviews, removeObject, subview);
 
    $(self, setNeedsLayout);
  }
}

render()

static void render ( View *  self, Renderer *  renderer  )

static

Definition at line 1519 of file View.c.

                                                   {
 
  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;
      }
    }
  }
}

renderDeviceDidReset()

static void renderDeviceDidReset ( View *  self )

static

Definition at line 1606 of file View.c.

                                             {
  $(self, enumerateSubviews, renderDeviceDidReset_enumerate, NULL);
}

renderDeviceDidReset_enumerate()

static void renderDeviceDidReset_enumerate ( View *  subview, ident  data  )

static

ViewEnumerator for renderDeviceDidReset recursion.

Definition at line 1598 of file View.c.

                                                                      {
  $(subview, renderDeviceDidReset);
}

renderDeviceWillReset()

static void renderDeviceWillReset ( View *  self )

static

Definition at line 1621 of file View.c.

                                              {
  $(self, enumerateSubviews, renderDeviceWillReset_enumerate, NULL);
}

renderDeviceWillReset_enumerate()

static void renderDeviceWillReset_enumerate ( View *  subview, ident  data  )

static

ViewEnumerator for renderDeviceWillReset recursion.

Definition at line 1613 of file View.c.

                                                                       {
  $(subview, renderDeviceWillReset);
}

renderFrame()

static SDL_Rect renderFrame ( const View *  self )

static

Definition at line 1629 of file View.c.

                                              {
 
  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;
}

replaceSubview()

static void replaceSubview ( View *  self, View *  subview, View *  replacement  )

static

Definition at line 1663 of file View.c.

                                                                         {
 
  assert(subview);
  assert(replacement);
 
  $(self, addSubviewRelativeTo, replacement, subview, ViewPositionAfter);
  $(self, removeSubview, subview);
}

resignKeyResponder()

static void resignKeyResponder ( View *  self )

static

Definition at line 1676 of file View.c.

                                           {
 
  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);
  }
}

resignTouchResponder()

static void resignTouchResponder ( View *  self )

static

Definition at line 1692 of file View.c.

                                             {
 
  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);
  }
}

resize()

static void resize ( View *  self, const SDL_Size *  size  )

static

Definition at line 1708 of file View.c.

                                                     {
 
  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);
      }
    }
  }
}

resolve()

static void resolve ( View *  self, Outlet *  outlets  )

static

Definition at line 1732 of file View.c.

                                                 {
 
  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);
    }
  }
}

resolveViewConstraint()

static int resolveViewConstraint ( int  hasAutoresizingBit, ViewConstraint  constraint, int  intrinsic  )

static

Resolves an axis's sizeThatFits value against an offered ViewConstraint, if the View has opted into that axis's autoresizing bit; otherwise returns the value unmodified.

Definition at line 1959 of file View.c.

                                                                                                   {
 
  if (!hasAutoresizingBit) {
    return intrinsic;
  }
 
  switch (constraint.mode) {
    case ViewConstraintEqual:
      return constraint.value;
    case ViewConstraintMax:
      return min(intrinsic, constraint.value);
    default:
      return intrinsic;
  }
}

respondToEvent()

static void respondToEvent ( View *  self, const SDL_Event *  event  )

static

Definition at line 1752 of file View.c.

                                                               {
 
  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);
  }
}

selectFirst()

static View * selectFirst ( View *  self, const char *  rule  )

static

Definition at line 1819 of file View.c.

                                                       {
 
  Selector *selector = $(alloc(Selector), initWithRule, rule);
  assert(selector);
 
  View *first = $(selector, selectFirst, self);
 
  release(selector);
  return first;
}

setNeedsApplyTheme()

static void setNeedsApplyTheme ( View *  self )

static

Definition at line 1852 of file View.c.

                                           {
 
  self->needsApplyTheme = true;
 
  for (View *view = self->superview; view && !view->needsApplyThemeSubviews; view = view->superview) {
    view->needsApplyThemeSubviews = true;
  }
}

setNeedsLayout()

static void setNeedsLayout ( View *  self )

static

Definition at line 1865 of file View.c.

                                       {
 
  self->needsLayout = true;
 
  for (View *view = self->superview; view && !view->needsLayoutSubviews; view = view->superview) {
    view->needsLayoutSubviews = true;
  }
}

setVisibility()

static void setVisibility ( View *  self, ViewVisibility  visibility  )

static

Definition at line 1834 of file View.c.

                                                                 {
 
  if (self->visibility != visibility) {
 
    self->visibility = visibility;
 
    $(self->style, addEnumAttribute, "visibility", ViewVisibilityNames, visibility);
 
    if (self->superview && $(self->superview, isContainer)) {
      $(self->superview, setNeedsLayout);
    }
  }
}

size()

static SDL_Size size ( const View *  self )

static

Definition at line 1878 of file View.c.

                                       {
  return MakeSize(self->frame.w, self->frame.h);
}

sizeThatContains()

static SDL_Size sizeThatContains ( const View *  self )

static

Definition at line 1886 of file View.c.

                                                   {
 
  const SDL_Size size = $(self, size);
  const SDL_Size sizeThatFits = $(self, sizeThatFits);
 
  return MakeSize(max(size.w, sizeThatFits.w), max(size.h, sizeThatFits.h));
}

sizeThatFills()

static SDL_Size sizeThatFills ( const View *  self )

static

Definition at line 1898 of file View.c.

                                                {
  SDL_Size size;
 
  if (self->superview == NULL) {
    SDL_GetWindowSize(self->window, &size.w, &size.h);
  } else {
    size = $(self->superview, size);
  }
 
  return size;
}

sizeThatFits()

static SDL_Size sizeThatFits ( const View *  self )

static

Definition at line 1914 of file View.c.

                                               {
 
  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;
}

sizeThatSatisfies()

static SDL_Size sizeThatSatisfies ( View *  self, ViewConstraint  width, ViewConstraint  height  )

static

Definition at line 1979 of file View.c.

                                                                                           {
 
  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;
}

sizeToContain()

static void sizeToContain ( View *  self )

static

Definition at line 1996 of file View.c.

                                      {
 
  const SDL_Size size = $(self, sizeThatContains);
 
  $(self, resize, &size);
}

sizeToFill()

static void sizeToFill ( View *  self )

static

Definition at line 2007 of file View.c.

                                   {
 
  const SDL_Size size = $(self, sizeThatFills);
 
  $(self, resize, &size);
}

sizeToFit()

static void sizeToFit ( View *  self )

static

Definition at line 2018 of file View.c.

                                  {
 
  const SDL_Size size = $(self, sizeThatFits);
 
  $(self, resize, &size);
}

sizeToSatisfy()

static void sizeToSatisfy ( View *  self, ViewConstraint  width, ViewConstraint  height  )

static

Definition at line 2029 of file View.c.

                                                                                   {
 
  const SDL_Size size = $(self, sizeThatSatisfies, width, height);
 
  $(self, resize, &size);
}

subviewWithIdentifier()

static View * subviewWithIdentifier ( const View *  self, const char *  identifier  )

static

Definition at line 2040 of file View.c.

                                                                             {
 
  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;
}

updateBindings()

static void updateBindings ( View *  self, ident  data  )

static

Definition at line 2070 of file View.c.

                                                   {
  $(self, enumerateSubviews, updateBindings_enumerate, data);
}

updateBindings_enumerate()

static void updateBindings_enumerate ( View *  subview, ident  data  )

static

ViewEnumerator for updateBindings recursion.

Definition at line 2062 of file View.c.

                                                                {
  $(subview, updateBindings, data);
}

viewport()

static SDL_Rect viewport ( const View *  self )

static

Definition at line 2078 of file View.c.

                                           {
 
  assert(self->window);
 
  const SDL_Rect frame =  $(self, renderFrame);
 
  return MVC_TransformToWindow(self->window, &frame);
}

viewWithCharacters()

static View * viewWithCharacters ( const char *  chars, Outlet *  outlets  )

static

Definition at line 2091 of file View.c.

                                                                    {
 
  Data *data = $$(Data, dataWithConstMemory, (ident) chars, strlen(chars));
 
  View *view = $$(View, viewWithData, data, outlets);
 
  release(data);
 
  return view;
}

viewWithData()

static View * viewWithData ( const Data *  data, Outlet *  outlets  )

static

Definition at line 2106 of file View.c.

                                                             {
 
  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;
}

viewWithDictionary()

static View * viewWithDictionary ( const Dictionary *  dictionary, Outlet *  outlets  )

static

Definition at line 2127 of file View.c.

                                                                               {
 
  View *view = NULL;
 
  BindInlet(&MakeInlet(NULL, InletTypeView, &view, NULL), dictionary);
 
  $(view, resolve, outlets);
 
  return view;
}

viewWithResource()

static View * viewWithResource ( const Resource *  resource, Outlet *  outlets  )

static

Definition at line 2142 of file View.c.

                                                                         {
 
  assert(resource);
 
  return $$(View, viewWithData, resource->data, outlets);
}

viewWithResourceName()

static View * viewWithResourceName ( const char *  name, Outlet *  outlets  )

static

Definition at line 2153 of file View.c.

                                                                     {
 
  Resource *resource = $$(Resource, resourceWithName, name);
 
  View *view = $$(View, viewWithResource, resource, outlets);
 
  release(resource);
 
  return view;
}

visibleSubviews()

static Array * visibleSubviews ( const View *  self )

static

Definition at line 2178 of file View.c.

                                                {
  return $((Array *) self->subviews, filteredArray, visibleSubviews_filter, NULL);
}

visibleSubviews_filter()

static bool visibleSubviews_filter ( ident  obj, ident  data  )

static

Predicate for visibleSubviews.

Definition at line 2167 of file View.c.

                                                          {
 
  const View *view = (View *) obj;
 
  return view->visibility != ViewVisibilityHidden && view->alignment != ViewAlignmentInternal;
}

warn()

static void warn ( View *  self, WarningType  type, const char *  fmt,   ...  )

static

Definition at line 2186 of file View.c.

                                                                     {
 
  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);
}

willMoveToWindow()

static void willMoveToWindow ( View *  self, SDL_Window *  window  )

static

Definition at line 2208 of file View.c.

                                                             {
 
  if (self->window) {
    $(self, resignKeyResponder);
    $(self, resignTouchResponder);
    $(self, detachStylesheet, self->window);
  }
}

Variable Documentation

_renderFrameGeneration

unsigned _renderFrameGeneration

static

The render frame generation; per-View renderFrame and clippingFrame caches are valid only while their generation matches this. Zero disables caching entirely, for callers that never invalidate (e.g. unit tests).

Definition at line 44 of file View.c.

MVC_NOTIFICATION_EVENT

Uint32 MVC_NOTIFICATION_EVENT

Definition at line 36 of file View.c.

MVC_VIEW_EVENT

Uint32 MVC_VIEW_EVENT

Definition at line 37 of file View.c.

ViewAlignmentNames

const EnumName ViewAlignmentNames[]

Initial value:

= 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)
)

Definition at line 63 of file View.c.

ViewAutoresizingNames

const EnumName ViewAutoresizingNames[]

Initial value:

= MakeEnumNames(
  MakeEnumAlias(ViewAutoresizingNone, none),
  MakeEnumAlias(ViewAutoresizingWidth, width),
  MakeEnumAlias(ViewAutoresizingHeight, height),
  MakeEnumAlias(ViewAutoresizingFill, fill),
  MakeEnumAlias(ViewAutoresizingFit, fit),
  MakeEnumAlias(ViewAutoresizingContain, contain)
)

Definition at line 83 of file View.c.

ViewPointerEventsNames

const EnumName ViewPointerEventsNames[]

Initial value:

= MakeEnumNames(
  MakeEnumAlias(ViewPointerEventsAuto, auto),
  MakeEnumAlias(ViewPointerEventsNone, none)
)

Definition at line 52 of file View.c.

ViewVisibilityNames

const EnumName ViewVisibilityNames[]

Initial value:

= MakeEnumNames(
  MakeEnumAlias(ViewVisibilityUnspecified, unspecified),
  MakeEnumAlias(ViewVisibilityVisible, visible),
  MakeEnumAlias(ViewVisibilityHidden, hidden)
)

Definition at line 57 of file View.c.