backup nonfunction opengl 4 code in another branch

.gitignore

@@ -4,8 +4,8 @@
 examples/*
 examples/*.exe
 examples/*/*
-examples/*/*.exe
-!examples/*/
-!examples/*.*
-!examples/*/*.*
+!examples/*/*.c
+!examples/*/*.spv
 compile_flags.txt
+*.a
+Makefile

examples/basic/rotate.c

@@ -56,13 +56,13 @@ void resize(MwWidget w, void* user, void* client) {
 
 int main() {
 	MwWidget window;
-	int i;
+	int	 i;
 
 	MwLibraryInit();
 
 	window = MwVaCreateWidget(MwWindowClass, "window", NULL, MwDEFAULT, MwDEFAULT, (ww = 500), (wh = 500),
-					   MwNtitle, "rotate",
-					   NULL);
+				  MwNtitle, "rotate",
+				  NULL);
 
 	for(i = 0; i < (int)(sizeof(buttons) / sizeof(buttons[0])); i++) {
 		const char* color = "";

include/Mw/Core.h

@@ -128,7 +128,7 @@ MWDECL void MwLoop(MwWidget handle);
  */
 MWDECL int MwStep(MwWidget handle);
 
-/*!
+/*!MwStep(
  * @brief Check if any event is pending
  * @param handle Widget
  * @return `1` if any event is pending

include/Mw/LowLevel.h

@@ -26,13 +26,15 @@ typedef void* MwLLPixmap;
 
 enum MwLLBackends {
 	MwLLBackendX11 = 0,
-	MwLLBackendGDI
+	MwLLBackendGDI,
+	MwLLBackendWayland,
 };
 
 struct _MwLLCommon {
 	void* user;
 	int   copy_buffer;
 	int   type;
+	int   success;
 
 	MwLLHandler handler;
 };
@@ -56,6 +58,9 @@ struct _MwLLCommonPixmap {
 #ifdef USE_GDI
 #include <Mw/LowLevel/GDI.h>
 #endif
+#ifdef USE_WAYLAND
+#include <Mw/LowLevel/Wayland.h>
+#endif
 
 union _MwLL {
 	struct _MwLLCommon common;
@@ -65,6 +70,9 @@ union _MwLL {
 #ifdef USE_GDI
 	struct _MwLLGDI gdi;
 #endif
+#ifdef USE_WAYLAND
+	struct _MwLLWayland wayland;
+#endif
 };
 
 union _MwLLColor {
@@ -75,6 +83,9 @@ union _MwLLColor {
 #ifdef USE_GDI
 	struct _MwLLGDIColor gdi;
 #endif
+#ifdef USE_WAYLAND
+	struct _MwLLWaylandColor wayland;
+#endif
 };
 
 union _MwLLPixmap {
@@ -85,6 +96,9 @@ union _MwLLPixmap {
 #ifdef USE_GDI
 	struct _MwLLGDIPixmap gdi;
 #endif
+#ifdef USE_WAYLAND
+	struct _MwLLWaylandPixmap wayland;
+#endif
 };
 #endif
 #include <Mw/TypeDefs.h>
@@ -184,8 +198,6 @@ MWDECL void (*MwLLMakePopup)(MwLL handle, MwLL parent);
 MWDECL void (*MwLLBeginStateChange)(MwLL handle);
 MWDECL void (*MwLLEndStateChange)(MwLL handle);
 
-MWDECL void (*MwLLSetBackground)(MwLL handle, MwLLColor color);
-
 MWDECL void (*MwLLFocus)(MwLL handle);
 MWDECL void (*MwLLGrabPointer)(MwLL handle, int toggle);
 

include/Mw/LowLevel/Wayland.h

@@ -0,0 +1,111 @@
+/* $Id$ */
+/*!
+ * @file Mw/LowLevel/Wayland.h
+ * @brief Wayland Backend
+ * @warning This is used internally
+ */
+#ifndef __MW_LOWLEVEL_WAYLAND_H__
+#define __MW_LOWLEVEL_WAYLAND_H__
+
+#include "Mw/BaseTypes.h"
+#include <Mw/MachDep.h>
+#include <Mw/TypeDefs.h>
+#include <Mw/LowLevel.h>
+
+#include <wayland-egl.h>
+#include <EGL/egl.h>
+#include <GL/gl.h>
+#include <GL/glext.h>
+
+#include <wayland-client.h>
+#include <xkbcommon/xkbcommon.h>
+
+MWDECL int MwLLWaylandCallInit(void);
+
+#ifndef WL_PROTOCOLS_DEFINED
+#define WL_PROTOCOLS_DEFINED
+#include "Wayland/xdg-shell-client-protocol.h"
+#include "Wayland/xdg-decoration-client-protocol.h"
+#include "Wayland/cursor-shape-client-protocol.h"
+#endif
+
+typedef struct wayland_protocol {
+	void* listener;
+	void* context;
+} wayland_protocol_t;
+
+typedef wayland_protocol_t*(wl_setup_func)(MwU32, struct _MwLLWayland*);
+
+struct _MwLLWaylandTopLevel {
+	struct xdg_surface*	     xdg_surface;
+	struct xdg_toplevel*	     xdg_top_level;
+	struct xdg_toplevel_listener xdg_toplevel_listener;
+	struct xdg_surface_listener  xdg_surface_listener;
+
+	struct xkb_context* xkb_context;
+
+	MwBool running;
+	MwBool compositor_created;
+	MwBool xdg_wm_base_created;
+	MwBool xdg_surface_created;
+};
+
+struct _MwLLWayland {
+	struct _MwLLCommon common;
+	union {
+		struct _MwLLWaylandTopLevel* toplevel;
+		struct wl_subsurface*	     subsurface;
+	};
+	enum {
+		MWLL_WAYLAND_TOPLEVEL	= 0,
+		MWLL_WAYLAND_SUBSURFACE = 1,
+	} type;
+
+	struct {
+		const char*    key;
+		wl_setup_func* value;
+	}* wl_protocol_setup_map;
+
+	struct {
+		const char*	    key;
+		wayland_protocol_t* value;
+	}* wl_protocol_map;
+
+	struct wl_display*	    display;
+	struct wl_registry*	    registry;
+	struct wl_compositor*	    compositor;
+	struct wl_subcompositor*    subcompositor;
+	struct wl_surface*	    surface;
+	struct wl_shm*		    shm;
+	struct wl_registry_listener registry_listener;
+
+	MwBool configured;
+	MwBool force_redraw;
+	MwBool do_clear;
+	MwU32  x, y, ww, wh;
+	int    z_index;
+
+	MwLL parent;
+
+	GLuint	     fbo;
+	unsigned int fbo_texture;
+	unsigned int rbo;
+
+	MwBool		    egl_setup;
+	EGLNativeWindowType egl_window_native;
+	EGLDisplay	    egl_display;
+	EGLContext	    egl_context;
+	EGLSurface	    egl_surface;
+	GLuint		    vertex_buffer;
+	GLuint		    vertex_array;
+};
+
+struct _MwLLWaylandColor {
+	struct _MwLLCommonColor common;
+};
+
+struct _MwLLWaylandPixmap {
+	struct _MwLLCommonPixmap common;
+};
+
+#endif

include/Mw/LowLevel/Wayland/.gitignore

@@ -0,0 +1 @@
+*protocol.h

include/Mw/LowLevel/Wayland/README.md

@@ -0,0 +1 @@
+Folder for wayland-scanner to place any of its files.

pl/ostype/Linux.pl

@@ -1,4 +1,9 @@
 # $Id$
-use_backend("x11");
+
+if(system("wayland-scanner -v >/dev/null 2>&1") == 0){
+    use_backend("wayland", "x11");
+} else {
+    use_backend("x11");
+}
 
 1;

pl/rules.pl

@@ -27,6 +27,19 @@ if (grep(/^gdi$/, @backends)) {
     $gl_libs = "-lopengl32 -lglu32";
 }
 
+if (grep(/^wayland$/, @backends)) {
+    add_cflags("-DUSE_WAYLAND");
+    new_object("src/backend/wayland.c");
+    add_libs("-lGL -lEGL -lwayland-egl -lwayland-client -lxkbcommon");
+
+    scan_wayland_protocol("stable", "xdg-shell","");
+    scan_wayland_protocol("stable", "tablet","-v2");
+    scan_wayland_protocol("staging", "cursor-shape","-v1");
+    scan_wayland_protocol("unstable", "xdg-decoration","-unstable-v1");
+
+    $gl_libs = "-lGL -lGLU";
+}
+
 if (param_get("stb-image")) {
     add_cflags("-DUSE_STB_IMAGE");
 }

pl/utils.pl

@@ -55,6 +55,23 @@ sub use_backend {
     }
 }
 
+sub scan_wayland_protocol {
+    my $tier = $_[0];
+    my $proto = $_[1];
+    my $ver = $_[2];
+
+    my $proto_c = "src/backend/wayland-${proto}-protocol.c";
+
+    if(system("wayland-scanner private-code /usr/share/wayland-protocols/${tier}/${proto}/${proto}${ver}.xml ${proto_c}") != 0) {
+      print("^ Error on getting private code for /usr/share/wayland-protocols/${tier}/${proto}/${proto}${ver}.xml\n");
+    } else {
+        new_object($proto_c);
+    };
+    if(system("wayland-scanner client-header /usr/share/wayland-protocols/${tier}/${proto}/${proto}${ver}.xml include/Mw/LowLevel/Wayland/${proto}-client-protocol.h")) {
+      print("^ Error on getting client header for /usr/share/wayland-protocols/${tier}/${proto}/${proto}${ver}.xml\n");
+    };
+}
+
 our %params = ();
 
 sub param_set {

src/backend/.gitignore

@@ -0,0 +1 @@
+wayland*protocol.c

src/backend/call.c

@@ -44,8 +44,6 @@
 \
 		MwLLBeginStateChange = MwLLBeginStateChangeImpl; \
 		MwLLEndStateChange   = MwLLEndStateChangeImpl; \
-\
-		MwLLSetBackground = MwLLSetBackgroundImpl; \
 \
 		MwLLFocus	= MwLLFocusImpl; \
 		MwLLGrabPointer = MwLLGrabPointerImpl; \

src/backend/gdi.c

@@ -342,11 +342,6 @@ static void MwLLFreeColorImpl(MwLLColor color) {
 	free(color);
 }
 
-static void MwLLSetBackgroundImpl(MwLL handle, MwLLColor color) {
-	(void)handle;
-	(void)color;
-}
-
 static void MwLLGetXYWHImpl(MwLL handle, int* x, int* y, unsigned int* w, unsigned int* h) {
 	RECT rc;
 

src/backend/wayland.c

@@ -0,0 +1,912 @@
+/* $Id$ */
+
+#include <Mw/Milsko.h>
+
+#include <EGL/egl.h>
+#include <GL/gl.h>
+#include <GL/glext.h>
+
+#include <assert.h>
+#include <cairo/cairo.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wayland-client-protocol.h>
+
+#include "../../external/stb_ds.h"
+#include "Mw/BaseTypes.h"
+#include "Mw/LowLevel.h"
+
+#include <sys/mman.h>
+#include <wayland-egl-core.h>
+#include <wayland-util.h>
+
+PFNGLGENFRAMEBUFFERSPROC	   glGenFramebuffers;
+PFNGLFRAMEBUFFERTEXTURE2DPROC	   glFramebufferTexture2D;
+PFNGLGENRENDERBUFFERSPROC	   glGenRenderbuffers;
+PFNGLFRAMEBUFFERRENDERBUFFERPROC   glFramebufferRenderbuffer;
+PFNGLBINDRENDERBUFFERPROC	   glBindRenderbuffer;
+PFNGLBINDFRAMEBUFFERPROC	   glBindFramebuffer;
+PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatus;
+PFNGLCREATEBUFFERSPROC		   glCreateBuffers;
+PFNGLBINDBUFFERPROC		   glBindBuffer;
+PFNGLBUFFERDATAPROC		   glBufferData;
+PFNGLBUFFERSUBDATAPROC		   glBufferSubData;
+PFNGLBINDVERTEXARRAYPROC	   glBindVertexArray;
+PFNGLGENVERTEXARRAYSPROC	   glGenVertexArrays;
+PFNGLVERTEXARRAYVERTEXBUFFERPROC   glVertexArrayVertexBuffer;
+PFNGLVERTEXARRAYATTRIBFORMATPROC   glVertexArrayAttribFormat;
+PFNGLVERTEXARRAYATTRIBBINDINGPROC  glVertexArrayAttribBinding;
+PFNGLENABLEVERTEXARRAYATTRIBPROC   glEnableVertexArrayAttrib;
+PFNGLVERTEXATTRIBPOINTERPROC	   glVertexAttribPointer;
+PFNGLENABLEVERTEXATTRIBARRAYPROC   glEnableVertexAttribArray;
+PFNGLCREATEPROGRAMPROC		   glCreateProgram;
+PFNGLATTACHSHADERPROC		   glAttachShader;
+PFNGLLINKPROGRAMPROC		   glLinkProgram;
+PFNGLCREATESHADERPROC		   glCreateShader;
+PFNGLSHADERSOURCEPROC		   glShaderSource;
+PFNGLCOMPILESHADERPROC		   glCompileShader;
+
+#define WAYLAND_GET_INTERFACE(r, inter) shget(r.wl_protocol_map, inter##_interface.name)
+
+static void new_protocol(void* data, struct wl_registry* registry,
+			 MwU32 name, const char* interface,
+			 MwU32 version) {
+	struct _MwLLWayland* wayland = data;
+
+	wl_setup_func* func = shget(wayland->wl_protocol_setup_map, interface);
+	if(func != NULL) {
+		// printf("registering interface %s\n", interface);
+		shput(wayland->wl_protocol_map, interface, func(name, data));
+	} else {
+		// printf("unknown interface %s\n", interface);
+	}
+};
+
+static void protocol_removed(void*		 data,
+			     struct wl_registry* registry,
+			     MwU32		 name) {
+
+};
+
+static void wl_seat_name(void* data, struct wl_seat* wl_seat, const char* name) {};
+static void wl_seat_capabilities(void* data, struct wl_seat* wl_seat,
+				 MwU32 capabilities) {};
+
+void xdg_wm_base_ping(void*		  data,
+		      struct xdg_wm_base* xdg_wm_base,
+		      MwU32		  serial) {
+	// The compositor will send us a ping event to check that we're responsive.
+	// We need to send back a pong request immediately.
+	xdg_wm_base_pong(xdg_wm_base, serial);
+};
+
+static wayland_protocol_t* wl_shm_setup(MwU32 name, struct _MwLLWayland* wayland) {
+	wayland->shm = wl_registry_bind(wayland->registry, name, &wl_shm_interface, 1);
+	return NULL;
+}
+// static void buffer_setup(struct _MwLLWayland* wayland) {
+// }
+
+static wayland_protocol_t* wl_seat_setup(MwU32 name, struct _MwLLWayland* wayland) {
+	wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
+	proto->listener		  = malloc(sizeof(struct wl_seat_listener));
+
+	((struct wl_seat_listener*)proto->listener)->name	  = wl_seat_name;
+	((struct wl_seat_listener*)proto->listener)->capabilities = wl_seat_capabilities;
+
+	proto->context = wl_registry_bind(wayland->registry, name, &wl_seat_interface, 1);
+	wl_seat_add_listener(proto->context, proto->listener, wayland);
+
+	return proto;
+}
+
+static wayland_protocol_t* wl_compositor_setup(MwU32 name, struct _MwLLWayland* wayland) {
+	wayland->compositor = wl_registry_bind(wayland->registry, name, &wl_compositor_interface, 1);
+
+	return NULL;
+}
+
+static wayland_protocol_t* wl_subcompositor_setup(MwU32 name, struct _MwLLWayland* wayland) {
+	wayland->subcompositor = wl_registry_bind(wayland->registry, name, &wl_subcompositor_interface, 1);
+
+	return NULL;
+}
+
+static wayland_protocol_t* xdg_wm_base_setup(MwU32 name, struct _MwLLWayland* wayland) {
+	wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
+	proto->listener		  = malloc(sizeof(struct xdg_wm_base_listener));
+
+	((struct xdg_wm_base_listener*)proto->listener)->ping = xdg_wm_base_ping;
+
+	proto->context = wl_registry_bind(wayland->registry, name, &xdg_wm_base_interface, 1);
+	xdg_wm_base_add_listener(proto->context, proto->listener, wayland);
+
+	return proto;
+}
+
+static wayland_protocol_t* wp_cursor_shape_manager_v1_setup(MwU32 name, struct _MwLLWayland* wayland) {
+	wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
+	proto->listener		  = NULL;
+
+	proto->context = wl_registry_bind(wayland->registry, name, &wp_cursor_shape_manager_v1_interface, 1);
+
+	return proto;
+}
+
+typedef struct zxdg_decoration_manager_v1_context {
+	struct zxdg_decoration_manager_v1* manager;
+	// struct zxdg_decoration_toplevel_v1* toplevel;
+	struct zxdg_toplevel_decoration_v1* decoration;
+} zxdg_decoration_manager_v1_context_t;
+
+static wayland_protocol_t* zxdg_decoration_manager_v1_setup(MwU32 name, struct _MwLLWayland* wayland) {
+	wayland_protocol_t*		      proto = malloc(sizeof(wayland_protocol_t));
+	zxdg_decoration_manager_v1_context_t* ctx   = malloc(sizeof(zxdg_decoration_manager_v1_context_t));
+	proto->listener				    = NULL;
+
+	ctx->manager = wl_registry_bind(wayland->registry, name, &zxdg_decoration_manager_v1_interface, 1);
+	;
+
+	proto->context = ctx;
+
+	return proto;
+}
+
+static MwBool egl_setup(MwLL self, int width, int height) {
+	int	   err;
+	EGLint	   numConfigs;
+	EGLint	   majorVersion;
+	EGLint	   minorVersion;
+	EGLContext context;
+	EGLSurface surface;
+	EGLConfig  config;
+	EGLint	   fbAttribs[] =
+	    {
+		EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+		EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+		EGL_RED_SIZE, 8,
+		EGL_GREEN_SIZE, 8,
+		EGL_BLUE_SIZE, 8,
+		EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
+		EGL_NONE};
+	EGLint contextAttribs[] = {
+	    EGL_CONTEXT_MAJOR_VERSION, 4,
+	    EGL_CONTEXT_MINOR_VERSION, 1,
+	    EGL_NONE};
+	GLuint	    vs, fs;
+	const char* vertex_shader =
+	    "#version 410 core\n"
+	    "in vec3 vp;"
+	    "void main() {"
+	    "  gl_Position = vec4( vp, 1.0 );"
+	    "}";
+	const char* fragment_shader =
+	    "#version 410 core\n"
+	    "out vec4 frag_colour;"
+	    "void main() {"
+	    "  frag_colour = vec4( 0.5, 0.0, 0.5, 1.0 );"
+	    "}";
+
+	EGLDisplay display = eglGetDisplay(self->wayland.display);
+	if(display == EGL_NO_DISPLAY) {
+		printf("ERROR: eglGetDisplay, %0X\n", eglGetError());
+		return MwFALSE;
+	}
+
+	// Initialize EGL
+	if(!eglInitialize(display, &majorVersion, &minorVersion)) {
+		printf("ERROR: eglInitialize, %0X\n", eglGetError());
+		return MwFALSE;
+	}
+
+	// Get configs
+	if((eglGetConfigs(display, NULL, 0, &numConfigs) != EGL_TRUE) || (numConfigs == 0)) {
+		printf("ERROR: eglGetConfigs, %0X\n", eglGetError());
+		return MwFALSE;
+	}
+
+	// Choose config
+	if((eglChooseConfig(display, fbAttribs, &config, 1, &numConfigs) != EGL_TRUE) || (numConfigs != 1)) {
+		printf("ERROR: eglChooseConfig, %0X\n", eglGetError());
+		return MwFALSE;
+	}
+
+	self->wayland.egl_window_native =
+	    wl_egl_window_create(self->wayland.surface, width, height);
+	if(self->wayland.egl_window_native == EGL_NO_SURFACE) {
+		printf("ERROR: wl_egl_window_create, EGL_NO_SURFACE\n");
+		return MwFALSE;
+	}
+
+	// Create a surface
+	surface = eglCreateWindowSurface(display, config, self->wayland.egl_window_native, NULL);
+	if(surface == EGL_NO_SURFACE) {
+		printf("ERROR: eglCreateWindowSurface, %0X\n", eglGetError());
+		return MwFALSE;
+	}
+
+	eglBindAPI(EGL_OPENGL_API);
+
+	// Create a GL context
+	context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs);
+	if(context == EGL_NO_CONTEXT) {
+		printf("ERROR: eglCreateContext, %0X\n", eglGetError());
+		return MwFALSE;
+	}
+
+	// Make the context current
+	if(!eglMakeCurrent(display, surface, surface, context)) {
+		printf("ERROR: eglMakeCurrent, %0X\n", eglGetError());
+		return MwFALSE;
+	}
+
+	glGenFramebuffers      = (PFNGLGENFRAMEBUFFERSPROC)eglGetProcAddress("glGenFramebuffers");
+	glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)eglGetProcAddress("glFramebufferTexture2D");
+	glGenRenderbuffers     = (PFNGLGENRENDERBUFFERSPROC)eglGetProcAddress("glGenRenderbuffers");
+	// glRenderbufferStorage	  = (PFNGLRENDERBUFFERSTORAGEPROC)eglGetProcAddress("glRenderbufferStorage");
+	glFramebufferRenderbuffer  = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)eglGetProcAddress("glFramebufferRenderbuffer");
+	glBindRenderbuffer	   = (PFNGLBINDRENDERBUFFERPROC)eglGetProcAddress("glBindRenderbuffer");
+	glBindFramebuffer	   = (PFNGLBINDFRAMEBUFFERPROC)eglGetProcAddress("glBindFramebuffer");
+	glCheckFramebufferStatus   = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)eglGetProcAddress("glCheckFramebufferStatus");
+	glCreateBuffers		   = (PFNGLCREATEBUFFERSPROC)eglGetProcAddress("glCreateBuffers");
+	glBindBuffer		   = (PFNGLBINDBUFFERPROC)eglGetProcAddress("glBindBuffer");
+	glBufferData		   = (PFNGLBUFFERDATAPROC)eglGetProcAddress("glBufferData");
+	glBufferSubData		   = (PFNGLBUFFERSUBDATAPROC)eglGetProcAddress("glBufferSubData");
+	glBindVertexArray	   = (PFNGLBINDVERTEXARRAYPROC)eglGetProcAddress("glBindVertexArray");
+	glGenVertexArrays	   = (PFNGLGENVERTEXARRAYSPROC)eglGetProcAddress("glGenVertexArrays");
+	glVertexArrayVertexBuffer  = (PFNGLVERTEXARRAYVERTEXBUFFERPROC)eglGetProcAddress("glVertexArrayVertexBuffer");
+	glVertexArrayAttribFormat  = (PFNGLVERTEXARRAYATTRIBFORMATPROC)eglGetProcAddress("glVertexArrayAttribFormat");
+	glVertexArrayAttribBinding = (PFNGLVERTEXARRAYATTRIBBINDINGPROC)eglGetProcAddress("glVertexArrayAttribBinding");
+	glEnableVertexArrayAttrib  = (PFNGLENABLEVERTEXARRAYATTRIBPROC)eglGetProcAddress("glEnableVertexArrayAttrib");
+	glVertexAttribPointer	   = (PFNGLVERTEXATTRIBPOINTERPROC)eglGetProcAddress("glVertexAttribPointer");
+	glEnableVertexAttribArray  = (PFNGLENABLEVERTEXATTRIBARRAYPROC)eglGetProcAddress("glEnableVertexAttribArray");
+	glCreateProgram		   = (PFNGLCREATEPROGRAMPROC)eglGetProcAddress("glCreateProgram");
+	glAttachShader		   = (PFNGLATTACHSHADERPROC)eglGetProcAddress("glAttachShader");
+	glLinkProgram		   = (PFNGLLINKPROGRAMPROC)eglGetProcAddress("glLinkProgram");
+
+	glCreateShader	= (PFNGLCREATESHADERPROC)eglGetProcAddress("glCreateShader");
+	glShaderSource	= (PFNGLSHADERSOURCEPROC)eglGetProcAddress("glShaderSource");
+	glCompileShader = (PFNGLCOMPILESHADERPROC)eglGetProcAddress("glCompileShader");
+
+	glGenTextures(1, &self->wayland.fbo_texture);
+	glBindTexture(GL_TEXTURE_2D, self->wayland.fbo_texture);
+
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+
+	glBindTexture(GL_TEXTURE_2D, 0);
+
+	glGenRenderbuffers(1, &self->wayland.rbo);
+	// glBindRenderbuffer(GL_RENDERBUFFER, self->wayland.rbo));
+	// glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 768, 1024);
+	// glBindRenderbuffer(GL_RENDERBUFFER, 0);
+
+	glGenFramebuffers(1, &self->wayland.fbo);
+	glBindFramebuffer(GL_FRAMEBUFFER_BINDING, self->wayland.fbo);
+
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->wayland.fbo_texture, 0);
+
+	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, self->wayland.rbo);
+
+	if((err = glCheckFramebufferStatus(GL_FRAMEBUFFER)) != GL_FRAMEBUFFER_COMPLETE) {
+		printf("Error binding framebuffer: %0X\n", err);
+		return MwFALSE;
+	}
+
+	glBindFramebuffer(GL_FRAMEBUFFER_BINDING, 0);
+
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	glOrtho(0, width, height, 0, -1, 1);
+
+	self->wayland.egl_display = display;
+	self->wayland.egl_surface = surface;
+	self->wayland.egl_context = context;
+
+	vs = glCreateShader(GL_VERTEX_SHADER);
+	glShaderSource(vs, 1, &vertex_shader, NULL);
+	glCompileShader(vs);
+	fs = glCreateShader(GL_FRAGMENT_SHADER);
+	glShaderSource(fs, 1, &fragment_shader, NULL);
+	glCompileShader(fs);
+
+	GLuint shader_program = glCreateProgram();
+	glAttachShader(shader_program, fs);
+	glAttachShader(shader_program, vs);
+	glLinkProgram(shader_program);
+
+	printf("EGL success\n");
+	return MwTRUE;
+}
+
+static void egl_vbo_setup(MwLL self) {
+	glCreateBuffers(1, &self->wayland.vertex_buffer);
+	glGenVertexArrays(1, &self->wayland.vertex_array);
+	glBindBuffer(GL_ARRAY_BUFFER, self->wayland.vertex_buffer);
+
+	glVertexAttribPointer(self->wayland.z_index, 2, GL_INT, GL_FALSE, 0, 0);
+	glEnableVertexAttribArray(self->wayland.z_index);
+}
+
+static void xdg_toplevel_configure(void*		data,
+				   struct xdg_toplevel* xdg_toplevel,
+				   MwI32 width, MwI32 height,
+				   struct wl_array* states) {
+	MwLL			      self		     = data;
+	PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)eglGetProcAddress("glFramebufferTexture2D");
+
+	if(width == 0 && height == 0) {
+		width  = self->wayland.ww;
+		height = self->wayland.wh;
+	}
+	self->wayland.ww = width;
+	self->wayland.wh = height;
+	xdg_surface_set_window_geometry(self->wayland.toplevel->xdg_surface, self->wayland.x, self->wayland.y, self->wayland.ww, self->wayland.wh);
+
+	MwLLSetWH(self, width, height);
+	MwLLDispatch(self, resize, NULL);
+
+	if(!self->wayland.egl_setup) {
+		self->wayland.egl_setup = egl_setup(self, width, height);
+		egl_vbo_setup(self);
+		MwLLForceRender(self);
+	} else {
+		wl_egl_window_resize(self->wayland.egl_window_native, width, height, 0, 0);
+		glMatrixMode(GL_PROJECTION);
+		glLoadIdentity();
+		glOrtho(0, width, height, 0, -1, 1);
+		self->wayland.do_clear = MwTRUE;
+	}
+
+	return;
+};
+
+static void decoration_configure(
+    void* data, struct zxdg_toplevel_decoration_v1* zxdg_toplevel_decoration_v1,
+    MwU32 mode) {
+}
+
+static void xdg_toplevel_close(
+    void* data, struct xdg_toplevel* xdg_toplevel) {
+	MwLL self = data;
+
+	// Stop running if the user requests to close the toplevel
+	self->wayland.toplevel->running = MwFALSE;
+};
+
+static void xdg_surface_configure(
+    void* data, struct xdg_surface* xdg_surface, MwU32 serial) {
+	MwLL self = data;
+
+	// The compositor configures our surface, acknowledge the configure event
+	xdg_surface_ack_configure(xdg_surface, serial);
+
+	if(self->wayland.configured) {
+		// If this isn't the first configure event we've received, we already
+		// have a buffer attached, so no need to do anything. Commit the
+		// surface to apply the configure acknowledgement.
+		// wl_surface_attach(self->surface, self->buffer, 0, 0);
+		wl_surface_commit(self->wayland.surface);
+	}
+
+	self->wayland.configured = MwTRUE;
+}
+
+#define WL_INTERFACE(interface) \
+	shput(wayland->wl_protocol_setup_map, interface##_interface.name, (wl_setup_func*)interface##_setup);
+
+static void setup_callbacks(struct _MwLLWayland* wayland) {
+	wayland->registry_listener.global	 = new_protocol;
+	wayland->registry_listener.global_remove = protocol_removed;
+	wayland->wl_protocol_setup_map		 = NULL;
+	wayland->wl_protocol_map		 = NULL;
+
+	WL_INTERFACE(wl_shm);
+	WL_INTERFACE(wl_compositor);
+	WL_INTERFACE(wl_subcompositor);
+	if(wayland->type == MWLL_WAYLAND_TOPLEVEL) {
+		WL_INTERFACE(wl_seat);
+		WL_INTERFACE(xdg_wm_base);
+		WL_INTERFACE(zxdg_decoration_manager_v1);
+		WL_INTERFACE(wp_cursor_shape_manager_v1);
+	}
+}
+
+#undef WL_INTERFACE
+
+static MwBool flush_display(struct wl_display* display) {
+	while(wl_display_flush(display) == -1) {
+		if(errno != EAGAIN) {
+			return MwFALSE;
+		}
+
+		struct pollfd fd = {wl_display_get_fd(display), POLL_OUT};
+
+		while(poll(&fd, 1, -1) == -1) {
+			if(errno != EINTR && errno != EAGAIN)
+				return MwFALSE;
+		}
+	}
+	return MwTRUE;
+}
+
+static void setup_toplevel(MwLL r, int x, int y, int width, int height) {
+	r->wayland.type	    = MWLL_WAYLAND_TOPLEVEL;
+	r->wayland.toplevel = malloc(sizeof(struct _MwLLWaylandTopLevel));
+
+	setup_callbacks(&r->wayland);
+
+	// Connect to the Wayland compositor
+	r->wayland.display = wl_display_connect(NULL);
+	if(r->wayland.display == NULL) {
+		printf("wayland: failed to create display\n");
+		r->common.success = MwFALSE;
+		return;
+	}
+
+	// Do a roundtrip to ensure all interfaces are setup.
+	r->wayland.registry = wl_display_get_registry(r->wayland.display);
+	wl_registry_add_listener(r->wayland.registry, &r->wayland.registry_listener, r);
+	if(wl_display_roundtrip(r->wayland.display) == -1) {
+		printf("roundtrip failed\n");
+		r->common.success = MwFALSE;
+		return;
+	}
+
+	// Check that all globals we require are available
+	if(
+	    r->wayland.compositor == NULL ||
+	    WAYLAND_GET_INTERFACE(r->wayland, xdg_wm_base)->context == NULL ||
+	    WAYLAND_GET_INTERFACE(r->wayland, wl_seat)->context == NULL) {
+
+		printf("no wl_shm, wl_compositor, wl_seat, or xdg_wm_base support\n");
+		r->common.success = MwFALSE;
+		return;
+	}
+
+	r->wayland.toplevel->xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+
+	// Create a wl_surface, a xdg_surface and a xdg_toplevel
+	r->wayland.surface = wl_compositor_create_surface(r->wayland.compositor);
+	r->wayland.toplevel->xdg_surface =
+	    xdg_wm_base_get_xdg_surface(WAYLAND_GET_INTERFACE(r->wayland, xdg_wm_base)->context, r->wayland.surface);
+	r->wayland.toplevel->xdg_top_level = xdg_surface_get_toplevel(r->wayland.toplevel->xdg_surface);
+
+	// setup mandatory listeners
+	r->wayland.toplevel->xdg_surface_listener.configure  = xdg_surface_configure;
+	r->wayland.toplevel->xdg_toplevel_listener.configure = xdg_toplevel_configure;
+	r->wayland.toplevel->xdg_toplevel_listener.close     = xdg_toplevel_close;
+
+	xdg_surface_add_listener(r->wayland.toplevel->xdg_surface, &r->wayland.toplevel->xdg_surface_listener, r);
+	xdg_toplevel_add_listener(r->wayland.toplevel->xdg_top_level, &r->wayland.toplevel->xdg_toplevel_listener,
+				  r);
+
+	xdg_toplevel_set_title(r->wayland.toplevel->xdg_top_level, "Milsko Wayland App");
+	xdg_toplevel_set_app_id(r->wayland.toplevel->xdg_top_level, "MilskoWaylandApp");
+
+	// Perform the initial commit and wait for the first configure event
+	wl_surface_commit(r->wayland.surface);
+	while(wl_display_dispatch(r->wayland.display) != -1 && !r->wayland.configured) {
+	}
+
+	// setup decorations if we can
+	if(WAYLAND_GET_INTERFACE(r->wayland, zxdg_decoration_manager_v1)->context != NULL) {
+		zxdg_decoration_manager_v1_context_t* dec = WAYLAND_GET_INTERFACE(r->wayland, zxdg_decoration_manager_v1)->context;
+
+		dec->decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(
+		    dec->manager, r->wayland.toplevel->xdg_top_level);
+
+		zxdg_toplevel_decoration_v1_set_mode(
+		    dec->decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
+	} else {
+		printf("zxdg null\n");
+	}
+
+	// buffer_setup(&r->wayland);
+
+	wl_surface_commit(r->wayland.surface);
+}
+
+static void setup_subsurface(MwLL parent, MwLL r, int x, int y, int width, int height) {
+	struct wl_compositor*	 compositor	= parent->wayland.compositor;
+	struct wl_subcompositor* subcompositor	= parent->wayland.subcompositor;
+	struct wl_surface*	 parent_surface = parent->wayland.surface;
+
+	r->wayland.type = MWLL_WAYLAND_SUBSURFACE;
+
+	r->wayland.display = parent->wayland.display;
+
+	r->wayland.surface = wl_compositor_create_surface(compositor);
+
+	r->wayland.subsurface = wl_subcompositor_get_subsurface(subcompositor, r->wayland.surface, parent_surface);
+
+	wl_subsurface_set_position(r->wayland.subsurface, x, y);
+
+	// printf("position %d %d\n", x, y);
+
+	setup_callbacks(&r->wayland);
+
+	r->wayland.registry = wl_display_get_registry(parent->wayland.display);
+	r->wayland.display  = parent->wayland.display;
+
+	wl_registry_add_listener(r->wayland.registry, &r->wayland.registry_listener, r);
+	if(wl_display_roundtrip(r->wayland.display) == -1) {
+		printf("roundtrip failed\n");
+		raise(SIGTRAP);
+		return;
+	}
+
+	// arrpush(parent->wayland.subsurfaces, r);
+
+	r->wayland.configured = MwTRUE;
+
+	r->wayland.egl_context = parent->wayland.egl_context;
+	r->wayland.egl_display = parent->wayland.egl_display;
+	r->wayland.egl_surface = parent->wayland.egl_surface;
+	r->wayland.fbo	       = parent->wayland.fbo;
+	r->wayland.fbo_texture = parent->wayland.fbo_texture;
+	r->wayland.rbo	       = parent->wayland.rbo;
+
+	// egl_vbo_setup(r);
+}
+
+static int z_index_counter = 0;
+
+static MwLL MwLLCreateImpl(MwLL parent, int x, int y, int width, int height) {
+	MwLL r;
+	r = malloc(sizeof(*r));
+	MwLLCreateCommon(r);
+
+	r->common.type = MwLLBackendWayland;
+
+	if(width == 0) width = 1;
+	if(height == 0) height = 1;
+
+	r->wayland.ww	   = width;
+	r->wayland.wh	   = height;
+	r->wayland.parent  = parent;
+	r->wayland.z_index = z_index_counter++;
+
+	r->wayland.force_redraw = MwFALSE;
+	r->wayland.do_clear	= MwFALSE;
+	r->common.success	= MwTRUE;
+
+	if(parent == NULL) {
+		setup_toplevel(r, x, y, width, height);
+	} else {
+		setup_subsurface(parent, r, x, y, width, height);
+	}
+
+	return r;
+}
+
+static void MwLLDestroyImpl(MwLL handle) {
+	MwLLDestroyCommon(handle);
+
+	free(handle);
+}
+
+static void MwLLGetXYWHImpl(MwLL handle, int* x, int* y, unsigned int* w, unsigned int* h) {
+	*x = handle->wayland.x;
+	*y = handle->wayland.y;
+	*w = handle->wayland.ww;
+	*h = handle->wayland.wh;
+}
+
+static void MwLLSetXYImpl(MwLL handle, int x, int y) {
+
+	if(handle->wayland.type != MWLL_WAYLAND_TOPLEVEL) {
+		handle->wayland.x = x;
+		handle->wayland.y = y;
+		wl_subsurface_set_position(handle->wayland.subsurface, x, y);
+		MwLLForceRender(handle);
+	}
+}
+
+static void MwLLSetWHImpl(MwLL handle, int w, int h) {
+	handle->wayland.ww = w;
+	handle->wayland.wh = h;
+
+	if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
+		xdg_surface_set_window_geometry(handle->wayland.toplevel->xdg_surface, handle->wayland.x, handle->wayland.y, handle->wayland.ww, handle->wayland.wh);
+	} else {
+	}
+}
+
+static void polygon_setup(MwLL handle, MwPoint* points, int points_count, MwLLColor color) {
+	int	 i;
+	MwPoint* points_translated = malloc(points_count * sizeof(MwPoint));
+
+	glEnable(GL_TEXTURE_2D);
+	glBindTexture(GL_TEXTURE_2D, 0);
+	glBindFramebuffer(GL_FRAMEBUFFER, handle->wayland.fbo);
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, handle->wayland.fbo_texture, 0);
+	glLineWidth(1);
+	glPointSize(5);
+
+	for(i = 0; i < points_count; i++) {
+		points_translated[i].x = ceil(handle->wayland.x) + ceil(points[i].x);
+		points_translated[i].y = ceil(handle->wayland.y) + ceil(points[i].y);
+		printf("%d %d\n", points_translated[i].x, points_translated[i].y);
+	}
+
+	glBindBuffer(GL_ARRAY_BUFFER, handle->wayland.vertex_buffer);
+	glBufferData(GL_ARRAY_BUFFER, points_count * sizeof(MwPoint), &points_translated[0], GL_STATIC_DRAW);
+
+	glPolygonMode(GL_FRONT, GL_LINE);
+	glPolygonMode(GL_BACK, GL_LINE);
+	glBindVertexArray(handle->wayland.vertex_buffer);
+	if(points_count == 3) {
+		glDrawArrays(GL_TRIANGLES, 0, points_count);
+	} else if(points_count == 4) {
+		glDrawArrays(GL_QUADS, 0, points_count);
+	} else {
+		glDrawArrays(GL_TRIANGLES, 0, points_count);
+	}
+	glPolygonMode(GL_FRONT, GL_FILL);
+	glPolygonMode(GL_BACK, GL_FILL);
+
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+	glBindVertexArray(0);
+
+	free(points_translated);
+}
+
+static void MwLLPolygonImpl(MwLL handle, MwPoint* points, int points_count, MwLLColor color) {
+	int w, h;
+
+	polygon_setup(handle, points, points_count, color);
+
+	if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
+		w = handle->wayland.ww;
+		h = handle->wayland.wh;
+	} else {
+		MwLL parent = handle->wayland.parent;
+		while(parent->wayland.type != MWLL_WAYLAND_TOPLEVEL) {
+			parent = parent->wayland.parent;
+		}
+		w = parent->wayland.ww;
+		h = parent->wayland.wh;
+	}
+
+	glBindTexture(GL_TEXTURE_2D, handle->wayland.fbo_texture);
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	glClear(GL_COLOR_BUFFER_BIT);
+	glClearColor(0, 0, 0, 1);
+
+	glColor3f(1.0, 1.0, 1.0);
+
+	glBegin(GL_QUADS);
+	glTexCoord2f(0.0f, 1);
+	glVertex2f(0, 0);
+	glTexCoord2f(1, 1);
+	glVertex2f(w, 0);
+	glTexCoord2f(1, 0.0f);
+	glVertex2f(w, h);
+	glTexCoord2f(0.0f, 0.0f);
+	glVertex2f(0, h);
+	glEnd();
+	glFinish();
+
+	if(!eglSwapBuffers(handle->wayland.egl_display, handle->wayland.egl_surface)) {
+		printf("error swapping buffers! %0X\n", eglGetError());
+	} else {
+		wl_surface_commit(handle->wayland.surface);
+	}
+	glDisable(GL_TEXTURE_2D);
+	handle->wayland.do_clear = MwFALSE;
+}
+
+static void MwLLLineImpl(MwLL handle, MwPoint* points, MwLLColor color) {
+	//
+}
+
+static MwLLColor MwLLAllocColorImpl(MwLL handle, int r, int g, int b) {
+	MwLLColor c = malloc(sizeof(*c));
+
+	c->common.red	= r;
+	c->common.blue	= b;
+	c->common.green = g;
+
+	return c;
+}
+
+static void MwLLColorUpdateImpl(MwLL handle, MwLLColor c, int r, int g, int b) {
+	c->common.red	= r;
+	c->common.blue	= b;
+	c->common.green = g;
+}
+
+static void MwLLFreeColorImpl(MwLLColor color) {
+	free(color);
+}
+
+static int MwLLPendingImpl(MwLL handle) {
+	enum {
+		DISPLAY_FD,
+		KEYREPEAT_FD,
+		CURSOR_FD
+	};
+	struct pollfd fd;
+	int	      timeout = 1;
+
+	if(handle->wayland.force_redraw) {
+		return 1;
+	}
+
+	if(handle->wayland.display == NULL) {
+		return 0;
+	}
+	fd.fd	  = wl_display_get_fd(handle->wayland.display);
+	fd.events = POLLIN;
+
+	while(wl_display_prepare_read(handle->wayland.display) != 0) {
+		if(wl_display_dispatch_pending(handle->wayland.display) > 0) {
+			return 0;
+		}
+	}
+
+	// If an error other than EAGAIN happens, we have likely been disconnected
+	// from the Wayland session
+	if(!flush_display(handle->wayland.display)) {
+		wl_display_cancel_read(handle->wayland.display);
+
+		handle->wayland.toplevel->running = MwFALSE;
+		return 0;
+	}
+
+	// Condition where no events are being sent.
+	if(!poll(&fd, 1, timeout)) {
+		wl_display_cancel_read(handle->wayland.display);
+		// In this case, we need to commit the surface for any animations, etc.
+		wl_surface_commit(handle->wayland.surface);
+		return 0;
+	}
+
+	if(fd.revents & POLLIN) {
+		wl_display_read_events(handle->wayland.display);
+		if(wl_display_dispatch_pending(handle->wayland.display) > 0) {
+		}
+	} else {
+		wl_display_cancel_read(handle->wayland.display);
+	}
+
+	return 1;
+}
+
+static void MwLLNextEventImpl(MwLL handle) {
+	MwBool render = handle->wayland.force_redraw;
+
+	if(render) {
+		int	     x, y;
+		unsigned int w, h;
+
+		MwLLGetXYWH(handle, &x, &y, &w, &h);
+
+		MwLLDispatch(handle, draw, NULL);
+		handle->wayland.force_redraw = MwFALSE;
+	}
+}
+
+static void MwLLSetTitleImpl(MwLL handle, const char* title) {
+	if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
+		xdg_toplevel_set_title(handle->wayland.toplevel->xdg_top_level, title);
+	}
+}
+
+static MwLLPixmap MwLLCreatePixmapImpl(MwLL handle, unsigned char* data, int width, int height) {
+	MwLLPixmap r = malloc(sizeof(*r));
+
+	r->common.width	 = width;
+	r->common.height = height;
+	r->common.raw	 = data;
+	return r;
+}
+
+static void MwLLPixmapUpdateImpl(MwLLPixmap r) {
+}
+
+static void MwLLDestroyPixmapImpl(MwLLPixmap pixmap) {
+	free(pixmap);
+}
+
+static void MwLLDrawPixmapImpl(MwLL handle, MwRect* rect, MwLLPixmap pixmap) {
+}
+
+static void MwLLSetIconImpl(MwLL handle, MwLLPixmap pixmap) {
+}
+
+static void MwLLForceRenderImpl(MwLL handle) {
+	wl_surface_damage(handle->wayland.surface, 0, 0, handle->wayland.ww, handle->wayland.wh);
+
+	wl_surface_commit(handle->wayland.surface);
+
+	handle->wayland.force_redraw = MwTRUE;
+}
+
+static void MwLLSetCursorImpl(MwLL handle, MwCursor* image, MwCursor* mask) {
+}
+
+static void MwLLDetachImpl(MwLL handle, MwPoint* point) {
+}
+
+static void MwLLShowImpl(MwLL handle, int show) {
+}
+
+static void MwLLMakePopupImpl(MwLL handle, MwLL parent) {
+}
+
+static void MwLLSetSizeHintsImpl(MwLL handle, int minx, int miny, int maxx, int maxy) {
+	if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
+		xdg_toplevel_set_min_size(handle->wayland.toplevel->xdg_top_level, minx, miny);
+		xdg_toplevel_set_max_size(handle->wayland.toplevel->xdg_top_level, maxx, maxy);
+	}
+}
+
+static void MwLLMakeBorderlessImpl(MwLL handle, int toggle) {
+	if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
+		if(WAYLAND_GET_INTERFACE(handle->wayland, zxdg_decoration_manager_v1)->context != NULL) {
+			zxdg_decoration_manager_v1_context_t* dec = WAYLAND_GET_INTERFACE(handle->wayland, zxdg_decoration_manager_v1)->context;
+
+			dec->decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(
+			    dec->manager, handle->wayland.toplevel->xdg_top_level);
+
+			zxdg_toplevel_decoration_v1_set_mode(
+			    dec->decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE);
+		} else {
+			// TODO: hide our custom window decorations when we have them.
+			printf("zxdg null\n");
+		}
+	}
+}
+
+static void MwLLFocusImpl(MwLL handle) {
+}
+
+static void MwLLGrabPointerImpl(MwLL handle, int toggle) {
+}
+
+static void MwLLSetClipboardImpl(MwLL handle, const char* text) {
+}
+
+static char* MwLLGetClipboardImpl(MwLL handle) {
+	char* r = NULL;
+	return r;
+}
+
+static void MwLLMakeToolWindowImpl(MwLL handle) {
+}
+
+static void MwLLGetCursorCoordImpl(MwLL handle, MwPoint* point) {
+}
+
+static void MwLLGetScreenSizeImpl(MwLL handle, MwRect* rect) {
+}
+
+static void MwLLBeginStateChangeImpl(MwLL handle) {
+	MwLLShow(handle, 0);
+}
+
+static void MwLLEndStateChangeImpl(MwLL handle) {
+	MwLLShow(handle, 1);
+}
+
+static int MwLLWaylandCallInitImpl(void) {
+#ifdef __linux__
+	if(strcmp(getenv("XDG_SESSION_TYPE"), "wayland")) {
+		return 1;
+	}
+#endif
+	return 0;
+}
+
+#include "call.c"
+CALL(Wayland);

src/backend/x11.c

@@ -395,10 +395,6 @@ static void MwLLFreeColorImpl(MwLLColor color) {
 	free(color);
 }
 
-static void MwLLSetBackgroundImpl(MwLL handle, MwLLColor color) {
-	XSetWindowBackground(handle->x11.display, handle->x11.window, color->x11.pixel);
-}
-
 static int MwLLPendingImpl(MwLL handle) {
 	XEvent ev;
 	if(XCheckTypedWindowEvent(handle->x11.display, handle->x11.window, ClientMessage, &ev) || XCheckWindowEvent(handle->x11.display, handle->x11.window, mask, &ev)) {
@@ -1019,7 +1015,6 @@ static void MwLLEndStateChangeImpl(MwLL handle) {
 }
 
 static int MwLLX11CallInitImpl(void) {
-	/* TODO: check properly */
 	return 0;
 }
 

src/core.c

@@ -1,7 +1,9 @@
 /* $Id$ */
 #include <Mw/Milsko.h>
+#include <wayland-util.h>
 
 #include "../external/stb_ds.h"
+#include "Mw/LowLevel.h"
 
 static void lldrawhandler(MwLL handle, void* data) {
 	MwWidget h = (MwWidget)handle->common.user;
@@ -295,7 +297,10 @@ int MwStep(MwWidget handle) {
 	arrfree(widgets);
 
 	handle->prop_event = 0;
-	if(handle->lowlevel != NULL && MwLLPending(handle->lowlevel)) MwLLNextEvent(handle->lowlevel);
+
+	if(handle->lowlevel != NULL && MwLLPending(handle->lowlevel))
+		MwLLNextEvent(handle->lowlevel);
+
 	handle->prop_event = 1;
 
 	clean_destroy_queue(handle);
@@ -378,11 +383,7 @@ void MwSetText(MwWidget handle, const char* key, const char* value) {
 		shput(handle->text, key, v);
 	}
 	if(handle->prop_event) MwDispatch3(handle, prop_change, key);
-	if(strcmp(key, MwNbackground) == 0) {
-		MwLLColor c = MwParseColor(handle, value);
-		MwLLSetBackground(handle->lowlevel, c);
-		MwLLFreeColor(c);
-	}
+
 	if(strcmp(key, MwNbackground) == 0 || strcmp(key, MwNforeground) == 0 || strcmp(key, MwNsubBackground) == 0 || strcmp(key, MwNsubForeground) == 0) {
 		MwForceRender(handle);
 	}
@@ -687,6 +688,9 @@ MwWidget MwGetParent(MwWidget handle) {
 typedef int (*call_t)(void);
 int MwLibraryInit(void) {
 	call_t calls[] = {
+#ifdef USE_WAYLAND
+	    MwLLWaylandCallInit,
+#endif
 #ifdef USE_X11
 	    MwLLX11CallInit,
 #endif

src/draw.c

@@ -1,5 +1,7 @@
 /* $Id$ */
+#include "Mw/LowLevel.h"
 #include <Mw/Milsko.h>
+#include <stdio.h>
 
 #ifdef USE_STB_IMAGE
 #include "../external/stb_image.h"
@@ -484,6 +486,7 @@ void MwDrawTriangle(MwWidget handle, MwRect* rect, MwLLColor color, int invert,
 		p4[2].y = rect->y + s * border;
 	}
 	MwLLPolygon(handle->lowlevel, p4, 3, col);
+
 	if(color != col) MwLLFreeColor(col);
 
 	MwLLFreeColor(lighter);

src/lowlevel.c

@@ -40,8 +40,6 @@ void (*MwLLMakePopup)(MwLL handle, MwLL parent);
 void (*MwLLBeginStateChange)(MwLL handle);
 void (*MwLLEndStateChange)(MwLL handle);
 
-void (*MwLLSetBackground)(MwLL handle, MwLLColor color);
-
 void (*MwLLFocus)(MwLL handle);
 void (*MwLLGrabPointer)(MwLL handle, int toggle);