Style.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <Objectively.h>
#include "Style.h"

Go to the source code of this file.

Data Structures
struct	StyleShorthand
	A shorthand attribute, and the longhands it stands for. More...

Macros
#define	_Class   _Style

Functions
Class *	_Style (void)
static void	addAttribute (Style *self, const char *attr, ident value)
static void	addAttributes (Style *self, const Dictionary *attributes)
static void	addAttributes_enumerate (const Dictionary *dictionary, ident obj, ident key, ident data)
	DictionaryEnumerator for addAttributes.
static void	addBoolAttribute (Style *self, const char *attr, bool value)
static void	addCharactersAttribute (Style *self, const char *attr, const char *value)
static void	addColorAttribute (Style *self, const char *attr, const SDL_Color *color)
static void	addDoubleAttribute (Style *self, const char *attr, double value)
static void	addEnumAttribute (Style *self, const char *attr, const EnumName *names, int value)
static void	addFloatAttribute (Style *self, const char *attr, float value)
static void	addIntegerAttribute (Style *self, const char *attr, int value)
static void	addPointAttribute (Style *self, const char *attr, const SDL_Point *value)
static void	addRectangleAttribute (Style *self, const char *attr, const SDL_Rect *value)
static void	addSelector (Style *self, Selector *selector)
static bool	addShorthandAttribute (Style *self, const StyleShorthand *shorthand, ident value)
	Stores value as the longhands of shorthand, if it can be split into them.
static void	addSizeAttribute (Style *self, const char *attr, const SDL_Size *value)
static ident	attributeValue (const Style *self, const char *attr)
static void	dealloc (Object *self)
static String *	description (const Object *self)
static int	hash (const Object *self)
static void	initialize (Class *clazz)
static Style *	initWithAttributes (Style *self, const Dictionary *attributes)
static Style *	initWithRules (Style *self, const char *rules)
static bool	isComputedEqual (const Style *self, const Style *other)
static bool	isEqual (const Object *self, const Object *other)
static Array *	parse (const char *css)
static ident	parseValue (String *string)
static void	removeAllAttributes (Style *self)
static void	removeAttribute (Style *self, const char *attr)
static void	setAttribute (Style *self, const char *key, ident value)
	Stores value under key, expanding it into longhands if key is a shorthand.
static char *	stripComments (const char *css)
	Returns a newly allocated copy of css with all / * ... * / comments removed. The tokenizer below splits on { : ; } and has no notion of comments, so a comment absorbed into a selector or declaration silently corrupts the rule. Each comment is replaced by a single space so it still separates adjacent tokens. The caller must free the returned buffer.
static size_t	styleShorthandCount (const StyleShorthand *shorthand)
static const StyleShorthand *	styleShorthandForKey (const char *key)

Variables
static const StyleShorthand	styleShorthands []

Macro Definition Documentation

_Class

#define _Class   _Style

Definition at line 32 of file Style.c.

Function Documentation

_Style()

Class * _Style

(

void

)

Definition at line 676 of file Style.c.

                    {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "Style",
      .superclass = _Object(),
      .instanceSize = sizeof(Style),
      .interfaceSize = sizeof(StyleInterface),
      .initialize = initialize,
    });
  });
 
  return clazz;
}

addAttribute()

static void addAttribute ( Style *  self, const char *  attr, ident  value  )

static

Definition at line 196 of file Style.c.

                                                                     {
 
  assert(attr);
  assert(value);
 
  char *key = strtrim(attr);
  assert(key);
 
  setAttribute(self, key, value);
 
  free(key);
}

addAttributes()

static void addAttributes ( Style *  self, const Dictionary *  attributes  )

static

Definition at line 221 of file Style.c.

                                                                     {
 
  assert(attributes);
 
  $(attributes, enumerateObjectsAndKeys, addAttributes_enumerate, self);
}

addAttributes_enumerate()

static void addAttributes_enumerate ( const Dictionary *  dictionary, ident  obj, ident  key, ident  data  )

static

DictionaryEnumerator for addAttributes.

Definition at line 212 of file Style.c.

                                                                                                    {
 
  setAttribute((Style *) data, ((String *) key)->chars, obj);
}

addBoolAttribute()

static void addBoolAttribute ( Style *  self, const char *  attr, bool  value  )

static

Definition at line 232 of file Style.c.

                                                                        {
  $(self, addAttribute, attr, $$(Boole, valueof, value));
}

addCharactersAttribute()

static void addCharactersAttribute ( Style *  self, const char *  attr, const char *  value  )

static

Definition at line 240 of file Style.c.

                                                                                     {
 
  String *string = $$(String, stringWithCharacters, value);
 
  $(self, addAttribute, attr, string);
 
  release(string);
}

addColorAttribute()

static void addColorAttribute ( Style *  self, const char *  attr, const SDL_Color *  color  )

static

Definition at line 253 of file Style.c.

                                                                                     {
 
  Number *r = $$(Number, numberWithValue, color->r);
  Number *g = $$(Number, numberWithValue, color->g);
  Number *b = $$(Number, numberWithValue, color->b);
  Number *a = $$(Number, numberWithValue, color->a);
 
  Array *array = $$(Array, arrayWithObjects, r, g, b, a, NULL);
 
  $(self, addAttribute, attr, array);
 
  release(array);
  release(r);
  release(g);
  release(b);
  release(a);
}

addDoubleAttribute()

static void addDoubleAttribute ( Style *  self, const char *  attr, double  value  )

static

Definition at line 275 of file Style.c.

                                                                            {
 
  Number *number = $$(Number, numberWithValue, value);
 
  $(self, addAttribute, attr, number);
 
  release(number);
}

addEnumAttribute()

static void addEnumAttribute ( Style *  self, const char *  attr, const EnumName *  names, int  value  )

static

Definition at line 288 of file Style.c.

                                                                                              {
 
  String *string = nameof(names, value);
 
  $(self, addAttribute, attr, string);
 
  release(string);
}

addFloatAttribute()

static void addFloatAttribute ( Style *  self, const char *  attr, float  value  )

static

Definition at line 301 of file Style.c.

                                                                          {
  $(self, addDoubleAttribute, attr, value);
}

addIntegerAttribute()

static void addIntegerAttribute ( Style *  self, const char *  attr, int  value  )

static

Definition at line 309 of file Style.c.

                                                                          {
  $(self, addDoubleAttribute, attr, value);
}

addPointAttribute()

static void addPointAttribute ( Style *  self, const char *  attr, const SDL_Point *  value  )

static

Definition at line 317 of file Style.c.

                                                                                     {
 
  Number *x = $$(Number, numberWithValue, value->x);
  Number *y = $$(Number, numberWithValue, value->y);
 
  Array *array = $$(Array, arrayWithObjects, x, y, NULL);
 
  $(self, addAttribute, attr, array);
 
  release(array);
  release(x);
  release(y);
}

addRectangleAttribute()

static void addRectangleAttribute ( Style *  self, const char *  attr, const SDL_Rect *  value  )

static

Definition at line 335 of file Style.c.

                                                                                        {
 
  Number *x = $$(Number, numberWithValue, value->x);
  Number *y = $$(Number, numberWithValue, value->y);
  Number *w = $$(Number, numberWithValue, value->w);
  Number *h = $$(Number, numberWithValue, value->h);
 
  Array *array = $$(Array, arrayWithObjects, x, y, w, h, NULL);
 
  $(self, addAttribute, attr, array);
 
  release(array);
  release(x);
  release(y);
  release(w);
  release(h);
}

addSelector()

static void addSelector ( Style *  self, Selector *  selector  )

static

Definition at line 357 of file Style.c.

                                                         {
 
  assert(selector);
 
  $((Array *) self->selectors, addObject, selector);
}

addShorthandAttribute()

static bool addShorthandAttribute ( Style *  self, const StyleShorthand *  shorthand, ident  value  )

static

Stores value as the longhands of shorthand, if it can be split into them.

Returns

True if the value was expanded and stored.

Remarks

A single Number splats to every longhand, as View+JSON's rectangle binding does, so padding: 2 still means all four sides. A value of any other shape is left to the Inlet binding to reject, rather than being silently dropped here.

Definition at line 156 of file Style.c.

                                                                                             {
 
  const size_t count = styleShorthandCount(shorthand);
 
  if ($((Object *) value, isKindOfClass, _Number())) {
    for (size_t i = 0; i < count; i++) {
      $((Dictionary *) self->attributes, setObjectForKeyPath, value, shorthand->longhands[i]);
    }
    return true;
  }
 
  if ($((Object *) value, isKindOfClass, _Array())) {
    const Array *array = value;
    if (array->count == count) {
      for (size_t i = 0; i < count; i++) {
        ident number = $(array, objectAtIndex, i);
        $((Dictionary *) self->attributes, setObjectForKeyPath, number, shorthand->longhands[i]);
      }
      return true;
    }
  }
 
  return false;
}

addSizeAttribute()

static void addSizeAttribute ( Style *  self, const char *  attr, const SDL_Size *  value  )

static

Definition at line 368 of file Style.c.

                                                                                   {
 
  Number *w = $$(Number, numberWithValue, value->w);
  Number *h = $$(Number, numberWithValue, value->h);
 
  Array *array = $$(Array, arrayWithObjects, w, h, NULL);
 
  $(self, addAttribute, attr, array);
 
  release(array);
  release(w);
  release(h);
}

attributeValue()

static ident attributeValue ( const Style *  self, const char *  attr  )

static

Definition at line 386 of file Style.c.

                                                                 {
  return $((Dictionary *) self->attributes, objectForKeyPath, attr);
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 39 of file Style.c.

                                  {
 
  Style *this = (Style *) self;
 
  release(this->attributes);
  release(this->selectors);
 
  super(Object, self, dealloc);
}

description()

static String * description ( const Object *  self )

static

See also

Object::description(const Object *)

Definition at line 52 of file Style.c.

                                               {
 
  const Style *this = (Style *) self;
 
  return $((Array *) this->selectors, componentsJoinedByCharacters, ", ");
}

hash()

static int hash ( const Object *  self )

static

See also

Object::hash(const Object *)

Definition at line 62 of file Style.c.

                                    {
 
  Style *this = (Style *) self;
 
  int hash = HASH_SEED;
 
  hash = HashForObject(hash, this->attributes);
  hash = HashForObject(hash, this->selectors);
 
  return hash;
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 643 of file Style.c.

                                     {
 
  ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
  ((ObjectInterface *) clazz->interface)->description = description;
  ((ObjectInterface *) clazz->interface)->hash = hash;
  ((ObjectInterface *) clazz->interface)->isEqual = isEqual;
 
  ((StyleInterface *) clazz->interface)->addAttribute = addAttribute;
  ((StyleInterface *) clazz->interface)->addAttributes = addAttributes;
  ((StyleInterface *) clazz->interface)->addBoolAttribute = addBoolAttribute;
  ((StyleInterface *) clazz->interface)->addCharactersAttribute = addCharactersAttribute;
  ((StyleInterface *) clazz->interface)->addColorAttribute = addColorAttribute;
  ((StyleInterface *) clazz->interface)->addDoubleAttribute = addDoubleAttribute;
  ((StyleInterface *) clazz->interface)->addEnumAttribute = addEnumAttribute;
  ((StyleInterface *) clazz->interface)->addFloatAttribute = addFloatAttribute;
  ((StyleInterface *) clazz->interface)->addIntegerAttribute = addIntegerAttribute;
  ((StyleInterface *) clazz->interface)->addPointAttribute = addPointAttribute;
  ((StyleInterface *) clazz->interface)->addRectangleAttribute = addRectangleAttribute;
  ((StyleInterface *) clazz->interface)->addSelector = addSelector;
  ((StyleInterface *) clazz->interface)->addSizeAttribute = addSizeAttribute;
  ((StyleInterface *) clazz->interface)->attributeValue = attributeValue;
  ((StyleInterface *) clazz->interface)->initWithAttributes = initWithAttributes;
  ((StyleInterface *) clazz->interface)->initWithRules = initWithRules;
  ((StyleInterface *) clazz->interface)->isComputedEqual = isComputedEqual;
  ((StyleInterface *) clazz->interface)->parse = parse;
  ((StyleInterface *) clazz->interface)->removeAllAttributes = removeAllAttributes;
  ((StyleInterface *) clazz->interface)->removeAttribute = removeAttribute;
}

initWithAttributes()

static Style * initWithAttributes ( Style *  self, const Dictionary *  attributes  )

static

Definition at line 394 of file Style.c.

                                                                            {
 
  self = $(self, initWithRules, NULL);
  if (self) {
    if (attributes) {
      $(self, addAttributes, attributes);
    }
  }
 
  return self;
}

initWithRules()

static Style * initWithRules ( Style *  self, const char *  rules  )

static

Definition at line 410 of file Style.c.

                                                            {
 
  self = (Style *) super(Object, self, init);
  if (self) {
 
    self->selectors = $$(Selector, parse, rules);
    assert(self->selectors);
 
    for (size_t i = 0; i < self->selectors->count; i++) {
      ((Selector *) self->selectors->elements[i])->style = self;
    }
 
    self->attributes = (Dictionary *) $$(Dictionary, dictionaryWithCapacity, 4);
    assert(self->attributes);
  }
 
  return self;
}

isComputedEqual()

static bool isComputedEqual ( const Style *  self, const Style *  other  )

static

Definition at line 433 of file Style.c.

                                                                   {
 
  assert(other);
 
  if (self->selectors->count == other->selectors->count) {
 
    for (size_t i = 0; i < self->selectors->count; i++) {
 
      const Selector *this = $(self->selectors, objectAtIndex, i);
      const Selector *that = $(other->selectors, objectAtIndex, i);
 
      if (strcmp(this->rule, that->rule)) {
        return false;
      }
    }
 
    return true;
  }
 
  return false;
}

isEqual()

static bool isEqual ( const Object *  self, const Object *  other  )

static

See also

Object::isEqual(const Object *, const Object *)

Definition at line 77 of file Style.c.

                                                             {
 
  if (super(Object, self, isEqual, other)) {
    return true;
  }
 
  if (other && $(other, isKindOfClass, _Style())) {
 
    const Style *this = (Style *) self;
    const Style *that = (Style *) other;
 
    if ($((Object *) this->selectors, isEqual, (Object *) that->selectors)) {
      return $((Object *) this->attributes, isEqual, (Object *) that->attributes);
    }
  }
 
  return false;
}

parse()

static Array * parse ( const char *  css )

static

Definition at line 556 of file Style.c.

                                     {
 
  Array *styles = $$(Array, array);
  assert(styles);
 
  if (css) {
 
    char *stripped = stripComments(css);
 
    StringReader *reader = $(alloc(StringReader), initWithCharacters, stripped);
    assert(reader);
 
    Style *style = NULL;
    char *attr = NULL;
 
    while (true) {
 
      const Unicode *charset = style ? L"{:;}" : L"{}";
      Unicode stop;
 
      String *token = $(reader, readToken, charset, &stop);
      if (token) {
        switch (stop) {
          case '{':
            style = $(alloc(Style), initWithRules, token->chars);
            assert(style);
            break;
          case ':':
            if (style) {
              attr = strtrim(token->chars);
              assert(attr);
            }
            break;
          case ';':
            if (style && attr) {
 
              ident value = parseValue(token);
              $(style, addAttribute, attr, value);
 
              free(attr);
              attr = NULL;
 
              release(value);
            }
            break;
          case '}':
            if (style) {
              $(styles, addObject, style);
              style = release(style);
            }
            break;
        }
 
        release(token);
      } else {
        break;
      }
    }
 
    release(reader);
    free(stripped);
  }
 
  return (Array *) styles;
}

parseValue()

static ident parseValue ( String *  string )

static

Returns

The value Object parsed from the given String.

Definition at line 458 of file Style.c.

                                        {
 
  ident value = NULL;
 
  assert(string);
 
  String *trimmed = $(string, trimmedString);
  assert(trimmed);
 
  StringReader *reader = $(alloc(StringReader), initWithString, trimmed);
  assert(reader);
 
  const Unicode *charset = L", \n\t";
  Unicode stop;
 
  String *token = $(reader, readToken, charset, &stop);
  if (token) {
 
    NumberFormatter *formatter = $(alloc(NumberFormatter), initWithFormat, NULL);
    assert(formatter);
 
    Number *number = $(formatter, numberFromString, token);
 
    if (stop == READER_EOF) {
 
      if (number) {
        value = retain(number);
      } else if (strcmp("true", token->chars) == 0) {
        value = retain($$(Boole, True));
      } else if (strcmp("false", token->chars) == 0) {
        value = retain($$(Boole, False));
      } else {
        value = $((Object *) token, copy);
      }
 
    } else if (number) {
      value = $$(Array, arrayWithCapacity, 4);
 
      while (token) {
 
        Object *obj = parseValue(token);
        $((Array *) value, addObject, obj);
        release(obj);
        release(token);
 
        token = $(reader, readToken, charset, NULL);
      }
    } else {
      value = retain(trimmed);
    }
 
    release(number);
    release(formatter);
    release(token);
  }
 
  release(reader);
  release(trimmed);
 
  return value;
}

removeAllAttributes()

static void removeAllAttributes ( Style *  self )

static

Definition at line 634 of file Style.c.

                                             {
  $((Dictionary *) self->attributes, removeAllObjects);
}

removeAttribute()

static void removeAttribute ( Style *  self, const char *  attr  )

static

Definition at line 626 of file Style.c.

                                                           {
  $((Dictionary *) self->attributes, removeObjectForKeyPath, attr);
}

setAttribute()

static void setAttribute ( Style *  self, const char *  key, ident  value  )

static

Stores value under key, expanding it into longhands if key is a shorthand.

Definition at line 184 of file Style.c.

                                                                    {
 
  const StyleShorthand *shorthand = styleShorthandForKey(key);
  if (shorthand == NULL || !addShorthandAttribute(self, shorthand, value)) {
    $((Dictionary *) self->attributes, setObjectForKeyPath, value, key);
  }
}

stripComments()

static char * stripComments ( const char *  css )

static

Returns a newly allocated copy of css with all / * ... * / comments removed. The tokenizer below splits on { : ; } and has no notion of comments, so a comment absorbed into a selector or declaration silently corrupts the rule. Each comment is replaced by a single space so it still separates adjacent tokens. The caller must free the returned buffer.

Definition at line 527 of file Style.c.

                                            {
 
  const size_t len = strlen(css);
 
  char *out = calloc(1, len + 1);
  assert(out);
 
  size_t w = 0;
  for (size_t r = 0; r < len; ) {
    if (css[r] == '/' && css[r + 1] == '*') {
      r += 2;
      while (r < len && !(css[r] == '*' && css[r + 1] == '/')) {
        r++;
      }
      r = (r < len) ? r + 2 : len;
      out[w++] = ' ';
    } else {
      out[w++] = css[r++];
    }
  }
 
  out[w] = '\0';
  return out;
}

styleShorthandCount()

static size_t styleShorthandCount ( const StyleShorthand *  shorthand )

static

Returns

The number of longhands shorthand stands for.

Definition at line 125 of file Style.c.

                                                                   {
 
  size_t count = 0;
  while (count < lengthof(shorthand->longhands) && shorthand->longhands[count]) {
    count++;
  }
 
  return count;
}

styleShorthandForKey()

static const StyleShorthand * styleShorthandForKey ( const char *  key )

static

Returns

The StyleShorthand key names, or NULL if it is already a longhand.

Definition at line 138 of file Style.c.

                                                                   {
 
  for (size_t i = 0; i < lengthof(styleShorthands); i++) {
    if (strcmp(styleShorthands[i].shorthand, key) == 0) {
      return &styleShorthands[i];
    }
  }
 
  return NULL;
}

Variable Documentation

styleShorthands

const StyleShorthand styleShorthands[]

static

Initial value:

= {
  { "corner-cut", { "corner-cut-top-left", "corner-cut-top-right",
                    "corner-cut-bottom-right", "corner-cut-bottom-left" } },
  { "max-size", { "max-width", "max-height" } },
  { "min-size", { "min-width", "min-height" } },
  { "padding", { "padding-top", "padding-right", "padding-bottom", "padding-left" } },
}

Remarks

The longhands are in the order the shorthand's values are written, which is the order of the struct each one binds: padding is top right bottom left, frame is x y w h.

Definition at line 114 of file Style.c.

                                                {
  { "corner-cut", { "corner-cut-top-left", "corner-cut-top-right",
                    "corner-cut-bottom-right", "corner-cut-bottom-left" } },
  { "max-size", { "max-width", "max-height" } },
  { "min-size", { "min-width", "min-height" } },
  { "padding", { "padding-top", "padding-right", "padding-bottom", "padding-left" } },
};