bare-gtk 0.0.0 → 0.1.1

package/CMakeLists.txt

@@ -7,7 +7,7 @@ find_package(PkgConfig REQUIRED)
 
 project(bare_gtk C)
 
-fetch_package("github:holepunchto/bare@1.24.5")
+fetch_package("github:holepunchto/bare@1.25.0")
 fetch_package("github:holepunchto/libpath")
 
 pkg_check_modules(GTK REQUIRED IMPORTED_TARGET GLOBAL gtk4)
@@ -52,13 +52,8 @@ target_link_libraries(
   PUBLIC
     $<LINK_LIBRARY:WHOLE_ARCHIVE,bare_static>
   PRIVATE
-    log_static
     rlimit_static
     path_static
-)
-
-target_link_libraries(
-  bare_runtime
   PRIVATE
     PkgConfig::GTK
 )

package/binding.c

@@ -22,8 +22,10 @@ bare_gtk_exports(js_env_t *env, js_value_t *exports) {
   }
 
   V("widgetVisible", bare_gtk_widget_visible)
+  V("widgetSizeRequest", bare_gtk_widget_size_request)
 
   V("windowInit", bare_gtk_window_init)
+  V("windowDefaultSize", bare_gtk_window_default_size)
   V("windowChild", bare_gtk_window_child)
 #undef V
 

package/lib/runtime.c

@@ -1,10 +1,10 @@
 #include <assert.h>
 #include <bare.h>
 #include <js.h>
-#include <log.h>
 #include <path.h>
 #include <rlimit.h>
 #include <signal.h>
+#include <unistd.h>
 #include <uv.h>
 
 #include <gtk/gtk.h>
@@ -14,9 +14,6 @@ static uv_async_t bare__platform_shutdown;
 static uv_thread_t bare__platform_thread;
 static js_platform_t *bare__platform;
 
-static int bare__argc;
-static char **bare__argv;
-
 static uv_loop_t *bare__loop;
 static uv_async_t bare__shutdown;
 static bare_t *bare;
@@ -27,6 +24,8 @@ static guint bare__timer;
 
 GtkApplication *bare_gtk_app;
 
+extern char __bare_identifier[] __attribute__((weak));
+
 static void
 bare__on_shutdown(uv_async_t *handle) {
   uv_close((uv_handle_t *) handle, NULL);
@@ -103,26 +102,11 @@ bare__run(void) {
 }
 
 static void
-bare__on_activate(GtkApplication *app, gpointer data) {
-  int err;
-
-  err = uv_barrier_init(&bare__platform_ready, 2);
-  assert(err == 0);
-
-  err = uv_thread_create(&bare__platform_thread, bare__on_platform_thread, NULL);
-  assert(err == 0);
-
-  uv_barrier_wait(&bare__platform_ready);
-
-  uv_barrier_destroy(&bare__platform_ready);
-
-  bare__loop = uv_default_loop();
-
-  err = uv_async_init(bare__loop, &bare__shutdown, bare__on_shutdown);
-  assert(err == 0);
+bare__on_activate(GtkApplication *app, gpointer data) {}
 
-  err = bare_setup(bare__loop, bare__platform, NULL, bare__argc, (const char **) bare__argv, NULL, &bare);
-  assert(err == 0);
+static void
+bare__on_startup(GtkApplication *app, gpointer data) {
+  int err;
 
   size_t len;
 
@@ -136,18 +120,18 @@ bare__on_activate(GtkApplication *app, gpointer data) {
   err = path_dirname(bin, &dir, path_behavior_system);
   assert(err == 0);
 
-  char bundle[4096];
+  char entry[4096];
   len = 4096;
 
   err = path_join(
     (const char *[]) {bin, "..", "..", "share", &bin[dir], "app.bundle", NULL},
-    bundle,
+    entry,
     &len,
     path_behavior_system
   );
   assert(err == 0);
 
-  err = bare_load(bare, bundle, NULL, NULL);
+  err = bare_load(bare, entry, NULL, NULL);
   (void) err;
 
   bare__channel = g_io_channel_unix_new(bare__loop->backend_fd);
@@ -167,21 +151,80 @@ main(int argc, char *argv[]) {
   signal(SIGPIPE, SIG_IGN);
 #endif
 
-  err = log_open("bare", 0);
-  assert(err == 0);
-
   err = rlimit_set(rlimit_open_files, rlimit_infer);
   assert(err == 0);
 
+  uv_disable_stdio_inheritance();
+
   argv = uv_setup_args(argc, argv);
 
-  bare__argc = argc;
-  bare__argv = argv;
+  err = uv_barrier_init(&bare__platform_ready, 2);
+  assert(err == 0);
+
+  err = uv_thread_create(&bare__platform_thread, bare__on_platform_thread, NULL);
+  assert(err == 0);
+
+  uv_barrier_wait(&bare__platform_ready);
+
+  uv_barrier_destroy(&bare__platform_ready);
+
+  bare__loop = uv_default_loop();
+
+  size_t len;
+
+  char bin[4096];
+  len = sizeof(bin);
+
+  err = uv_exepath(bin, &len);
+  assert(err == 0);
+
+  size_t dir;
+  err = path_dirname(bin, &dir, path_behavior_system);
+  assert(err == 0);
 
-  GtkApplication *app = bare_gtk_app = gtk_application_new(NULL, 0);
+  char preflight[4096];
+  len = 4096;
+
+  err = path_join(
+    (const char *[]) {bin, "..", "..", "share", &bin[dir], "preflight.bundle", NULL},
+    preflight,
+    &len,
+    path_behavior_system
+  );
+  assert(err == 0);
+
+  uv_fs_t fs;
+  err = uv_fs_access(bare__loop, &fs, preflight, R_OK, NULL);
+
+  if (err == 0) {
+    err = bare_setup(bare__loop, bare__platform, NULL, argc, (const char **) argv, NULL, &bare);
+    assert(err == 0);
+
+    err = bare_load(bare, preflight, NULL, NULL);
+    (void) err;
+
+    err = bare_run(bare, UV_RUN_DEFAULT);
+    assert(err == 0);
+
+    int exit_code;
+    err = bare_teardown(bare, UV_RUN_DEFAULT, &exit_code);
+    assert(err == 0);
+
+    if (exit_code != 0) _exit(exit_code);
+  }
+
+  err = uv_async_init(bare__loop, &bare__shutdown, bare__on_shutdown);
+  assert(err == 0);
+
+  err = bare_setup(bare__loop, bare__platform, NULL, argc, (const char **) argv, NULL, &bare);
+  assert(err == 0);
+
+  GtkApplication *app = bare_gtk_app = gtk_application_new(__bare_identifier, 0);
 
   g_signal_connect(app, "activate", G_CALLBACK(bare__on_activate), NULL);
 
+  g_signal_connect(app, "startup", G_CALLBACK(bare__on_startup), NULL);
+
   g_application_run(G_APPLICATION(app), argc, argv);
 
   g_source_remove(bare__poll);
@@ -211,8 +254,5 @@ main(int argc, char *argv[]) {
 
   uv_thread_join(&bare__platform_thread);
 
-  err = log_close();
-  assert(err == 0);
-
   return exit_code;
 }

package/lib/widget.h

@@ -37,3 +37,54 @@ bare_gtk_widget_visible(js_env_t *env, js_callback_info_t *info) {
 
   return result;
 }
+
+static js_value_t *
+bare_gtk_widget_size_request(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1 || argc == 3);
+
+  GtkWidget *widget;
+  err = js_get_value_external(env, argv[0], (void **) &widget);
+  assert(err == 0);
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    int width, height;
+    gtk_widget_get_size_request(widget, &width, &height);
+
+    err = js_create_array_with_length(env, 2, &result);
+    assert(err == 0);
+
+#define V(i, d) \
+  { \
+    js_value_t *val; \
+    err = js_create_int32(env, d, &val); \
+    assert(err == 0); \
+    err = js_set_element(env, result, i, val); \
+    assert(err == 0); \
+  }
+    V(0, width)
+    V(1, width)
+#undef V
+  } else {
+    int32_t width;
+    err = js_get_value_int32(env, argv[1], &width);
+    assert(err == 0);
+
+    int32_t height;
+    err = js_get_value_int32(env, argv[2], &height);
+    assert(err == 0);
+
+    gtk_widget_set_size_request(widget, width, height);
+  }
+
+  return result;
+}

package/lib/widget.js

@@ -15,4 +15,12 @@ module.exports = class GTKWidget extends EventEmitter {
   set visible(value) {
     binding.widgetVisible(this._handle, value)
   }
+
+  get sizeRequest() {
+    return binding.widgetSizeRequest(this._handle)
+  }
+
+  set sizeRequest([width, height]) {
+    binding.widgetSizeRequest(this._handle, width, height)
+  }
 }

package/lib/window.h

@@ -48,6 +48,11 @@ bare_window_class_init(BareWindowClass *class) {
   object_class->finalize = bare_window_finalize;
 }
 
+static void
+bare_gtk_window__on_release(js_env_t *env, void *data, void *finalize_hint) {
+  g_object_unref(data);
+}
+
 static js_value_t *
 bare_gtk_window_init(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -70,12 +75,63 @@ bare_gtk_window_init(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   js_value_t *handle;
-  err = js_create_external(env, window, NULL, NULL, &handle);
+  err = js_create_external(env, window, bare_gtk_window__on_release, NULL, &handle);
   assert(err == 0);
 
   return handle;
 }
 
+static js_value_t *
+bare_gtk_window_default_size(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1 || argc == 3);
+
+  BareWindow *window;
+  err = js_get_value_external(env, argv[0], (void **) &window);
+  assert(err == 0);
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    int width, height;
+    gtk_window_get_default_size(GTK_WINDOW(window), &width, &height);
+
+    err = js_create_array_with_length(env, 2, &result);
+    assert(err == 0);
+
+#define V(i, d) \
+  { \
+    js_value_t *val; \
+    err = js_create_int32(env, d, &val); \
+    assert(err == 0); \
+    err = js_set_element(env, result, i, val); \
+    assert(err == 0); \
+  }
+    V(0, width)
+    V(1, width)
+#undef V
+  } else {
+    int32_t width;
+    err = js_get_value_int32(env, argv[1], &width);
+    assert(err == 0);
+
+    int32_t height;
+    err = js_get_value_int32(env, argv[2], &height);
+    assert(err == 0);
+
+    gtk_window_set_default_size(GTK_WINDOW(window), width, height);
+  }
+
+  return result;
+}
+
 static js_value_t *
 bare_gtk_window_child(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -88,23 +144,28 @@ bare_gtk_window_child(js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 1 || argc == 2);
 
-  void *handle;
-  err = js_get_value_external(env, argv[0], &handle);
+  BareWindow *window;
+  err = js_get_value_external(env, argv[0], (void **) &window);
   assert(err == 0);
 
-  GtkWindow *window = handle;
-
   js_value_t *result = NULL;
 
   if (argc == 1) {
-    err = js_create_external(env, gtk_window_get_child(window), NULL, NULL, &result);
-    assert(err == 0);
+    GtkWidget *handle = gtk_window_get_child(GTK_WINDOW(window));
+
+    if (handle) {
+      err = js_create_external(env, handle, NULL, NULL, &result);
+      assert(err == 0);
+    } else {
+      err = js_get_null(env, &result);
+      assert(err == 0);
+    }
   } else {
     void *handle;
     err = js_get_value_external(env, argv[1], &handle);
     assert(err == 0);
 
-    gtk_window_set_child(window, handle);
+    gtk_window_set_child(GTK_WINDOW(window), handle);
   }
 
   return result;

package/lib/window.js

@@ -8,8 +8,20 @@ module.exports = exports = class GTKWindow extends GTKWidget {
     this._handle = binding.windowInit(this)
   }
 
+  get defaultSize() {
+    return binding.windowDefaultSize(this._handle)
+  }
+
+  set defaultSize([width, height]) {
+    binding.windowDefaultSize(this._handle, width, height)
+  }
+
   get child() {
-    return new GTKWidget(binding.windowChild(this._handle))
+    const handle = binding.windowChild(this._handle)
+
+    if (handle === null) return null
+
+    return new GTKWidget(handle)
   }
 
   set child(widget) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-gtk",
-  "version": "0.0.0",
+  "version": "0.1.1",
   "description": "GTK bindings and runtime for Bare",
   "exports": {
     "./package": "./package.json",