Style.c

Go to the documentation of this file.

/*
 * ObjectivelyMVC: Object oriented MVC framework for SDL3 and C.
 * Copyright (C) 2014 Jay Dolan <jay@jaydolan.com>
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#include <assert.h>
#include <stdlib.h>
#include <string.h>
 
#include <Objectively.h>
 
#include "Style.h"
 
#define _Class _Style
 
#pragma mark - Object
 
static void dealloc(Object *self) {
 
  Style *this = (Style *) self;
 
  release(this->attributes);
  release(this->selectors);
 
  super(Object, self, dealloc);
}
 
static String *description(const Object *self) {
 
  const Style *this = (Style *) self;
 
  return $((Array *) this->selectors, componentsJoinedByCharacters, ", ");
}
 
static int hash(const Object *self) {
 
  Style *this = (Style *) self;
 
  int hash = HASH_SEED;
 
  hash = HashForObject(hash, this->attributes);
  hash = HashForObject(hash, this->selectors);
 
  return hash;
}
 
static bool isEqual(const Object *self, const Object *other) {
 
  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;
}
 
#pragma mark - Style
 
typedef struct {
  const char *shorthand;
  const char *longhands[4];
} StyleShorthand;
 
static const StyleShorthand styleShorthands[] = {
  { "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" } },
};
 
static size_t styleShorthandCount(const StyleShorthand *shorthand) {
 
  size_t count = 0;
  while (count < lengthof(shorthand->longhands) && shorthand->longhands[count]) {
    count++;
  }
 
  return count;
}
 
static const StyleShorthand *styleShorthandForKey(const char *key) {
 
  for (size_t i = 0; i < lengthof(styleShorthands); i++) {
    if (strcmp(styleShorthands[i].shorthand, key) == 0) {
      return &styleShorthands[i];
    }
  }
 
  return NULL;
}
 
static bool addShorthandAttribute(Style *self, const StyleShorthand *shorthand, ident value) {
 
  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;
}
 
static void setAttribute(Style *self, const char *key, ident value) {
 
  const StyleShorthand *shorthand = styleShorthandForKey(key);
  if (shorthand == NULL || !addShorthandAttribute(self, shorthand, value)) {
    $((Dictionary *) self->attributes, setObjectForKeyPath, value, key);
  }
}
 
static void addAttribute(Style *self, const char *attr, ident value) {
 
  assert(attr);
  assert(value);
 
  char *key = strtrim(attr);
  assert(key);
 
  setAttribute(self, key, value);
 
  free(key);
}
 
static void addAttributes_enumerate(const Dictionary *dictionary, ident obj, ident key, ident data) {
 
  setAttribute((Style *) data, ((String *) key)->chars, obj);
}
 
static void addAttributes(Style *self, const Dictionary *attributes) {
 
  assert(attributes);
 
  $(attributes, enumerateObjectsAndKeys, addAttributes_enumerate, self);
}
 
static void addBoolAttribute(Style *self, const char *attr, bool value) {
  $(self, addAttribute, attr, $$(Boole, valueof, value));
}
 
static void addCharactersAttribute(Style *self, const char *attr, const char *value) {
 
  String *string = $$(String, stringWithCharacters, value);
 
  $(self, addAttribute, attr, string);
 
  release(string);
}
 
static void addColorAttribute(Style *self, const char *attr, const SDL_Color *color) {
 
  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);
}
 
static void addDoubleAttribute(Style *self, const char *attr, double value) {
 
  Number *number = $$(Number, numberWithValue, value);
 
  $(self, addAttribute, attr, number);
 
  release(number);
}
 
static void addEnumAttribute(Style *self, const char *attr, const EnumName *names, int value) {
 
  String *string = nameof(names, value);
 
  $(self, addAttribute, attr, string);
 
  release(string);
}
 
static void addFloatAttribute(Style *self, const char *attr, float value) {
  $(self, addDoubleAttribute, attr, value);
}
 
static void addIntegerAttribute(Style *self, const char *attr, int value) {
  $(self, addDoubleAttribute, attr, value);
}
 
static void addPointAttribute(Style *self, const char *attr, const SDL_Point *value) {
 
  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);
}
 
static void addRectangleAttribute(Style *self, const char *attr, const SDL_Rect *value) {
 
  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);
}
 
static void addSelector(Style *self, Selector *selector) {
 
  assert(selector);
 
  $((Array *) self->selectors, addObject, selector);
}
 
static void addSizeAttribute(Style *self, const char *attr, const SDL_Size *value) {
 
  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);
}
 
static ident attributeValue(const Style *self, const char *attr) {
  return $((Dictionary *) self->attributes, objectForKeyPath, attr);
}
 
static Style *initWithAttributes(Style *self, const Dictionary *attributes) {
 
  self = $(self, initWithRules, NULL);
  if (self) {
    if (attributes) {
      $(self, addAttributes, attributes);
    }
  }
 
  return self;
}
 
static Style *initWithRules(Style *self, const char *rules) {
 
  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;
}
 
static bool isComputedEqual(const Style *self, const Style *other) {
 
  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;
}
 
static ident parseValue(String *string) {
 
  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;
}
 
static char *stripComments(const char *css) {
 
  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;
}
 
static Array *parse(const char *css) {
 
  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;
}
 
static void removeAttribute(Style *self, const char *attr) {
  $((Dictionary *) self->attributes, removeObjectForKeyPath, attr);
}
 
static void removeAllAttributes(Style *self) {
  $((Dictionary *) self->attributes, removeAllObjects);
}
 
#pragma mark - Class lifecycle
 
static void initialize(Class *clazz) {
 
  ((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;
}
 
Class *_Style(void) {
  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;
}
 
#undef _Class