View+JSON.c

Go to the documentation of this file.

/*
 * Objectively: Ultra-lightweight object oriented framework for GNU C.
 * Copyright (C) 2014 Jay Dolan <jay@jaydolan.com>
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#include <assert.h>
#include <stdlib.h>
#include <string.h>
 
#include <Objectively.h>
 
#include <ObjectivelyMVC.h>
 
#define _Class _View
 
static void bindBool(const Inlet *inlet, ident obj) {
  *((bool *) inlet->dest) = cast(Boole, obj)->value;
}
 
static void bindCharacters(const Inlet *inlet, ident obj) {
 
  char **dest = inlet->dest;
 
  if (*dest) {
    free(*dest);
  }
 
  *dest = strdup(cast(String, obj)->chars);
}
 
static void bindClassNames_enumerate(const Array *array, ident obj, ident data) {
  $((View *) data, addClassName, cast(String, obj)->chars);
}
 
static void bindClassNames(const Inlet *inlet, ident obj) {
  $(cast(Array, obj), enumerate, bindClassNames_enumerate, *(View **) inlet->dest);
}
 
static void bindColor(const Inlet *inlet, ident obj) {
 
  SDL_Color color = Colors.Black;
 
  if ($((Object *) obj, isKindOfClass, _String())) {
 
    String *string = cast(String, obj);
    if (string->length) {
 
      if (strcmp("none", string->chars) == 0) {
        return;
      }
 
      if (string->chars[0] == '#') {
        color = MVC_HexToRGBA(string->chars + 1);
      } else {
        color = MVC_ColorForName(string->chars);
      }
    }
 
  } else {
    const Array *array = cast(Array, obj);
 
    assert(array->count == 4);
 
    const Number *r = $(array, objectAtIndex, 0);
    const Number *g = $(array, objectAtIndex, 1);
    const Number *b = $(array, objectAtIndex, 2);
    const Number *a = $(array, objectAtIndex, 3);
 
    #define ScaleColor(c) (c > 0.0 && c < 1.0 ? c * 255 : c)
 
    color = MakeColor(
      ScaleColor(r->value),
      ScaleColor(g->value),
      ScaleColor(b->value),
      ScaleColor(a->value)
    );
  }
 
  *((SDL_Color *) inlet->dest) = color;
}
 
static void bindDouble(const Inlet *inlet, ident obj) {
  *((double *) inlet->dest) = cast(Number, obj)->value;
}
 
static void bindEnum(const Inlet *inlet, ident obj) {
  *((int *) inlet->dest) = valueof(inlet->data, cast(String, obj)->chars);
}
 
static void bindFloat(const Inlet *inlet, ident obj) {
  *((float *) inlet->dest) = cast(Number, obj)->value;
}
 
static void bindInteger(const Inlet *inlet, ident obj) {
  *((int *) inlet->dest) = cast(Number, obj)->value;
}
 
static void bindPoint(const Inlet *inlet, ident obj) {
 
  const Array *array = cast(Array, obj);
 
  assert(array->count == 2);
 
  const Number *x = $(array, objectAtIndex, 0);
  const Number *y = $(array, objectAtIndex, 1);
 
  *((SDL_Point *) inlet->dest) = MakePoint(x->value, y->value);
}
 
static void bindRectangle(const Inlet *inlet, ident obj) {
 
  if ($((Object *) obj, isKindOfClass, _Number())) {
    const Number *n = obj;
 
    *((SDL_Rect *) inlet->dest) = MakeRect(n->value, n->value, n->value, n->value);
  } else {
    const Array *array = cast(Array, obj);
 
    assert(array->count == 4);
 
    const Number *x = $(array, objectAtIndex, 0);
    const Number *y = $(array, objectAtIndex, 1);
    const Number *w = $(array, objectAtIndex, 2);
    const Number *h = $(array, objectAtIndex, 3);
 
    *((SDL_Rect *) inlet->dest) = MakeRect(x->value, y->value, w->value, h->value);
  }
}
 
static void bindSize(const Inlet *inlet, ident obj) {
 
  const Array *array = cast(Array, obj);
 
  assert(array->count == 2);
 
  const Number *w = $(array, objectAtIndex, 0);
  const Number *h = $(array, objectAtIndex, 1);
 
  *((SDL_Size *) inlet->dest) = MakeSize(w->value, h->value);
}
 
static void bindView(const Inlet *inlet, ident obj) {
 
  View *dest = *(View **) inlet->dest;
 
  const Dictionary *dictionary = cast(Dictionary, obj);
 
  const String *className = $(dictionary, objectForKeyPath, "class");
  if (className || dest == NULL) {
 
    Class *clazz = className ? classForName(className->chars) : _View();
    assert(clazz);
 
    const Class *c = clazz;
    while (c) {
      if (c == _View()) {
        break;
      }
      c = c->def.superclass;
    }
    assert(c);
 
    if (clazz != _View()) {
      if (interfaceof(View, clazz)->init == interfaceof(View, clazz->def.superclass)->init) {
        MVC_LogWarn("%s does not implement View::init\n", clazz->def.name);
      }
    }
 
    View *view = $((View *) _alloc(clazz), init);
    assert(view);
 
    $(view, awakeWithDictionary, dictionary);
 
    if (dest) {
      if (dest->superview) {
        $(dest->superview, replaceSubview, dest, view);
      }
      release(dest);
    }
 
    *(View **) inlet->dest = view;
 
  } else if (dest) {
    $(dest, awakeWithDictionary, dictionary);
  } else {
    MVC_LogWarn("Inlet %s has NULL destination and no className specified\n", inlet->name);
  }
}
 
static void bindStyle(const Inlet *inlet, ident obj) {
  $(cast(View, *((View **) inlet->dest))->style, addAttributes, cast(Dictionary, obj));
}
 
static void bindSubviews_enumerate(const Array *array, ident obj, ident data) {
 
  View *subview = NULL;
 
  const Inlet inlet = MakeInlet(NULL, InletTypeView, &subview, NULL);
 
  bindView(&inlet, obj);
 
  $(cast(View, data), addSubview, subview);
 
  release(subview);
}
 
static void bindSubviews(const Inlet *inlet, ident obj) {
  $(cast(Array, obj), enumerate, bindSubviews_enumerate, *(View **) inlet->dest);
}
 
static void bindApplicationDefined(const Inlet *inlet, ident obj) {
 
  assert(inlet->data);
 
  ((InletBinding) inlet->data)(inlet, obj);
}
 
const InletBinding inletBindings[] = {
  bindBool,
  bindCharacters,
  bindClassNames,
  bindColor,
  bindDouble,
  bindEnum,
  bindFloat,
  bindInteger,
  bindPoint,
  bindRectangle,
  bindSize,
  bindStyle,
  bindSubviews,
  bindView,
  bindApplicationDefined,
};
 
bool bindInlets(const Inlet *inlets, const Dictionary *dictionary) {
 
  assert(inlets);
  assert(dictionary);
 
  bool didBindInlets = false;
 
  for (const Inlet *inlet = inlets; inlet->name; inlet++) {
    const ident obj = $(dictionary, objectForKeyPath, inlet->name);
    if (obj) {
      BindInlet(inlet, obj);
      didBindInlets = true;
    }
  }
 
  return didBindInlets;
}
 
#undef _Class