nuklear 0.1.0

data/ext/nuklear/nkrb_ui_group.c

@@ -0,0 +1,27 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_group(VALUE self, VALUE rcontext, VALUE rtitle, VALUE rflags, VALUE rscroll_x, VALUE rscroll_y) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+  const char *title = StringValueCStr(rtitle);
+  int flags = FIX2INT(rflags);
+  unsigned int scroll_x = (unsigned int) FIX2INT(rscroll_x);
+  unsigned int scroll_y = (unsigned int) FIX2INT(rscroll_y);
+  int result = nk_group_scrolled_offset_begin(context, &scroll_x, &scroll_y, title, flags);
+
+  if (result) {
+    if (rb_block_given_p()) {
+      instance_eval_block(self);
+    }
+    nk_group_end(context);
+    VALUE scroll = rb_ary_new();
+    rb_ary_push(scroll, INT2FIX(scroll_x));
+    rb_ary_push(scroll, INT2FIX(scroll_y));
+    return scroll;
+  }
+
+  return Qnil;
+}
+
+void nkrb_ui_group_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_group", nkrb_ui_group, 5);
+}

data/ext/nuklear/nkrb_ui_label.c

@@ -0,0 +1,30 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_label(VALUE self, VALUE rcontext, VALUE text, VALUE rcolor, VALUE rwrap, VALUE ralign) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+  int align = FIX2INT(ralign);
+
+  if (RTEST(rwrap)) {
+    if (NIL_P(rcolor)) {
+      nk_text_wrap(context, StringValuePtr(text), (int) RSTRING_LEN(text));
+    } else {
+      struct nk_color color;
+      ASSIGN_STYLE_AS_COLOR(color, nkrb_style_item(rcolor));
+      nk_text_wrap_colored(context, StringValuePtr(text), (int) RSTRING_LEN(text), color);
+    }
+  } else {
+    if (NIL_P(rcolor)) {
+      nk_text(context, StringValuePtr(text), (int) RSTRING_LEN(text), align);
+    } else {
+      struct nk_color color;
+      ASSIGN_STYLE_AS_COLOR(color, nkrb_style_item(rcolor));
+      nk_text_colored(context, StringValuePtr(text), (int) RSTRING_LEN(text), align, color);
+    }
+  }
+
+  return Qnil;
+}
+
+void nkrb_ui_label_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_label", nkrb_ui_label, 5);
+}

data/ext/nuklear/nkrb_ui_layout.c

@@ -0,0 +1,125 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_layout_row(VALUE self, VALUE rcontext, VALUE rformat, VALUE rheight, VALUE rratios) {
+  struct nk_context *ctx = nkrb_context_get(rcontext);
+  enum nk_layout_format fmt = NK_DYNAMIC;
+  if (SYM2ID(rformat) == rb_intern("static")) fmt = NK_STATIC;
+  float height = (float) NUM2DBL(rheight);
+  int len = (int) RARRAY_LEN(rratios);
+  float *ratios = malloc(len * sizeof(float));
+  int i;
+  for (i = 0; i < len; i++) {
+    ratios[i] = (float) NUM2DBL(rb_ary_entry(rratios, i));
+  }
+  nk_layout_row(ctx, fmt, height, len, ratios);
+  free(ratios);
+  return Qnil;
+}
+
+VALUE nkrb_ui_layout_row_dynamic(VALUE self, VALUE context, VALUE height, VALUE ncols) {
+  nk_layout_row_dynamic(nkrb_context_get(context), (float) NUM2DBL(height), FIX2INT(ncols));
+  return Qtrue;
+}
+
+VALUE nkrb_ui_layout_row_static(VALUE self, VALUE context, VALUE height, VALUE col_width, VALUE ncols) {
+  nk_layout_row_static(nkrb_context_get(context), (float) NUM2DBL(height), FIX2INT(col_width), FIX2INT(ncols));
+  return Qtrue;
+}
+
+VALUE nkrb_ui_layout_row_begin(VALUE self, VALUE context, VALUE format, VALUE row_height, VALUE ncols) {
+  struct nk_context *ctx = nkrb_context_get(context);
+  enum nk_layout_format fmt = NK_DYNAMIC;
+  if (SYM2ID(format) == rb_intern("static")) fmt = NK_STATIC;
+  nk_layout_row_begin(ctx, fmt, (float) NUM2DBL(row_height), FIX2INT(ncols));
+  if (rb_block_given_p()) {
+    instance_eval_block(Qtrue);
+  }
+  nk_layout_row_end(ctx);
+  return Qnil;
+}
+
+VALUE nkrb_ui_layout_row_push(VALUE self, VALUE context, VALUE value) {
+  nk_layout_row_push(nkrb_context_get(context), (float) NUM2DBL(value));
+  return Qtrue;
+}
+
+VALUE nkrb_ui_layout_row_template_begin(VALUE self, VALUE context, VALUE height) {
+  nk_layout_row_template_begin(nkrb_context_get(context), (float) NUM2DBL(height));
+  return Qnil;
+}
+
+VALUE nkrb_ui_layout_row_template_push_dynamic(VALUE self, VALUE context) {
+  nk_layout_row_template_push_dynamic(nkrb_context_get(context));
+  return Qnil;
+}
+
+VALUE nkrb_ui_layout_row_template_push_variable(VALUE self, VALUE context, VALUE min_width) {
+  nk_layout_row_template_push_variable(nkrb_context_get(context), (float) NUM2DBL(min_width));
+  return Qnil;
+}
+
+VALUE nkrb_ui_layout_row_template_push_static(VALUE self, VALUE context, VALUE width) {
+  nk_layout_row_template_push_static(nkrb_context_get(context), (float) NUM2DBL(width));
+  return Qnil;
+}
+
+VALUE nkrb_ui_layout_row_template_end(VALUE self, VALUE context) {
+  nk_layout_row_template_end(nkrb_context_get(context));
+  return Qnil;
+}
+
+VALUE nkrb_ui_layout_space_begin(VALUE self, VALUE context, VALUE format, VALUE height, VALUE widget_count) {
+  enum nk_layout_format fmt = NK_DYNAMIC;
+  if (SYM2ID(format) == rb_intern("static")) fmt = NK_STATIC;
+  nk_layout_space_begin(nkrb_context_get(context), fmt, (float) NUM2DBL(height), FIX2INT(widget_count));
+  return Qnil;
+}
+
+VALUE nkrb_ui_layout_space_push(VALUE self, VALUE context, VALUE rbounds) {
+  VALUE left   = rb_hash_aref(rbounds, ID2SYM(rb_intern("left")));
+  VALUE top    = rb_hash_aref(rbounds, ID2SYM(rb_intern("top")));
+  VALUE width  = rb_hash_aref(rbounds, ID2SYM(rb_intern("width")));
+  VALUE height = rb_hash_aref(rbounds, ID2SYM(rb_intern("height")));
+  if (NIL_P(left))   rb_raise(rb_eArgError, ":left option is required");
+  if (NIL_P(top))    rb_raise(rb_eArgError, ":top option is required");
+  if (NIL_P(width))  rb_raise(rb_eArgError, ":width option is required");
+  if (NIL_P(height)) rb_raise(rb_eArgError, ":height option is required");
+  float x = (float) NUM2DBL(left);
+  float y = (float) NUM2DBL(top);
+  float w = (float) NUM2DBL(width);
+  float h = (float) NUM2DBL(height);
+  nk_layout_space_push(nkrb_context_get(context), nk_rect(x, y, w, h));
+  return Qnil;
+}
+
+VALUE nkrb_ui_layout_space_end(VALUE self, VALUE context) {
+  nk_layout_space_end(nkrb_context_get(context));
+  return Qnil;
+}
+
+VALUE nkrb_ui_layout_widget_bounds(VALUE self, VALUE context) {
+  struct nk_rect bounds = nk_layout_widget_bounds(nkrb_context_get(context));
+  VALUE ret = rb_hash_new();
+  rb_hash_aset(ret, ID2SYM(rb_intern("left")),   bounds.x);
+  rb_hash_aset(ret, ID2SYM(rb_intern("top")),    bounds.y);
+  rb_hash_aset(ret, ID2SYM(rb_intern("width")),  bounds.w);
+  rb_hash_aset(ret, ID2SYM(rb_intern("height")), bounds.h);
+  return Qnil;
+}
+
+void nkrb_ui_layout_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_layout_row",                   nkrb_ui_layout_row,                        4);
+  rb_define_method(mNuklearUIContainer, "ui_layout_row_dynamic",           nkrb_ui_layout_row_dynamic,                3);
+  rb_define_method(mNuklearUIContainer, "ui_layout_row_static",            nkrb_ui_layout_row_static,                 4);
+  rb_define_method(mNuklearUIContainer, "ui_layout_row_begin",             nkrb_ui_layout_row_begin,                  4);
+  rb_define_method(mNuklearUIContainer, "ui_layout_row_push",              nkrb_ui_layout_row_push,                   2);
+  rb_define_method(mNuklearUIContainer, "ui_layout_row_template_begin",    nkrb_ui_layout_row_template_begin,         2);
+  rb_define_method(mNuklearUIContainer, "ui_layout_row_template_dynamic",  nkrb_ui_layout_row_template_push_dynamic,  1);
+  rb_define_method(mNuklearUIContainer, "ui_layout_row_template_variable", nkrb_ui_layout_row_template_push_variable, 2);
+  rb_define_method(mNuklearUIContainer, "ui_layout_row_template_static",   nkrb_ui_layout_row_template_push_static,   2);
+  rb_define_method(mNuklearUIContainer, "ui_layout_row_template_end",      nkrb_ui_layout_row_template_end,           1);
+  rb_define_method(mNuklearUIContainer, "ui_layout_space_begin",           nkrb_ui_layout_space_begin,                4);
+  rb_define_method(mNuklearUIContainer, "ui_layout_space_push",            nkrb_ui_layout_space_push,                 2);
+  rb_define_method(mNuklearUIContainer, "ui_layout_space_end",             nkrb_ui_layout_space_end,                  1);
+  rb_define_method(mNuklearUIContainer, "ui_layout_widget_bounds",         nkrb_ui_layout_widget_bounds,              1);
+}

data/ext/nuklear/nkrb_ui_menu.c

@@ -0,0 +1,49 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_menu(VALUE self, VALUE rcontext, VALUE roptions) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+
+  VALUE rtitle = rb_hash_aref(roptions, ID2SYM(rb_intern("title")));
+  VALUE rimage = rb_hash_aref(roptions, ID2SYM(rb_intern("image")));
+  VALUE rsymbol = rb_hash_aref(roptions, ID2SYM(rb_intern("symbol")));
+  nk_flags align = FIX2INT(rb_hash_aref(roptions, ID2SYM(rb_intern("align"))));
+  float width  = (float) NUM2DBL(rb_hash_aref(roptions, ID2SYM(rb_intern("width"))));
+  float height = (float) NUM2DBL(rb_hash_aref(roptions, ID2SYM(rb_intern("height"))));
+  struct nk_vec2 size = nk_vec2(width, height);
+  VALUE rid = rb_hash_aref(roptions, ID2SYM(rb_intern("id")));
+
+  enum nk_symbol_type symbol = NK_SYMBOL_NONE;
+  SET_RSYMBOL(symbol, rsymbol);
+
+  int result = 0;
+  if (!NIL_P(rimage)) {
+    struct nk_image img;
+    ASSIGN_STYLE_AS_IMAGE(img, nkrb_style_item(rimage))
+    if (!NIL_P(rtitle)) {
+      result = nk_menu_begin_image_text(context, RSTRING_PTR(rtitle), (int) RSTRING_LEN(rtitle), align, img, size);
+    } else {
+      rid = rb_funcall(rid, rb_intern("to_s"), 0);
+      result = nk_menu_begin_image(context, StringValueCStr(rid), img, size);
+    }
+  } else if (!NIL_P(rtitle)) {
+    result = nk_menu_begin_symbol_text(context, RSTRING_PTR(rtitle), (int) RSTRING_LEN(rtitle), align, symbol, size);
+  } else {
+    rid = rb_funcall(rid, rb_intern("to_s"), 0);
+    result = nk_menu_begin_symbol(context, StringValueCStr(rid), symbol, size);
+  }
+
+  if (result) {
+    if (rb_block_given_p()) {
+      rb_yield(Qtrue);
+    }
+    nk_menu_end(context);
+  } else {
+    return Qfalse;
+  }
+
+  return Qnil;
+}
+
+void nkrb_ui_menu_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_menu", nkrb_ui_menu, 2);
+}

data/ext/nuklear/nkrb_ui_menu_item.c

@@ -0,0 +1,30 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_menu_item(VALUE self, VALUE rcontext, VALUE roptions) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+
+  VALUE rtitle = rb_funcall(rb_hash_aref(roptions, ID2SYM(rb_intern("title"))), rb_intern("to_s"), 0);
+  VALUE rimage = rb_hash_aref(roptions, ID2SYM(rb_intern("image")));
+  VALUE rsymbol = rb_hash_aref(roptions, ID2SYM(rb_intern("symbol")));
+  nk_flags align = FIX2INT(rb_hash_aref(roptions, ID2SYM(rb_intern("align"))));
+
+  enum nk_symbol_type symbol = NK_SYMBOL_NONE;
+  SET_RSYMBOL(symbol, rsymbol);
+
+  int result = 0;
+  if (!NIL_P(rimage)) {
+    struct nk_image img;
+    ASSIGN_STYLE_AS_IMAGE(img, nkrb_style_item(rimage))
+    result = nk_menu_item_image_text(context, img, RSTRING_PTR(rtitle), (int) RSTRING_LEN(rtitle), align);
+  } else if (!NIL_P(rsymbol)) {
+    result = nk_menu_item_symbol_text(context, symbol, RSTRING_PTR(rtitle), (int) RSTRING_LEN(rtitle), align);
+  } else {
+    result = nk_menu_item_text(context, RSTRING_PTR(rtitle), (int) RSTRING_LEN(rtitle), align);
+  }
+
+  return result ? ID2SYM(rb_intern("clicked")) : Qnil;
+}
+
+void nkrb_ui_menu_item_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_menu_item", nkrb_ui_menu_item, 2);
+}

data/ext/nuklear/nkrb_ui_menubar.c

@@ -0,0 +1,18 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_menubar(VALUE self, VALUE rcontext) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+
+  nk_menubar_begin(context);
+
+  if (rb_block_given_p()) {
+    rb_yield(Qtrue);
+  }
+
+  nk_menubar_end(context);
+  return Qnil;
+}
+
+void nkrb_ui_menubar_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_menubar", nkrb_ui_menubar, 1);
+}

data/ext/nuklear/nkrb_ui_popup.c

@@ -0,0 +1,24 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_popup(VALUE self, VALUE context, VALUE rtype, VALUE rtitle, VALUE rflags, VALUE left, VALUE top, VALUE width, VALUE height) {
+  struct nk_context *ctx = nkrb_context_get(context);
+  const char *title = StringValueCStr(rtitle);
+  int type = FIX2INT(rtype);
+  int flags = FIX2INT(rflags);
+  float x = (float) NUM2DBL(left);
+  float y = (float) NUM2DBL(top);
+  float w = (float) NUM2DBL(width);
+  float h = (float) NUM2DBL(height);
+  if (nk_popup_begin(ctx, type, title, flags, nk_rect(x, y, w, h))) {
+    if (rb_block_given_p()) {
+      instance_eval_block(ID2SYM(rb_intern("visible")));
+    }
+    nk_popup_end(ctx);
+    return Qnil;
+  }
+  return ID2SYM(rb_intern("hidden"));
+}
+
+void nkrb_ui_popup_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_popup", nkrb_ui_popup, 8);
+}

data/ext/nuklear/nkrb_ui_progress.c

@@ -0,0 +1,19 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_progress(VALUE self, VALUE context, VALUE rcurrent, VALUE rmax, VALUE rmodifiable) {
+  struct nk_context *ctx = nkrb_context_get(context);
+  nk_size current = (nk_size) NUM2LL(rcurrent);
+  nk_size max     = (nk_size) NUM2LL(rmax);
+  int modifiable  = nk_false;
+  if (RTEST(rmodifiable)) modifiable = nk_true;
+
+  if (nk_progress(ctx, &current, max, modifiable)) {
+    return LL2NUM(current);
+  }
+
+  return Qnil;
+}
+
+void nkrb_ui_progress_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_progress", nkrb_ui_progress, 4);
+}

data/ext/nuklear/nkrb_ui_property.c

@@ -0,0 +1,20 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_property(VALUE self, VALUE context, VALUE rid, VALUE rmin, VALUE rcurrent, VALUE rmax, VALUE rstep, VALUE rinc_per_pixel) {
+  struct nk_context *ctx = nkrb_context_get(context);
+  float min     = (float) NUM2DBL(rmin);
+  float current = (float) NUM2DBL(rcurrent);
+  float max     = (float) NUM2DBL(rmax);
+  float step    = (float) NUM2DBL(rstep);
+  float inc_pp  = (float) NUM2DBL(rinc_per_pixel);
+  float prev = current;
+  rid = rb_funcall(rid, rb_intern("to_s"), 0);
+
+  nk_property_float(ctx, StringValueCStr(rid), min, &current, max, step, inc_pp);
+  if (current != prev) return DBL2NUM(current);
+  return Qnil;
+}
+
+void nkrb_ui_property_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_property", nkrb_ui_property, 7);
+}

data/ext/nuklear/nkrb_ui_selectables.c

@@ -0,0 +1,53 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_checkbox(VALUE self, VALUE rcontext, VALUE rtext, VALUE ris_checked) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+  const char *text = StringValueCStr(rtext);
+  int is_checked = RTEST(ris_checked) ? 1 : 0;
+  if (nk_checkbox_label(context, text, &is_checked)) {
+    return is_checked ? Qtrue : Qfalse;
+  }
+  return Qnil;
+}
+
+VALUE nkrb_ui_option(VALUE self, VALUE rcontext, VALUE rtext, VALUE ris_checked) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+  const char *text = StringValueCStr(rtext);
+  int is_checked = RTEST(ris_checked) ? 1 : 0;
+  if (nk_option_label(context, text, is_checked)) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+VALUE nkrb_ui_selectable(VALUE self, VALUE rcontext, VALUE rimage, VALUE rtext, VALUE rselected, VALUE ralign) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+  int align = FIX2INT(ralign);
+  int selected = RTEST(rselected) ? 1 : 0;
+  int result;
+  if (NIL_P(rtext)) return Qnil;
+
+  const char *text = StringValuePtr(rtext);
+  int len = (int) RSTRING_LEN(rtext);
+
+  if (NIL_P(rimage))
+    result = nk_selectable_text(context, text, len, align, &selected);
+  else {
+    struct nk_image img;
+    ASSIGN_STYLE_AS_IMAGE(img, nkrb_style_item(rimage))
+    result = nk_selectable_image_text(context, img, text, len, align, &selected);
+  }
+
+  if (result) {
+    return selected ? Qtrue : Qfalse;
+  }
+
+  return Qnil;
+}
+
+void nkrb_ui_checkbox_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_checkbox",   nkrb_ui_checkbox,   3);
+  rb_define_method(mNuklearUIContainer, "ui_option",     nkrb_ui_option,     3);
+  rb_define_method(mNuklearUIContainer, "ui_selectable", nkrb_ui_selectable, 5);
+}

data/ext/nuklear/nkrb_ui_slider.c

@@ -0,0 +1,19 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_slider(VALUE self, VALUE context, VALUE rcurrent, VALUE rmin, VALUE rmax, VALUE rstep) {
+  struct nk_context *ctx = nkrb_context_get(context);
+  float current = (float) NUM2DBL(rcurrent);
+  float minimum = (float) NUM2DBL(rmin);
+  float maximum = (float) NUM2DBL(rmax);
+  float step    = (float) NUM2DBL(rstep);
+
+  if (nk_slider_float(ctx, minimum, &current, maximum, step)) {
+    return DBL2NUM(current);
+  }
+
+  return Qnil;
+}
+
+void nkrb_ui_slider_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_slider", nkrb_ui_slider, 5);
+}

data/ext/nuklear/nkrb_ui_tree.c

@@ -0,0 +1,29 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_tree(VALUE self, VALUE rcontext, VALUE rtree_type, VALUE rimage, VALUE rtitle, VALUE rcurrent_state) {
+  struct nk_context        *context = nkrb_context_get(rcontext);
+  enum   nk_tree_type       tree_type = FIX2INT(rtree_type);
+  enum   nk_collapse_states current_state = FIX2INT(rcurrent_state);
+  const char *title = StringValueCStr(rtitle);
+  int result;
+  if (!NIL_P(rimage)) {
+    struct nk_image image;
+    ASSIGN_STYLE_AS_IMAGE(image, nkrb_style_item(rimage));
+    result = nk_tree_state_image_push(context, tree_type, image, title, &current_state);
+  } else {
+    result = nk_tree_state_push(context, tree_type, title, &current_state);
+  }
+
+  if (rb_block_given_p()) {
+    rb_yield(INT2FIX(current_state));
+  }
+
+  if (result)
+    nk_tree_state_pop(context);
+
+  return Qnil;
+}
+
+void nkrb_ui_tree_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_tree", nkrb_ui_tree, 5);
+}

data/ext/nuklear/nkrb_ui_widget.c

@@ -0,0 +1,7 @@
+#include "nkrb.h"
+
+VALUE cNuklearUIWidget = Qnil;
+
+void nkrb_ui_widget_init(void) {
+  cNuklearUIWidget = rb_define_class_under(mNuklearUI, "Widget", rb_cObject);
+}

data/ext/nuklear/nkrb_ui_window.c

@@ -0,0 +1,43 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_window(VALUE self, VALUE context, VALUE rid, VALUE rtitle, VALUE rflags, VALUE left, VALUE top, VALUE width, VALUE height) {
+  struct nk_context *ctx = nkrb_context_get(context);
+  const char *id = StringValueCStr(rid);
+  const char *title = StringValueCStr(rtitle);
+  int flags = FIX2INT(rflags);
+  float x = (float) NUM2DBL(left);
+  float y = (float) NUM2DBL(top);
+  float w = (float) NUM2DBL(width);
+  float h = (float) NUM2DBL(height);
+  if (nk_begin_titled(ctx, id, title, nk_rect(x, y, w, h), flags)) {
+    VALUE result = rb_ary_new();
+    struct nk_rect bounds         = nk_window_get_bounds(ctx);
+    struct nk_rect content_region = nk_window_get_content_region(ctx);
+    rb_ary_push(result, DBL2NUM(bounds.x));
+    rb_ary_push(result, DBL2NUM(bounds.y));
+    rb_ary_push(result, DBL2NUM(bounds.w));
+    rb_ary_push(result, DBL2NUM(bounds.h));
+    rb_ary_push(result, DBL2NUM(content_region.x));
+    rb_ary_push(result, DBL2NUM(content_region.y));
+    rb_ary_push(result, DBL2NUM(content_region.w));
+    rb_ary_push(result, DBL2NUM(content_region.h));
+
+    if (rb_block_given_p()) {
+      rb_yield(result);
+    }
+  }
+  nk_end(ctx);
+  return Qnil;
+}
+
+VALUE nkrb_ui_window_close(VALUE self, VALUE context, VALUE rid) {
+  struct nk_context *ctx = nkrb_context_get(context);
+  const char *id = StringValueCStr(rid);
+  nk_window_close(ctx, id);
+  return Qnil;
+}
+
+void nkrb_ui_window_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_window", nkrb_ui_window, 8);
+  rb_define_method(mNuklearUIContainer, "ui_window_close", nkrb_ui_window_close, 2);
+}