sfml3-rb 0.0.1 → 0.2.2

data/ext/system/vec2.c

@@ -0,0 +1,251 @@
+#include "system/vec2.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfVector2f vec;
+} Vector2;
+
+static VALUE rb_cVector2;
+
+static void Vector2_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t Vector2_data_type = {
+    .wrap_struct_name = "SFML::Vector2",
+    .function = {.dmark = NULL, .dfree = Vector2_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Vector2_new(int argc, VALUE *argv, VALUE klass) {
+    VALUE self;
+    Vector2 *ptr;
+    float x = 0;
+    float y = 0;
+
+    if (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cVector2)) {
+        ptr = Get_Vector2_Struct(argv[0]);
+        x = ptr->vec.x;
+        y = ptr->vec.y;
+    } else if (argc == 1 && RB_TYPE_P(argv[0], T_ARRAY)) {
+        if (RARRAY_LEN(argv[0]) < 2) {
+            raise_invalid_array_length(2);
+        }
+
+        x = NUM2DBL(rb_ary_entry(argv[0], 0));
+        y = NUM2DBL(rb_ary_entry(argv[0], 1));
+    } else if (argc == 2) {
+        x = NUM2DBL(argv[0]);
+        y = NUM2DBL(argv[1]);
+    } else if (argc != 0) {
+        raise_invalid_arguments_excepted(2, argc);
+    }
+
+    ptr = malloc(sizeof(Vector2));
+    ptr->vec.x = x;
+    ptr->vec.y = y;
+
+    self = TypedData_Wrap_Struct(klass, &Vector2_data_type, ptr);
+
+    return self;
+}
+
+static VALUE Vector2_get_x(VALUE self) {
+    return DBL2NUM(((Vector2 *) Get_Vector2_Struct(self))->vec.x);
+}
+
+static VALUE Vector2_get_y(VALUE self) {
+    return DBL2NUM(((Vector2 *) Get_Vector2_Struct(self))->vec.y);
+}
+
+static VALUE Vector2_set_x(VALUE self, VALUE rb_x) {
+    ((Vector2 *) Get_Vector2_Struct(self))->vec.x = NUM2DBL(rb_x);
+    return rb_x;
+}
+
+static VALUE Vector2_set_y(VALUE self, VALUE rb_y) {
+    ((Vector2 *) Get_Vector2_Struct(self))->vec.y = NUM2DBL(rb_y);
+    return rb_y;
+}
+
+static VALUE Vector2_to_a(VALUE self) {
+    Vector2 *vec = Get_Vector2_Struct(self);
+
+    return rb_ary_new_from_args(2, DBL2NUM(vec->vec.x), DBL2NUM(vec->vec.y));
+}
+
+static VALUE Vector2_each(VALUE self) {
+    Vector2 *vec = Get_Vector2_Struct(self);
+
+    rb_yield(DBL2NUM(vec->vec.x));
+    rb_yield(DBL2NUM(vec->vec.y));
+
+    return self;
+}
+
+static VALUE Vector2_aref(VALUE self, VALUE rb_index) {
+    return rb_ary_entry(Vector2_to_a(self), NUM2LONG(rb_index));
+}
+
+static VALUE Vector2_size(VALUE self) {
+    return INT2NUM(2);
+}
+
+static VALUE Vector2_eql(VALUE self, VALUE rb_other) {
+    Vector2 *a = Get_Vector2_Struct(self);
+    sfVector2f b;
+
+    if (rb_obj_is_kind_of(rb_other, rb_cVector2)) {
+        b = ((Vector2 *) Get_Vector2_Struct(rb_other))->vec;
+    } else if (RB_TYPE_P(rb_other, T_ARRAY) && RARRAY_LEN(rb_other) >= 2) {
+        b = vec2f_from_rb(rb_other);
+    } else {
+        return Qfalse;
+    }
+
+    return BOOL2RB(a->vec.x == b.x && a->vec.y == b.y);
+}
+
+static VALUE Vector2_add(VALUE self, VALUE rb_other) {
+    Vector2 *a = Get_Vector2_Struct(self);
+    sfVector2f b = vec2f_from_rb(rb_other);
+
+    return vec2f_to_rb((sfVector2f) {a->vec.x + b.x, a->vec.y + b.y});
+}
+
+static VALUE Vector2_sub(VALUE self, VALUE rb_other) {
+    Vector2 *a = Get_Vector2_Struct(self);
+    sfVector2f b = vec2f_from_rb(rb_other);
+
+    return vec2f_to_rb((sfVector2f) {a->vec.x - b.x, a->vec.y - b.y});
+}
+
+static VALUE Vector2_mul(VALUE self, VALUE rb_scalar) {
+    Vector2 *a = Get_Vector2_Struct(self);
+    float scalar = NUM2DBL(rb_scalar);
+
+    return vec2f_to_rb((sfVector2f) {a->vec.x * scalar, a->vec.y * scalar});
+}
+
+static VALUE Vector2_to_s(VALUE self) {
+    Vector2 *a = Get_Vector2_Struct(self);
+    char buffer[64];
+
+    snprintf(buffer, sizeof(buffer), "(%g, %g)", a->vec.x, a->vec.y);
+
+    return rb_str_new2(buffer);
+}
+
+void Init_Vector2(VALUE rb_module) {
+    rb_cVector2 = rb_define_class_under(rb_module, "Vector2", rb_cObject);
+
+    rb_include_module(rb_cVector2, rb_mEnumerable);
+
+    rb_define_singleton_method(rb_cVector2, "new", Vector2_new, -1);
+
+    rb_define_method(rb_cVector2, "x", Vector2_get_x, 0);
+    rb_define_method(rb_cVector2, "y", Vector2_get_y, 0);
+    rb_define_method(rb_cVector2, "x=", Vector2_set_x, 1);
+    rb_define_method(rb_cVector2, "y=", Vector2_set_y, 1);
+
+    rb_define_method(rb_cVector2, "to_a", Vector2_to_a, 0);
+    rb_define_method(rb_cVector2, "to_ary", Vector2_to_a, 0);
+    rb_define_method(rb_cVector2, "each", Vector2_each, 0);
+    rb_define_method(rb_cVector2, "[]", Vector2_aref, 1);
+    rb_define_method(rb_cVector2, "size", Vector2_size, 0);
+    rb_define_method(rb_cVector2, "length", Vector2_size, 0);
+    rb_define_method(rb_cVector2, "==", Vector2_eql, 1);
+    rb_define_method(rb_cVector2, "+", Vector2_add, 1);
+    rb_define_method(rb_cVector2, "-", Vector2_sub, 1);
+    rb_define_method(rb_cVector2, "*", Vector2_mul, 1);
+    rb_define_method(rb_cVector2, "to_s", Vector2_to_s, 0);
+}
+
+VALUE Get_Klass_Vector2(void) {
+    return rb_cVector2;
+}
+
+void *Get_Vector2_Struct(VALUE self) {
+    Vector2 *ptr;
+    TypedData_Get_Struct(self, Vector2, &Vector2_data_type, ptr);
+    return ptr;
+}
+
+sfVector2f vec2f_from_rb(VALUE rb_vec) {
+    if (rb_obj_is_kind_of(rb_vec, rb_cVector2)) {
+        return ((Vector2 *) Get_Vector2_Struct(rb_vec))->vec;
+    }
+
+    if (RB_TYPE_P(rb_vec, T_ARRAY)) {
+        if (RARRAY_LEN(rb_vec) < 2) {
+            raise_invalid_array_length(2);
+        }
+
+        return (sfVector2f) {
+            (float) NUM2DBL(rb_ary_entry(rb_vec, 0)),
+            (float) NUM2DBL(rb_ary_entry(rb_vec, 1))
+        };
+    }
+
+    raise_invalid_argument_class(rb_cVector2);
+
+    return (sfVector2f) {0, 0};
+}
+
+sfVector2i vec2i_from_rb(VALUE rb_vec) {
+    sfVector2f vec = vec2f_from_rb(rb_vec);
+
+    return (sfVector2i) {(int) vec.x, (int) vec.y};
+}
+
+sfVector2u vec2u_from_rb(VALUE rb_vec) {
+    sfVector2f vec = vec2f_from_rb(rb_vec);
+
+    return (sfVector2u) {(unsigned) vec.x, (unsigned) vec.y};
+}
+
+VALUE vec2f_to_rb(sfVector2f c_vec) {
+    Vector2 *ptr = malloc(sizeof(Vector2));
+
+    ptr->vec = c_vec;
+
+    return TypedData_Wrap_Struct(rb_cVector2, &Vector2_data_type, ptr);
+}
+
+VALUE vec2_new(float x, float y) {
+    return vec2f_to_rb((sfVector2f) {x, y});
+}
+
+void vec2_check(VALUE rb_arr) {
+    if (rb_obj_is_kind_of(rb_arr, rb_cVector2)) {
+        return;
+    }
+
+    if (RB_TYPE_P(rb_arr, T_ARRAY) && RARRAY_LEN(rb_arr) >= 2) {
+        return;
+    }
+
+    raise_invalid_array_length(2);
+}
+
+VALUE vec2f_new_from_c(sfVector2f c_vec) {
+    return vec2f_to_rb(c_vec);
+}
+
+sfVector2i vec2i_new_from_ruby(VALUE rb_arr) {
+    return vec2i_from_rb(rb_arr);
+}
+
+sfVector2u vec2u_new_from_ruby(VALUE rb_arr) {
+    return vec2u_from_rb(rb_arr);
+}
+
+sfVector2f vec2f_new_from_ruby(VALUE rb_arr) {
+    return vec2f_from_rb(rb_arr);
+}

data/ext/system/vec2.h

@@ -0,0 +1,55 @@
+#ifndef SFML_RB_SYSTEM_VEC2_H
+#define SFML_RB_SYSTEM_VEC2_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+#define UNPACK_VEC2(c_type, c_vec) (c_type) c_vec.x, (c_type) c_vec.y
+
+#define VEC2_C2RB(c_vec) vec2f_to_rb((sfVector2f) { (float) (c_vec).x, (float) (c_vec).y })
+
+#define VEC2_C2RB_T(c_type, c_vec) \
+    vec2f_to_rb((sfVector2f) { (float) (c_type) (c_vec).x, (float) (c_type) (c_vec).y })
+
+#define VEC2_RB2C(rb_vec) vec2f_from_rb(rb_vec)
+
+#define VEC2_RB2C_T(c_type, rb_vec) \
+    (c_type) NUM2DBL(rb_ary_entry(rb_vec, 0)), (c_type) NUM2DBL(rb_ary_entry(rb_vec, 1))
+
+#define VEC2_SET_X(rb_vec, x) rb_ary_store(rb_vec, 0, DBL2NUM(x))
+
+#define VEC2_SET_Y(rb_vec, y) rb_ary_store(rb_vec, 1, DBL2NUM(y))
+
+#define VEC2_GET_X(rb_vec) NUM2DBL(rb_ary_entry(rb_vec, 0))
+
+#define VEC2_GET_Y(rb_vec) NUM2DBL(rb_ary_entry(rb_vec, 1))
+
+void Init_Vector2(VALUE rb_module);
+
+VALUE Get_Klass_Vector2(void);
+
+void *Get_Vector2_Struct(VALUE self);
+
+sfVector2f vec2f_from_rb(VALUE rb_vec);
+
+sfVector2i vec2i_from_rb(VALUE rb_vec);
+
+sfVector2u vec2u_from_rb(VALUE rb_vec);
+
+VALUE vec2f_to_rb(sfVector2f c_vec);
+
+/* Backwards-compatible internal helpers. */
+VALUE vec2_new(float x, float y);
+
+void vec2_check(VALUE rb_arr);
+
+VALUE vec2f_new_from_c(sfVector2f c_vec);
+
+sfVector2i vec2i_new_from_ruby(VALUE rb_arr);
+
+sfVector2u vec2u_new_from_ruby(VALUE rb_arr);
+
+sfVector2f vec2f_new_from_ruby(VALUE rb_arr);
+
+#endif //SFML_RB_SYSTEM_VEC2_H

data/ext/system/vec3.c

@@ -0,0 +1,219 @@
+#include "system/vec3.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfVector3f vec;
+} Vector3;
+
+static VALUE rb_cVector3;
+
+static void Vector3_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t Vector3_data_type = {
+    .wrap_struct_name = "SFML::Vector3",
+    .function = {.dmark = NULL, .dfree = Vector3_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Vector3_new(int argc, VALUE *argv, VALUE klass) {
+    VALUE self;
+    Vector3 *ptr;
+    float x = 0;
+    float y = 0;
+    float z = 0;
+
+    if (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cVector3)) {
+        ptr = Get_Vector3_Struct(argv[0]);
+        x = ptr->vec.x;
+        y = ptr->vec.y;
+        z = ptr->vec.z;
+    } else if (argc == 1 && RB_TYPE_P(argv[0], T_ARRAY)) {
+        if (RARRAY_LEN(argv[0]) < 3) {
+            raise_invalid_array_length(3);
+        }
+
+        x = NUM2DBL(rb_ary_entry(argv[0], 0));
+        y = NUM2DBL(rb_ary_entry(argv[0], 1));
+        z = NUM2DBL(rb_ary_entry(argv[0], 2));
+    } else if (argc == 3) {
+        x = NUM2DBL(argv[0]);
+        y = NUM2DBL(argv[1]);
+        z = NUM2DBL(argv[2]);
+    } else if (argc != 0) {
+        raise_invalid_arguments_excepted(3, argc);
+    }
+
+    ptr = malloc(sizeof(Vector3));
+    ptr->vec.x = x;
+    ptr->vec.y = y;
+    ptr->vec.z = z;
+
+    self = TypedData_Wrap_Struct(klass, &Vector3_data_type, ptr);
+
+    return self;
+}
+
+static VALUE Vector3_get_x(VALUE self) {
+    return DBL2NUM(((Vector3 *) Get_Vector3_Struct(self))->vec.x);
+}
+
+static VALUE Vector3_get_y(VALUE self) {
+    return DBL2NUM(((Vector3 *) Get_Vector3_Struct(self))->vec.y);
+}
+
+static VALUE Vector3_get_z(VALUE self) {
+    return DBL2NUM(((Vector3 *) Get_Vector3_Struct(self))->vec.z);
+}
+
+static VALUE Vector3_set_x(VALUE self, VALUE rb_x) {
+    ((Vector3 *) Get_Vector3_Struct(self))->vec.x = NUM2DBL(rb_x);
+    return rb_x;
+}
+
+static VALUE Vector3_set_y(VALUE self, VALUE rb_y) {
+    ((Vector3 *) Get_Vector3_Struct(self))->vec.y = NUM2DBL(rb_y);
+    return rb_y;
+}
+
+static VALUE Vector3_set_z(VALUE self, VALUE rb_z) {
+    ((Vector3 *) Get_Vector3_Struct(self))->vec.z = NUM2DBL(rb_z);
+    return rb_z;
+}
+
+static VALUE Vector3_to_a(VALUE self) {
+    Vector3 *vec = Get_Vector3_Struct(self);
+
+    return rb_ary_new_from_args(3, DBL2NUM(vec->vec.x), DBL2NUM(vec->vec.y), DBL2NUM(vec->vec.z));
+}
+
+static VALUE Vector3_each(VALUE self) {
+    Vector3 *vec = Get_Vector3_Struct(self);
+
+    rb_yield(DBL2NUM(vec->vec.x));
+    rb_yield(DBL2NUM(vec->vec.y));
+    rb_yield(DBL2NUM(vec->vec.z));
+
+    return self;
+}
+
+static VALUE Vector3_size(VALUE self) {
+    return INT2NUM(3);
+}
+
+static VALUE Vector3_eql(VALUE self, VALUE rb_other) {
+    Vector3 *a = Get_Vector3_Struct(self);
+    sfVector3f b;
+
+    if (rb_obj_is_kind_of(rb_other, rb_cVector3)) {
+        b = ((Vector3 *) Get_Vector3_Struct(rb_other))->vec;
+    } else if (RB_TYPE_P(rb_other, T_ARRAY) && RARRAY_LEN(rb_other) >= 3) {
+        b = vec3f_from_rb(rb_other);
+    } else {
+        return Qfalse;
+    }
+
+    return BOOL2RB(a->vec.x == b.x && a->vec.y == b.y && a->vec.z == b.z);
+}
+
+static VALUE Vector3_add(VALUE self, VALUE rb_other) {
+    Vector3 *a = Get_Vector3_Struct(self);
+    sfVector3f b = vec3f_from_rb(rb_other);
+
+    return vec3f_to_rb((sfVector3f) {a->vec.x + b.x, a->vec.y + b.y, a->vec.z + b.z});
+}
+
+static VALUE Vector3_sub(VALUE self, VALUE rb_other) {
+    Vector3 *a = Get_Vector3_Struct(self);
+    sfVector3f b = vec3f_from_rb(rb_other);
+
+    return vec3f_to_rb((sfVector3f) {a->vec.x - b.x, a->vec.y - b.y, a->vec.z - b.z});
+}
+
+static VALUE Vector3_mul(VALUE self, VALUE rb_scalar) {
+    Vector3 *a = Get_Vector3_Struct(self);
+    float scalar = NUM2DBL(rb_scalar);
+
+    return vec3f_to_rb((sfVector3f) {a->vec.x * scalar, a->vec.y * scalar, a->vec.z * scalar});
+}
+
+static VALUE Vector3_to_s(VALUE self) {
+    Vector3 *a = Get_Vector3_Struct(self);
+    char buffer[96];
+
+    snprintf(buffer, sizeof(buffer), "(%g, %g, %g)", a->vec.x, a->vec.y, a->vec.z);
+
+    return rb_str_new2(buffer);
+}
+
+void Init_Vector3(VALUE rb_module) {
+    rb_cVector3 = rb_define_class_under(rb_module, "Vector3", rb_cObject);
+
+    rb_include_module(rb_cVector3, rb_mEnumerable);
+
+    rb_define_singleton_method(rb_cVector3, "new", Vector3_new, -1);
+
+    rb_define_method(rb_cVector3, "x", Vector3_get_x, 0);
+    rb_define_method(rb_cVector3, "y", Vector3_get_y, 0);
+    rb_define_method(rb_cVector3, "z", Vector3_get_z, 0);
+    rb_define_method(rb_cVector3, "x=", Vector3_set_x, 1);
+    rb_define_method(rb_cVector3, "y=", Vector3_set_y, 1);
+    rb_define_method(rb_cVector3, "z=", Vector3_set_z, 1);
+
+    rb_define_method(rb_cVector3, "to_a", Vector3_to_a, 0);
+    rb_define_method(rb_cVector3, "to_ary", Vector3_to_a, 0);
+    rb_define_method(rb_cVector3, "each", Vector3_each, 0);
+    rb_define_method(rb_cVector3, "size", Vector3_size, 0);
+    rb_define_method(rb_cVector3, "length", Vector3_size, 0);
+    rb_define_method(rb_cVector3, "==", Vector3_eql, 1);
+    rb_define_method(rb_cVector3, "+", Vector3_add, 1);
+    rb_define_method(rb_cVector3, "-", Vector3_sub, 1);
+    rb_define_method(rb_cVector3, "*", Vector3_mul, 1);
+    rb_define_method(rb_cVector3, "to_s", Vector3_to_s, 0);
+}
+
+VALUE Get_Klass_Vector3(void) {
+    return rb_cVector3;
+}
+
+void *Get_Vector3_Struct(VALUE self) {
+    Vector3 *ptr;
+    TypedData_Get_Struct(self, Vector3, &Vector3_data_type, ptr);
+    return ptr;
+}
+
+sfVector3f vec3f_from_rb(VALUE rb_vec) {
+    if (rb_obj_is_kind_of(rb_vec, rb_cVector3)) {
+        return ((Vector3 *) Get_Vector3_Struct(rb_vec))->vec;
+    }
+
+    if (RB_TYPE_P(rb_vec, T_ARRAY)) {
+        if (RARRAY_LEN(rb_vec) < 3) {
+            raise_invalid_array_length(3);
+        }
+
+        return (sfVector3f) {
+            (float) NUM2DBL(rb_ary_entry(rb_vec, 0)),
+            (float) NUM2DBL(rb_ary_entry(rb_vec, 1)),
+            (float) NUM2DBL(rb_ary_entry(rb_vec, 2))
+        };
+    }
+
+    raise_invalid_argument_class(rb_cVector3);
+
+    return (sfVector3f) {0, 0, 0};
+}
+
+VALUE vec3f_to_rb(sfVector3f c_vec) {
+    Vector3 *ptr = malloc(sizeof(Vector3));
+
+    ptr->vec = c_vec;
+
+    return TypedData_Wrap_Struct(rb_cVector3, &Vector3_data_type, ptr);
+}

data/ext/system/vec3.h

@@ -0,0 +1,18 @@
+#ifndef SFML_RB_SYSTEM_VEC3_H
+#define SFML_RB_SYSTEM_VEC3_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Vector3(VALUE rb_module);
+
+VALUE Get_Klass_Vector3(void);
+
+void *Get_Vector3_Struct(VALUE self);
+
+sfVector3f vec3f_from_rb(VALUE rb_vec);
+
+VALUE vec3f_to_rb(sfVector3f c_vec);
+
+#endif //SFML_RB_SYSTEM_VEC3_H

data/ext/window/clipboard.c

@@ -0,0 +1,89 @@
+#include "window/clipboard.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "core/sfml.h"
+
+static void unicode_char_to_utf8(sfChar32 code, char buffer[4], int *length) {
+    if (code < 0x80) {
+        buffer[0] = (char) code;
+        *length = 1;
+    } else if (code < 0x800) {
+        buffer[0] = (char) (0xC0 | (code >> 6));
+        buffer[1] = (char) (0x80 | (code & 0x3F));
+        *length = 2;
+    } else if (code < 0x10000) {
+        buffer[0] = (char) (0xE0 | (code >> 12));
+        buffer[1] = (char) (0x80 | ((code >> 6) & 0x3F));
+        buffer[2] = (char) (0x80 | (code & 0x3F));
+        *length = 3;
+    } else {
+        buffer[0] = (char) (0xF0 | (code >> 18));
+        buffer[1] = (char) (0x80 | ((code >> 12) & 0x3F));
+        buffer[2] = (char) (0x80 | ((code >> 6) & 0x3F));
+        buffer[3] = (char) (0x80 | (code & 0x3F));
+        *length = 4;
+    }
+}
+
+static VALUE Clipboard_get_string(VALUE module) {
+    const char *string = sfClipboard_getString();
+
+    return rb_utf8_str_new_cstr(string != NULL ? string : "");
+}
+
+static VALUE Clipboard_set_string(VALUE module, VALUE rb_text) {
+    sfClipboard_setString(StringValueCStr(rb_text));
+    return rb_text;
+}
+
+static VALUE Clipboard_get_unicode_string(VALUE module) {
+    const sfChar32 *chars = sfClipboard_getUnicodeString();
+    VALUE string = rb_utf8_str_new("", 0);
+
+    if (chars == NULL) {
+        return string;
+    }
+
+    for (size_t i = 0; chars[i] != 0; i++) {
+        char buffer[4];
+        int length;
+
+        unicode_char_to_utf8(chars[i], buffer, &length);
+        rb_str_cat(string, buffer, length);
+    }
+
+    return string;
+}
+
+static VALUE Clipboard_set_unicode_string(VALUE module, VALUE rb_text) {
+    VALUE codepoints;
+    long count;
+    sfChar32 *chars;
+
+    StringValue(rb_text);
+    codepoints = rb_funcall(rb_text, rb_intern("codepoints"), 0);
+    count = RARRAY_LEN(codepoints);
+    chars = ALLOC_N(sfChar32, count + 1);
+
+    for (long i = 0; i < count; i++) {
+        chars[i] = (sfChar32) NUM2UINT(rb_ary_entry(codepoints, i));
+    }
+
+    chars[count] = 0;
+    sfClipboard_setUnicodeString(chars);
+
+    xfree(chars);
+
+    return rb_text;
+}
+
+void Init_Clipboard(VALUE rb_module) {
+    VALUE rb_mClipboard = rb_define_module_under(rb_module, "Clipboard");
+
+    rb_define_module_function(rb_mClipboard, "string", Clipboard_get_string, 0);
+    rb_define_module_function(rb_mClipboard, "string=", Clipboard_set_string, 1);
+    rb_define_module_function(rb_mClipboard, "unicode_string", Clipboard_get_unicode_string, 0);
+    rb_define_module_function(rb_mClipboard, "unicode_string=", Clipboard_set_unicode_string, 1);
+}

data/ext/window/clipboard.h

@@ -0,0 +1,8 @@
+#ifndef SFML_RB_WINDOW_CLIPBOARD_H
+#define SFML_RB_WINDOW_CLIPBOARD_H
+
+#include <ruby.h>
+
+void Init_Clipboard(VALUE rb_module);
+
+#endif //SFML_RB_WINDOW_CLIPBOARD_H

data/ext/window/context.c

@@ -0,0 +1,70 @@
+#include "window/context.h"
+
+#include <ruby.h>
+
+#include "window/context_settings.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+static VALUE rb_cContext;
+
+static void Context_free(void *ptr) {
+    sfContext_destroy(ptr);
+}
+
+static const rb_data_type_t Context_data_type = {
+    .wrap_struct_name = "SFML::Context",
+    .function = {.dmark = NULL, .dfree = Context_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static sfContext *Get_Context_Struct(VALUE self) {
+    sfContext *ptr;
+    TypedData_Get_Struct(self, sfContext, &Context_data_type, ptr);
+    return ptr;
+}
+
+static VALUE Context_new(VALUE klass) {
+    sfContext *context = sfContext_create();
+    VALUE self;
+
+    if (context == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create context");
+    }
+
+    self = TypedData_Wrap_Struct(klass, &Context_data_type, context);
+
+    return self;
+}
+
+static VALUE Context_extension_available(VALUE klass, VALUE rb_name) {
+    return BOOL2RB(sfContext_isExtensionAvailable(StringValueCStr(rb_name)));
+}
+
+static VALUE Context_set_active(VALUE self, VALUE rb_active) {
+    return BOOL2RB(sfContext_setActive(Get_Context_Struct(self), RTEST(rb_active)));
+}
+
+static VALUE Context_get_function(VALUE klass, VALUE rb_name) {
+    return ULL2NUM((unsigned long long) (uintptr_t) sfContext_getFunction(StringValueCStr(rb_name)));
+}
+
+static VALUE Context_get_settings(VALUE self) {
+    return context_settings_to_rb(sfContext_getSettings(Get_Context_Struct(self)));
+}
+
+static VALUE Context_active_context_id(VALUE klass) {
+    return ULL2NUM(sfContext_getActiveContextId());
+}
+
+void Init_Context(VALUE rb_module) {
+    rb_cContext = rb_define_class_under(rb_module, "Context", rb_cObject);
+
+    rb_define_singleton_method(rb_cContext, "new", Context_new, 0);
+    rb_define_singleton_method(rb_cContext, "extension_available?", Context_extension_available, 1);
+    rb_define_singleton_method(rb_cContext, "function", Context_get_function, 1);
+    rb_define_singleton_method(rb_cContext, "active_context_id", Context_active_context_id, 0);
+
+    rb_define_method(rb_cContext, "active=", Context_set_active, 1);
+    rb_define_method(rb_cContext, "settings", Context_get_settings, 0);
+}