simpler-tiles 0.0.1

data/ext/simpler_tiles/layer.c

@@ -0,0 +1,93 @@
+#include "layer.h"
+#include <simple-tiles/layer.h>
+#include <simple-tiles/query.h>
+#include <simple-tiles/list.h>
+
+VALUE cSimplerTilesLayer;
+
+static simplet_layer_t *
+get_layer(VALUE self){
+  simplet_layer_t *layer;
+  Data_Get_Struct(self, simplet_layer_t, layer);
+  return layer;
+}
+
+static void
+mark_layer(void *layer){
+  simplet_layer_t *lyr = layer;
+  VALUE ref = (VALUE)simplet_layer_get_user_data(lyr);
+  if(ref) rb_gc_mark(ref);
+}
+
+static void
+layer_free(void *layer){
+  simplet_layer_t *lyr = layer;
+  // test if we have been linked in ruby land
+  VALUE refs = (VALUE)simplet_layer_get_user_data(lyr);
+  // if not it is safe to free this layer.
+  if(!refs) simplet_layer_free(lyr);
+}
+
+
+/*
+Set the source attribute for the Layer.
+
+@return (String)
+@param (String)
+*/
+static VALUE
+set_source(VALUE self, VALUE source){
+  Check_Type(source, T_STRING);
+  simplet_layer_t *layer = get_layer(self);
+  simplet_layer_set_source(layer, RSTRING_PTR(source));
+  return source;
+}
+
+/*
+Get a copy of the Layer's source.
+
+@return (String)
+*/
+static VALUE
+get_source(VALUE self) {
+  simplet_layer_t *layer = get_layer(self);
+  char *source;
+  simplet_layer_get_source(layer, &source);
+  return rb_str_new2(source);
+}
+
+/*
+Add a query object to this Layer's list of queries.
+
+@param (String)
+@return (Query)
+*/
+static VALUE
+add_query(VALUE self, VALUE query){
+  simplet_layer_t *layer = get_layer(self);
+  simplet_query_t *qry;
+  Data_Get_Struct(query, simplet_query_t, qry);
+  simplet_layer_add_query_directly(layer, qry);
+  VALUE circ_ref = rb_ary_new3(2, self, query);
+  simplet_query_set_user_data(qry, (void *)circ_ref);
+  return query;
+}
+
+VALUE
+layer_alloc(VALUE klass){
+  simplet_layer_t *layer;
+  if(!(layer = simplet_layer_new("")))
+    rb_fatal("Could not allocate space for a new SimplerTiles::Layer in memory.");
+
+  return Data_Wrap_Struct(klass, mark_layer, layer_free, layer);
+}
+
+void init_layer(){
+  VALUE rlayer = rb_define_class_under(mSimplerTiles, "Layer", rb_cObject);
+  rb_define_alloc_func(rlayer, layer_alloc);
+  rb_define_method(rlayer, "source=", set_source, 1);
+  rb_define_method(rlayer, "source", get_source, 0);
+  rb_define_private_method(rlayer, "add_query", add_query, 1);
+
+  cSimplerTilesLayer = rlayer;
+}

data/ext/simpler_tiles/layer.h

@@ -0,0 +1,16 @@
+#ifndef _SIMPLER_LAYER_H
+#define _SIMPLER_LAYER_H
+
+#include "simpler_tiles.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void init_layer();
+extern VALUE cSimplerTilesLayer;
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/simpler_tiles/map.c

@@ -0,0 +1,338 @@
+#include "map.h"
+#include "util.h"
+#include <simple-tiles/map.h>
+#include <simple-tiles/layer.h>
+#include <simple-tiles/bounds.h>
+#include <simple-tiles/list.h>
+
+VALUE cSimplerTilesMap;
+
+static simplet_map_t *
+get_map(VALUE self){
+  simplet_map_t *map;
+  Data_Get_Struct(self, simplet_map_t, map);
+  return map;
+}
+
+/*
+Set the background color of the map.
+
+@param (String)
+@return (nil)
+*/
+static VALUE
+set_bgcolor(VALUE self, VALUE bgcolor){
+  Check_Type(bgcolor, T_STRING);
+  simplet_map_t *map = get_map(self);
+  simplet_map_set_bgcolor(map, RSTRING_PTR(bgcolor));
+  return Qnil;
+}
+
+/*
+Return a copy of the background color of the map.
+
+@return (String)
+*/
+static VALUE
+get_bgcolor(VALUE self){
+  simplet_map_t *map = get_map(self);
+  char *color;
+  simplet_map_get_bgcolor(map, &color);
+  return rb_str_new2(color);
+}
+
+/*
+Set the projection from an Proj.4 readable string.
+
+@param (String)
+@return (String)
+*/
+static VALUE
+set_srs(VALUE self, VALUE srs){
+  Check_Type(srs, T_STRING);
+  simplet_map_t *map = get_map(self);
+  simplet_map_set_srs(map, RSTRING_PTR(srs));
+  return Qnil;
+}
+
+/*
+Return the projection for the map in string representation.
+
+@return (String)
+*/
+static VALUE
+get_srs(VALUE self){
+  simplet_map_t *map = get_map(self);
+  char *srs;
+  simplet_map_get_srs(map, &srs);
+  return rb_str_new2(srs);
+}
+
+/*
+Set the bounds on the map.
+
+@param (Number, Number, Number, Number)
+@return (nil)
+*/
+static VALUE
+set_bounds(VALUE self, VALUE maxx, VALUE maxy, VALUE minx, VALUE miny){
+  simplet_map_t *map = get_map(self);
+  simplet_map_set_bounds(map, NUM2DBL(maxx), NUM2DBL(maxy), NUM2DBL(minx), NUM2DBL(miny));
+  return Qnil;
+}
+
+static VALUE
+new_bounds(simplet_bounds_t *bounds){
+  VALUE args[4];
+  args[0] = rb_float_new(bounds->nw.x);
+  args[1] = rb_float_new(bounds->nw.y);
+  args[2] = rb_float_new(bounds->se.x);
+  args[3] = rb_float_new(bounds->se.y);
+  return rb_funcall2(cSimplerTilesBounds, rb_intern("new"), 4, args);
+}
+
+/*
+Return the bounds of this map.
+
+@return (Bounds)
+*/
+static VALUE
+bounds(VALUE self){
+  simplet_map_t *map = get_map(self);
+  return new_bounds(map->bounds);
+}
+/*
+Return the bounds of this map sized according to it's buffer attribute.
+
+@return (Bounds)
+*/
+static VALUE
+buffered_bounds(VALUE self){
+  simplet_map_t *map = get_map(self);
+  cairo_matrix_t mat;
+  simplet_map_init_matrix(map, &mat);
+  cairo_matrix_invert(&mat);
+
+  double dx, dy;
+  dx = dy = simplet_map_get_buffer(map);
+  cairo_matrix_transform_distance(&mat, &dx, &dy);
+
+  simplet_bounds_t *bbounds = simplet_bounds_buffer(map->bounds, dx);
+  if(!bbounds)
+    rb_raise(rb_eRuntimeError, "Could not allocate space for a new SimplerTiles::Bounds in memory.");
+
+  return new_bounds(bbounds);
+}
+
+/*
+Set the size in pixels of the final map.
+
+@param (Number, Number)
+@return (nil)
+*/
+static VALUE
+set_size(VALUE self, VALUE width, VALUE height){
+  simplet_map_t *map = get_map(self);
+  simplet_map_set_size(map, NUM2INT(width), NUM2INT(height));
+  return Qnil;
+}
+
+/*
+Set the buffer on the Map.
+
+@param (Number)
+@return (Number)
+*/
+static VALUE
+set_buffer(VALUE self, VALUE buffer){
+  simplet_map_t *map = get_map(self);
+  simplet_map_set_buffer(map, NUM2DBL(buffer));
+  return rb_float_new(map->buffer);
+}
+
+/*
+Get the Map's buffer.
+
+@return (Number)
+*/
+static VALUE
+get_buffer(VALUE self){
+  simplet_map_t *map = get_map(self);
+  return rb_float_new(simplet_map_get_buffer(map));
+}
+
+
+/*
+Get the width of the map.
+
+@return (Number)
+*/
+static VALUE
+get_width(VALUE self){
+  simplet_map_t *map = get_map(self);
+  return INT2NUM(simplet_map_get_width(map));
+}
+
+/*
+Get the height of the map.
+
+@return (Number)
+*/
+static VALUE
+get_height(VALUE self){
+  simplet_map_t *map = get_map(self);
+  return INT2NUM(simplet_map_get_height(map));
+}
+
+/*
+Set the width of the Map.
+
+@return (Number)
+*/
+static VALUE
+set_width(VALUE self, VALUE width){
+  simplet_map_t *map = get_map(self);
+  simplet_map_set_width(map, NUM2INT(width));
+  return get_width(self);
+}
+
+/*
+Set the height of the Map.
+
+@return (Number)
+*/
+static VALUE
+set_height(VALUE self, VALUE height){
+  simplet_map_t *map = get_map(self);
+  simplet_map_set_height(map, NUM2INT(height));
+  return get_height(self);
+}
+
+
+
+/*
+Create and return a {Layer} based on the passed in string.
+
+@param (String)
+@return (Layer)
+*/
+static VALUE
+add_layer(VALUE self, VALUE layer){
+  simplet_map_t *map = get_map(self);
+  simplet_layer_t *lyr;
+  Data_Get_Struct(layer, simplet_layer_t, lyr);
+  simplet_map_add_layer_directly(map, lyr);
+  VALUE circ_ref = rb_ary_new3(2, self, layer);
+  simplet_layer_set_user_data(lyr, (void *)circ_ref);
+  return layer;
+}
+
+/*
+Test to see if the Map has fulfilled the requirements for rendering
+
+@return (Boolean)
+*/
+static VALUE
+is_valid(VALUE self){
+  simplet_map_t *map = get_map(self);
+  if(!simplet_map_is_valid(map))
+    return Qfalse;
+  return Qtrue;
+}
+
+/*
+Render the Map to the filesystem.
+
+@param (String)
+@return (Boolean)
+*/
+static VALUE
+save(VALUE self, VALUE path){
+  Check_Type(path, T_STRING);
+  if(!is_valid(self)) return Qfalse;
+  simplet_map_t *map = get_map(self);
+  simplet_map_render_to_png(map, RSTRING_PTR(path));
+  if(simplet_map_get_status(map) == SIMPLET_OK) {
+    return Qtrue;
+  } else {
+    rb_raise(rb_eRuntimeError, simplet_map_status_to_string(map));
+    return Qfalse;
+  }
+}
+
+
+static cairo_status_t
+stream(void* block, const unsigned char *data, unsigned int length){
+  ID call = rb_intern("call");
+  VALUE rdata = rb_str_new((const char *)data, (long)length);
+  rb_funcall((VALUE)block, call, 1, rdata);
+  return CAIRO_STATUS_SUCCESS;
+}
+
+/*
+Render the map to a png stream and yield values to the passed in block.
+
+@yield [chunk] Block that takes chunks of data
+@return (nil)
+*/
+static VALUE
+to_png_stream(VALUE self, VALUE block){
+  simplet_map_t *map = get_map(self);
+
+  simplet_map_render_to_stream(map, (void *)block, stream);
+  if(simplet_map_get_status(map) != SIMPLET_OK)
+    rb_raise(rb_eRuntimeError, simplet_map_status_to_string(map));
+
+  return Qnil;
+}
+
+/*
+Set the map to be slippy via passed in parameters.
+
+@param (Number, Number, Number)
+@return (nil)
+*/
+static VALUE
+slippy(VALUE self, VALUE x, VALUE y, VALUE z){
+  simplet_map_t *map = get_map(self);
+  if(simplet_map_set_slippy(map, NUM2INT(x), NUM2INT(y), NUM2INT(z)) != SIMPLET_OK)
+    rb_raise(rb_eRuntimeError, simplet_map_status_to_string(map));
+  return Qnil;
+}
+
+static VALUE
+map_alloc(VALUE klass){
+  simplet_map_t *map;
+
+  if(!(map = simplet_map_new()))
+    rb_fatal("Could not allocate space for a new SimplerTiles::Map in memory.");
+
+  return Data_Wrap_Struct(klass, NULL, simplet_map_free, map);
+}
+
+void
+init_map(){
+  VALUE rmap = rb_define_class_under(mSimplerTiles, "Map", rb_cObject);
+  rb_define_alloc_func(rmap, map_alloc);
+  rb_define_method(rmap, "bgcolor=", set_bgcolor, 1);
+  rb_define_method(rmap, "bgcolor", get_bgcolor, 0);
+  rb_define_method(rmap, "srs=", set_srs, 1);
+  rb_define_method(rmap, "srs", get_srs, 0);
+  rb_define_method(rmap, "set_size", set_size, 2);
+  rb_define_method(rmap, "width", get_width, 0);
+  rb_define_method(rmap, "height", get_height, 0);
+  rb_define_method(rmap, "width=", set_width, 1);
+  rb_define_method(rmap, "height=", set_height, 1);
+  rb_define_method(rmap, "buffer", get_buffer, 0);
+  rb_define_method(rmap, "buffer=", set_buffer, 1);
+  rb_define_method(rmap, "set_bounds", set_bounds, 4);
+  rb_define_method(rmap, "bounds", bounds, 0);
+  rb_define_method(rmap, "buffered_bounds", buffered_bounds, 0);
+  rb_define_method(rmap, "save", save, 1);
+  rb_define_method(rmap, "slippy", slippy, 3);
+  rb_define_method(rmap, "valid?", is_valid, 0);
+  rb_define_private_method(rmap, "to_png_stream", to_png_stream, 1);
+  rb_define_private_method(rmap, "add_layer", add_layer, 1);
+
+  cSimplerTilesMap = rmap;
+}

data/ext/simpler_tiles/map.h

@@ -0,0 +1,17 @@
+#ifndef _SIMPLER_MAP_H
+#define _SIMPLER_MAP_H
+
+#include "simpler_tiles.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void init_map();
+extern VALUE cSimplerTilesMap;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/simpler_tiles/query.c

@@ -0,0 +1,87 @@
+#include "query.h"
+#include <simple-tiles/query.h>
+#include <simple-tiles/style.h>
+
+VALUE cSimplerTilesQuery;
+
+static simplet_query_t *
+get_query(VALUE self){
+  simplet_query_t *query;
+  Data_Get_Struct(self, simplet_query_t, query);
+  return query;
+}
+
+static void
+mark_query(void *query){
+  simplet_query_t *fltr = query;
+  VALUE ref = (VALUE)simplet_query_get_user_data(fltr);
+  if(ref) rb_gc_mark(ref);
+}
+
+
+static void
+query_free(void *query){
+  simplet_query_t *fltr = query;
+  // test if we have been linked in ruby land
+  VALUE refs = (VALUE)simplet_query_get_user_data(fltr);
+  // if not it is safe to free this query.
+  if(!refs) simplet_query_free(fltr);
+}
+
+/*
+Set the OGR SQL for this Query.
+
+@return (String)
+*/
+static VALUE
+set_sql(VALUE self, VALUE query){
+  Check_Type(query, T_STRING);
+  simplet_query_t *qry = get_query(self);
+  simplet_query_set(qry, RSTRING_PTR(query));
+  return query;
+}
+
+/*
+Get the OGR SQL for this Query.
+
+@return (String)
+*/
+static VALUE
+get_sql(VALUE self){
+  simplet_query_t *query = get_query(self);
+  char *str;
+  simplet_query_get(query, &str);
+  return rb_str_new2(str);
+}
+
+static VALUE
+add_style(VALUE self, VALUE style){
+  simplet_query_t *query = get_query(self);
+  simplet_style_t *style_s;
+  Data_Get_Struct(style, simplet_style_t, style_s);
+  simplet_query_add_style_directly(query, style_s);
+  VALUE circ_ref = rb_ary_new3(2, self, style);
+  simplet_style_set_user_data(style_s, (void *)circ_ref);
+  return style;
+}
+
+static VALUE
+query_alloc(VALUE klass){
+  simplet_query_t *query;
+
+  if(!(query = simplet_query_new(NULL)))
+    rb_fatal("Could not allocate space for a new SimplerTiles::Query in memory.");
+
+  return Data_Wrap_Struct(klass, mark_query, query_free, query);
+};
+
+
+void init_query(){
+  VALUE rquery = rb_define_class_under(mSimplerTiles, "Query", rb_cObject);
+  rb_define_alloc_func(rquery, query_alloc);
+  rb_define_method(rquery, "query=", set_sql, 1);
+  rb_define_method(rquery, "query", get_sql, 0);
+  rb_define_private_method(rquery, "add_style", add_style, 1);
+
+  cSimplerTilesQuery = rquery;
+}

data/ext/simpler_tiles/query.h

@@ -0,0 +1,17 @@
+#ifndef _SIMPLER_QUERY_H
+#define _SIMPLER_QUERY_H
+
+#include "simpler_tiles.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void init_query();
+extern VALUE cSimplerTilesQuery;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/simpler_tiles/simpler_tiles.c

@@ -0,0 +1,16 @@
+#include "simpler_tiles.h"
+
+VALUE mSimplerTiles;
+
+void
+Init_simpler_tiles(){
+  mSimplerTiles = rb_define_module("SimplerTiles");
+  rb_const_set(mSimplerTiles,
+              rb_intern("SIMPLE_TILES_VERSION"),
+              rb_str_new2(SIMPLE_TILES_VERSION));
+  init_map();
+  init_bounds();
+  init_layer();
+  init_query();
+  init_style();
+}

data/ext/simpler_tiles/simpler_tiles.h

@@ -0,0 +1,25 @@
+#ifndef _SIMPLER_TILES_H
+#define _SIMPLER_TILES_H
+
+#include <simple-tiles/simple_tiles.h>
+#include <ruby.h>
+
+#include "map.h"
+#include "bounds.h"
+#include "layer.h"
+#include "query.h"
+#include "style.h"
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern VALUE mSimplerTiles;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/simpler_tiles/style.c

@@ -0,0 +1,106 @@
+#include "style.h"
+#include "util.h"
+#include <simple-tiles/style.h>
+
+VALUE cSimplerTilesStyle;
+
+static simplet_style_t *
+get_style(VALUE self){
+  simplet_style_t *style;
+  Data_Get_Struct(self, simplet_style_t, style);
+  return style;
+}
+
+static void
+mark_style(void *style){
+  simplet_style_t *stl = style;
+  VALUE refs = (VALUE)simplet_style_get_user_data(stl);
+  if(refs) rb_gc_mark(refs);
+}
+
+static void
+style_free(void *style){
+  simplet_style_t *stl = style;
+  // test if we have been linked in ruby land
+  VALUE refs = (VALUE)simplet_style_get_user_data(stl);
+  // if not it is safe to free this style.
+  if(!refs) simplet_style_free(stl);
+}
+
+static VALUE
+alloc_style(VALUE klass){
+  simplet_style_t *style;
+
+  if(!(style = simplet_style_new(NULL, NULL)))
+    rb_fatal("Could not allocate space for a new SimplerTiles::Style in memory.");
+
+  return Data_Wrap_Struct(klass, mark_style, style_free, style);
+}
+
+/*
+Set the arg for this Style.
+
+@param (String)
+@return (String)
+*/
+static VALUE
+set_arg(VALUE self, VALUE arg){
+  Check_Type(arg, T_STRING);
+  simplet_style_t *style = get_style(self);
+  simplet_style_set_arg(style, RSTRING_PTR(arg));
+  return arg;
+}
+
+
+/*
+Get the arg for this Style.
+
+@return (String)
+*/
+static VALUE
+get_arg(VALUE self){
+  simplet_style_t *style = get_style(self);
+  char *arg;
+  simplet_style_get_arg(style, &arg);
+  return rb_str_new2(arg);
+}
+
+/*
+Set the key for this Style.
+
+@param (String)
+@return (String)
+*/
+static VALUE
+set_key(VALUE self, VALUE key){
+  Check_Type(key, T_STRING);
+  simplet_style_t *style = get_style(self);
+  simplet_style_set_key(style, RSTRING_PTR(key));
+  return key;
+}
+
+/*
+Get the key for this Style.
+
+@param (String)
+@return (String)
+*/
+static VALUE
+get_key(VALUE self){
+  simplet_style_t *style = get_style(self);
+  char *key;
+  simplet_style_get_key(style, &key);
+  return rb_str_new2(key);
+}
+
+void
+init_style(){
+  VALUE rstyle = rb_define_class_under(mSimplerTiles, "Style", rb_cObject);
+  rb_define_alloc_func(rstyle, alloc_style);
+  rb_define_method(rstyle, "arg=", set_arg, 1);
+  rb_define_method(rstyle, "arg", get_arg, 0);
+  rb_define_method(rstyle, "key=", set_key, 1);
+  rb_define_method(rstyle, "key", get_key, 0);
+
+  cSimplerTilesStyle = rstyle;
+}