Readded uiWindow on the GTK+ backend and to the tests.

new/test/main.c

@@ -7,8 +7,41 @@ void die(const char *fmt, ...)
 	abort();
 }
 
-int main(void)
+int onClosing(uiWindow *w, void *data)
 {
-	printf("hello, world %p\n", uiMain);
+	printf("in onClosing()\n");
+	uiQuit();
+	return 1;
+}
+
+int main(int argc, char *argv[])
+{
+	uiInitOptions o;
+	int i;
+	const char *err;
+	uiWindow *w;
+
+	memset(&o, 0, sizeof (uiInitOptions));
+	for (i = 1; i < argc; i++)
+		if (strcmp(argv[i], "leaks") == 0)
+			o.debugLogAllocations = 1;
+		else {
+			fprintf(stderr, "%s: unrecognized option %s\n", argv[0], argv[i]);
+			return 1;
+		}
+
+	err = uiInit(&o);
+	if (err != NULL) {
+		fprintf(stderr, "error initializing ui: %s\n", err);
+		uiFreeInitError(err);
+		return 1;
+	}
+
+	w = newWindow("Main Window", 320, 240, 1);
+	uiWindowOnClosing(w, onClosing, NULL);
+
+	uiWindowShow(w);
+	uiMain();
+	printf("after uiMain()\n");
 	return 0;
 }

new/test/spaced.c

@@ -49,7 +49,14 @@ void setSpaced(int spaced)
 	}
 }
 
-// TODO newWindow()
+uiWindow *newWindow(const char *title, int width, int height, int hasMenubar)
+{
+	uiWindow *w;
+
+	w = uiNewWindow(title, width, height, hasMenubar);
+	append(w, window);
+	return w;
+}
 
 uiBox *newHorizontalBox(void)
 {

new/test/test.h

@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdarg.h>
+#include <string.h>
 #include "../ui.h"
 
 // main.c
@@ -10,5 +11,6 @@ extern void die(const char *, ...);
 
 // spaced.c
 extern void setSpaced(int);
+extern uiWindow *newWindow(const char *title, int width, int height, int hasMenubar);
 extern uiBox *newHorizontalBox(void);
 extern uiBox *newVerticalBox(void);

new/unix/GNUmakeinc.mk

@@ -4,7 +4,8 @@ osCFILES = \
 	unix/alloc.c \
 	unix/main.c \
 	unix/oscontainer.c \
-	unix/util.c
+	unix/util.c \
+	unix/window.c
 
 osHFILES = \
 	unix/uipriv_unix.h

new/unix/oscontainer.c

@@ -199,7 +199,7 @@ static void parentUpdate(uiOSContainer *cc)
 	gtk_widget_queue_resize(GTK_WIDGET(c));
 }
 
-uiOSContainer *uiNewParent(uintptr_t osParent)
+uiOSContainer *uiNewOSContainer(uintptr_t osParent)
 {
 	uiOSContainer *c;
 

new/unix/uipriv_unix.h

@@ -7,3 +7,6 @@
 #include "../ui.h"
 #include "../ui_unix.h"
 #include "../uipriv.h"
+
+#define gtkXMargin 12
+#define gtkYMargin 12

new/unix/window.c

@@ -0,0 +1,170 @@
+// 6 april 2015
+#include "uipriv_unix.h"
+
+struct window {
+	uiWindow w;
+	GtkWidget *widget;
+	GtkContainer *container;
+	GtkWindow *window;
+	uiOSContainer *content;
+	int (*onClosing)(uiWindow *, void *);
+	void *onClosingData;
+	int margined;
+	gulong destroyBlocker;
+};
+
+static gboolean onClosing(GtkWidget *win, GdkEvent *e, gpointer data)
+{
+	struct window *w = (struct window *) data;
+
+	// manually destroy the window ourselves; don't let the delete-event handler do it
+	if ((*(w->onClosing))(uiWindow(w), w->onClosingData))
+		uiWindowDestroy(uiWindow(w));
+	return TRUE;		// don't continue to the default delete-event handler; we destroyed the window by now
+}
+
+static int defaultOnClosing(uiWindow *w, void *data)
+{
+	return 1;
+}
+
+// TODO should we change the GtkWindow's child first?
+static void windowDestroy(uiWindow *ww)
+{
+	struct window *w = (struct window *) ww;
+
+	// first, hide the window to prevent our cleanup from being noticed
+	gtk_widget_hide(w->widget);
+	// next, remove the uiOSContainer from the GtkWindow so the GtkWindow can release its reference on the uiOSContainer
+	gtk_container_remove(w->container, GTK_WIDGET(uiOSContainerHandle(w->content)));
+	// next, destroy the content uiOSContainer
+	// this will destroy any children
+	uiOSContainerDestroy(w->content);
+	// now that we cleaned up properly, we can mark our window as ready to be destroyed
+//TODO	g_signal_handler_disconnect(w->widget, w->destroyBlocker);
+	// finally, destroy the window
+	gtk_widget_destroy(w->widget);
+	// and free ourselves
+	uiFree(w);
+}
+
+static uintptr_t windowHandle(uiWindow *ww)
+{
+	struct window *w = (struct window *) ww;
+
+	return (uintptr_t) (w->widget);
+}
+
+static char *windowTitle(uiWindow *ww)
+{
+	struct window *w = (struct window *) ww;
+
+	return g_strdup(gtk_window_get_title(w->window));
+}
+
+static void windowSetTitle(uiWindow *ww, const char *title)
+{
+	struct window *w = (struct window *) ww;
+
+	gtk_window_set_title(w->window, title);
+}
+
+static void windowShow(uiWindow *ww)
+{
+	struct window *w = (struct window *) ww;
+
+	// don't use gtk_widget_show_all(); that will override user hidden settings
+	gtk_widget_show(w->widget);
+}
+
+static void windowHide(uiWindow *ww)
+{
+	struct window *w = (struct window *) ww;
+	gtk_widget_hide(w->widget);
+}
+
+static void windowOnClosing(uiWindow *ww, int (*f)(uiWindow *, void *), void *data)
+{
+	struct window *w = (struct window *) ww;
+
+	w->onClosing = f;
+	w->onClosingData = data;
+}
+
+static void windowSetChild(uiWindow *ww, uiControl *c)
+{
+	struct window *w = (struct window *) ww;
+
+	uiOSContainerSetMainControl(w->content, c);
+	uiOSContainerUpdate(w->content);
+}
+
+static int windowMargined(uiWindow *ww)
+{
+	struct window *w = (struct window *) ww;
+
+	return w->margined;
+}
+
+static void windowSetMargined(uiWindow *ww, int margined)
+{
+	struct window *w = (struct window *) ww;
+
+	w->margined = margined;
+	if (w->margined)
+		uiOSContainerSetMargins(w->content, gtkXMargin, gtkYMargin, gtkXMargin, gtkYMargin);
+	else
+		uiOSContainerSetMargins(w->content, 0, 0, 0, 0);
+	uiOSContainerUpdate(w->content);
+}
+
+uiWindow *uiNewWindow(const char *title, int width, int height, int hasMenubar)
+{
+	struct window *w;
+	GtkWidget *vbox;
+	GtkWidget *contentWidget;
+
+	w = uiNew(struct window);
+
+	w->widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+	w->container = GTK_CONTAINER(w->widget);
+	w->window = GTK_WINDOW(w->widget);
+
+	gtk_window_set_title(w->window, title);
+	// TODO this does not take menus or CSD into account
+	gtk_window_resize(w->window, width, height);
+
+	g_signal_connect(w->widget, "delete-event", G_CALLBACK(onClosing), w);
+//TODO	w->destroyBlocker = g_signal_connect(w->widget, "destroy", G_CALLBACK(destroyBlocker), w);
+
+	if (hasMenubar) {
+		vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+		gtk_widget_show_all(vbox);
+		gtk_container_add(w->container, vbox);
+
+//TODO		gtk_container_add(GTK_CONTAINER(vbox), makeMenubar());
+
+		w->content = uiNewOSContainer((uintptr_t) GTK_CONTAINER(vbox));
+		contentWidget = GTK_WIDGET(uiOSContainerHandle(w->content));
+		gtk_widget_set_hexpand(contentWidget, TRUE);
+		gtk_widget_set_halign(contentWidget, GTK_ALIGN_FILL);
+		gtk_widget_set_vexpand(contentWidget, TRUE);
+		gtk_widget_set_valign(contentWidget, GTK_ALIGN_FILL);
+	} else
+		w->content = uiNewOSContainer((uintptr_t) (w->container));
+
+	w->onClosing = defaultOnClosing;
+
+	uiWindow(w)->Destroy = windowDestroy;
+	uiWindow(w)->Handle = windowHandle;
+	uiWindow(w)->Title = windowTitle;
+	uiWindow(w)->SetTitle = windowSetTitle;
+	uiWindow(w)->Show = windowShow;
+	uiWindow(w)->Hide = windowHide;
+	uiWindow(w)->OnClosing = windowOnClosing;
+	uiWindow(w)->SetChild = windowSetChild;
+	uiWindow(w)->Margined = windowMargined;
+	uiWindow(w)->SetMargined = windowSetMargined;
+
+	return uiWindow(w);
+}