cache slack team users + lazy loading of channel messages

compile_commands.json

@@ -11,8 +11,8 @@
       "bin/an_editor.o",
       "src/main.c"
     ],
-    "directory": "/home/patrick/Documents/an_editor",
-    "file": "/home/patrick/Documents/an_editor/src/main.c",
-    "output": "/home/patrick/Documents/an_editor/bin/an_editor.o"
+    "directory": "/home/patrick/Documents/a_chat_client",
+    "file": "/home/patrick/Documents/a_chat_client/src/main.c",
+    "output": "/home/patrick/Documents/a_chat_client/bin/a_chat_client"
   }
 ]

flake.nix

@@ -37,6 +37,7 @@
             pkg-config
             binutils
             curlMinimal
+            curl-config
             clang
             bear
             naga-cli
@@ -48,12 +49,14 @@
           ] else if pkgs.system == "x86_64-linux" then [
             pkg-config
             binutils
+            curlMinimal
             clang
             bear
             naga-cli
             libGL
             mesa
             gf
+            wayland
             xorg.libX11
             xorg.libXi
             xorg.xinput

justfile

@@ -1,16 +1,36 @@
 alias b := build
 alias r := run
 
+c_flags := if os() == "macos" {
+    "$(curl-config --libs) -framework Cocoa -framework QuartzCore -framework CoreImage -framework Metal -framework MetalKit -ObjC"
+} else if os_family() == "unix" {
+    "$(curl-config --libs) -lEGL -lGLESv2 -lGL -lm -lwayland-client -lwayland-egl -lX11 -lXi -lXcursor -Wno-implicit-function-declaration"
+} else { "" }
+
+[macos]
 build: transpile_shaders_metal
     mkdir -p bin
-    cc -Ivendor/ -O0 -g -Wall -Wextra $(curl-config --libs) -framework Cocoa -framework QuartzCore -framework CoreImage -framework Metal -framework MetalKit -ObjC src/*.c -o bin/chat_client
-    # cc -Ivendor/ -g -Wall -Wextra src/*.c -o bin/chat_client -lEGL -lGLESv2 -lGL -lm -lX11 -lXi -lXcursor
-    # cc bin/*.o -o bin/chat_client -lEGL -lGLESv2 -lGL -lm -lX11 -lXi -lXcursor
+    cc -Ivendor/ -O0 -g -Wall -Wextra {{ c_flags }} src/*.c -o bin/chat_client
 
+[linux]
+build: generate_wayland_protocols
+    mkdir -p bin
+    cc -Ivendor/ -O0 -g -Wall -Wextra {{ c_flags }} src/*.c src/wayland-crap/*.c -o bin/chat_client
+
+[linux]
+run: build
+    nixGLIntel ./bin/chat_client
+
+[macos]
 run: build
-    # nixGLIntel ./bin/chat_client
     ./bin/chat_client
 
+[linux]
+generate_wayland_protocols:
+    wayland-scanner client-header src/wayland-crap/xdg-shell.xml src/wayland-crap/xdg-shell.h
+    wayland-scanner code src/wayland-crap/xdg-shell.xml src/wayland-crap/xdg-shell.c
+
+[macos]
 transpile_shaders_metal:
     mkdir -p bin/transpiled_shaders
 

shaders/text_atlas_fragment.glsl

@@ -0,0 +1,18 @@
+#version 440 core
+
+struct VertexOutput {
+    vec4 position;
+    vec2 tex_coord;
+};
+
+
+layout(location = 0) in VertexOutput out_vertex;
+layout(location = 1) uniform highp sampler2D atlas_texture;
+
+out vec4 color;
+
+void main() {
+    float text_color = texture(atlas_texture, out_vertex.tex_coord).r;
+
+    color = vec4(text_color * vec3(1,1,1), text_color);
+}

shaders/text_atlas_vertex.glsl

@@ -0,0 +1,56 @@
+#version 440 core
+
+struct Vertex {
+    vec2 position;
+    vec2 tex_coord;
+};
+
+struct VertexOutput {
+    vec4 position;
+    vec2 tex_coord;
+};
+
+struct Glyph {
+    vec2 atlas_position;
+    vec2 size;
+    vec2 target_position;
+    float y_offset;
+    float _haha_alignment;
+};
+
+layout(std430, binding = 0) readonly buffer VertexBlock {
+    Vertex vertices[];
+};
+
+layout(std430, binding = 1) readonly buffer GlyphBlock {
+    Glyph glyphs[];
+};
+
+layout(std430, binding = 2) readonly buffer ParamsBlock {
+    vec2 screen_size;
+    vec2 font_size;
+};
+
+vec4 to_device_position(vec2 position, vec2 size) {
+    return vec4(((position / size) * 2.0) - vec2(1.0), 1.0, 1.0);
+}
+
+layout(location = 0) out VertexOutput out_vertex;
+
+void main() {
+    Glyph glyph = glyphs[gl_InstanceID];
+
+    vec2 scaled_size = ((vertices[gl_VertexID].position + 1.0) / 2.0) * (glyph.size/2.0);
+    vec2 scaled_size_2 = ((vertices[gl_VertexID].position + 1.0) / 2.0) * (glyph.size);
+    vec2 glyph_pos = scaled_size + glyph.target_position + vec2(0, glyph.y_offset/2.0+font_size.y);
+
+    vec4 device_position = to_device_position(glyph_pos, screen_size);
+    vec2 atlas_position = (scaled_size_2 + glyph.atlas_position) / 512.0;
+
+    device_position.y = -device_position.y;
+
+    out_vertex.position = device_position;
+    out_vertex.tex_coord = atlas_position;
+
+    gl_Position = device_position;
+}

shaders/ui_rect_fragment.glsl

@@ -0,0 +1,45 @@
+#version 440 core
+
+struct UiRectFragment {
+    highp vec4 device_position;
+    highp vec2 position;
+    highp vec2 size;
+    highp vec2 border_size;
+    highp vec2 screen_size;
+    highp vec2 tex_coord;
+    highp vec4 color;
+};
+
+in UiRectFragment out_rect;
+
+layout(location = 0) out highp vec4 color;
+
+highp float rect_sdf(
+    highp vec2 absolute_pixel_position,
+    highp vec2 origin,
+    highp vec2 size,
+    highp float corner_radius
+) {
+    highp vec2 half_size = size / 2.0;
+    highp vec2 rect_center = origin + half_size;
+
+    highp vec2 pixel_position = abs(absolute_pixel_position - rect_center);
+    highp vec2 shrunk_corner_position = half_size - corner_radius;
+
+    highp vec2 pixel_to_shrunk_corner = max(vec2(0), pixel_position - shrunk_corner_position);
+    highp float distance_to_shrunk_corner = length(pixel_to_shrunk_corner);
+    highp float distance = distance_to_shrunk_corner - corner_radius;
+
+    return distance;
+}
+
+void main() {
+    highp vec2 pixel_pos = out_rect.tex_coord.xy * out_rect.screen_size;
+
+    highp float distance = rect_sdf(pixel_pos, out_rect.position, out_rect.size, out_rect.border_size.x);
+    if (distance <= 0.0) {
+        color = out_rect.color;
+    } else {
+        color = vec4(0);
+    }
+}

shaders/ui_rect_vertex.glsl

@@ -0,0 +1,50 @@
+#version 440 core
+
+struct Vertex {
+    vec2 position;
+    vec2 tex_coord;
+};
+
+struct UiRect {
+    vec4 position;
+    vec4 size;
+    vec4 border_size;
+    vec4 color;
+};
+
+struct UiRectFragment {
+    highp vec4 device_position;
+    highp vec2 position;
+    highp vec2 size;
+    highp vec2 border_size;
+    highp vec2 screen_size;
+    highp vec2 tex_coord;
+    highp vec4 color;
+};
+
+layout(std430, binding = 0) readonly buffer VertexBlock {
+    Vertex vertices[];
+};
+
+layout(std430, binding = 1) readonly buffer RectBlock {
+    UiRect rects[];
+};
+layout(std430, binding = 2) readonly buffer ParamsBlock {
+    vec2 screen_size;
+};
+
+out UiRectFragment out_rect;
+
+void main() {
+    UiRect rect = rects[gl_InstanceID];
+
+    out_rect.device_position = vec4(vertices[gl_VertexID].position, 1, 1);
+    out_rect.position = rect.position.xy;
+    out_rect.size = rect.size.xy;
+    out_rect.border_size = rect.border_size.xy;
+    out_rect.screen_size = screen_size;
+    out_rect.tex_coord = vertices[gl_VertexID].tex_coord;
+    out_rect.color = rect.color;
+
+    gl_Position = vec4(vertices[gl_VertexID].position, 1, 1);
+}

src/ed_array.h

@@ -1,80 +1,90 @@
 #ifndef ED_ARRAY_INCLUDED
 #define ED_ARRAY_INCLUDED
-#include <stdio.h>
-#include <stdlib.h>
 #include <assert.h>
 #include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
 
-#define array(T) struct T ## _Array
-#define arrayTemplate(T) array(T) {\
-    size_t size, capacity;\
-    T *data;\
-};\
-array(T) T ## _ArrayConstruct(size_t size) {\
-    array(T) this;\
-    this.size = 0;\
-    this.capacity = size;\
-    this.data = malloc(size * sizeof(T));\
-    if (!this.data) {\
-        assert("failed to allocate memory for array");\
-    }\
-    return this;\
-};\
-void T ## _PushArray(array(T) *arr, T value) {\
-    if (arr->size+1 <= arr->capacity) {\
-        arr->data[arr->size] = value;\
-        arr->size += 1;\
-    } else {\
-        fprintf(stderr, "failed to push to u8 array, size+num > capacity\n");\
-    }\
-};\
-void T ## _PushArrayMulti(array(T) *arr, T *values, size_t len) {\
-    for (size_t i = 0; i < len; ++i) {\
-        T ## _PushArray(arr, values[i]);\
-    }\
-};\
-void T ## _InsertArrayAt(array(T) *arr, size_t loc, T value) {\
-    if (arr->size == arr->capacity) {\
-        arr->capacity *= 2;\
-        void *new_data = realloc(arr->data, arr->capacity);\
-        if (new_data == NULL) {\
-            fprintf(stderr, "out of memory when reallocating array\n");\
-        }\
-        arr->data = new_data;\
-    }\
-    memcpy(&arr->data[loc+1], &arr->data[loc], arr->size * sizeof(T));\
-    arr->data[loc] = value;\
-    arr->size += 1;\
-};
+#define array(T) struct T##_Array
+#define arrayTemplate(T)                                                       \
+    array(T) {                                                                 \
+        size_t size, capacity;                                                 \
+        T *data;                                                               \
+    };                                                                         \
+    array(T) T##_ArrayConstruct(size_t size) {                                 \
+        array(T) this;                                                         \
+        this.size = 0;                                                         \
+        this.capacity = size;                                                  \
+        this.data = malloc(size * sizeof(T));                                  \
+        if (!this.data) {                                                      \
+            assert("failed to allocate memory for array");                     \
+        }                                                                      \
+        return this;                                                           \
+    };                                                                         \
+    void T##_PushArray(array(T) * arr, T value) {                              \
+        if (arr->size == arr->capacity) {                                      \
+            arr->capacity *= 2;                                                \
+            void *new_data = realloc(arr->data, arr->capacity);                \
+            if (new_data == NULL) {                                            \
+                fprintf(stderr, "out of memory when reallocating array\n");    \
+            }                                                                  \
+            arr->data = new_data;                                              \
+        }                                                                      \
+        if (arr->size + 1 <= arr->capacity) {                                  \
+            arr->data[arr->size] = value;                                      \
+            arr->size += 1;                                                    \
+        }                                                                      \
+    };                                                                         \
+    void T##_PushArrayMulti(array(T) * arr, T * values, size_t len) {          \
+        for (size_t i = 0; i < len; ++i) {                                     \
+            T##_PushArray(arr, values[i]);                                     \
+        }                                                                      \
+    };                                                                         \
+    void T##_InsertArrayAt(array(T) * arr, size_t loc, T value) {              \
+        if (arr->size == arr->capacity) {                                      \
+            arr->capacity *= 2;                                                \
+            void *new_data = realloc(arr->data, arr->capacity);                \
+            if (new_data == NULL) {                                            \
+                fprintf(stderr, "out of memory when reallocating array\n");    \
+            }                                                                  \
+            arr->data = new_data;                                              \
+        }                                                                      \
+        memcpy(&arr->data[loc + 1], &arr->data[loc], arr->size * sizeof(T));   \
+        arr->data[loc] = value;                                                \
+        arr->size += 1;                                                        \
+    };
 
-#define slice(T) struct T ## _Slice
-#define sliceTemplate(T) slice(T) {\
-    size_t len;\
-    T *data;\
-};\
-array(T) T ## _FromSlice(slice(T) s) {\
-    array(T) arr = T ## _ArrayConstruct(s.len);\
-    memcpy(arr.data, s.data, sizeof(T) * s.len);\
-    arr.size = s.len;\
-    return arr;\
-}\
-slice(T) T ## _SliceConstruct(void *data, size_t len) {\
-    slice(T) this;\
-    this.len = len;\
-    this.data = data;\
-    return this;\
-}
+#define slice(T) struct T##_Slice
+#define sliceTemplate(T)                                                       \
+    slice(T) {                                                                 \
+        size_t len;                                                            \
+        T *data;                                                               \
+    };                                                                         \
+    array(T) T##_FromSlice(slice(T) s) {                                       \
+        array(T) arr = T##_ArrayConstruct(s.len);                              \
+        memcpy(arr.data, s.data, sizeof(T) * s.len);                           \
+        arr.size = s.len;                                                      \
+        return arr;                                                            \
+    }                                                                          \
+    slice(T) T##_SliceConstruct(void *data, size_t len) {                      \
+        slice(T) this;                                                         \
+        this.len = len;                                                        \
+        this.data = data;                                                      \
+        return this;                                                           \
+    }
 
-#define newArray(T, size) T ## _ArrayConstruct(size)
-#define newArrayFromSlice(T, s) T ## _FromSlice(s)
-#define pushArray(T, arr, value) T ## _PushArray(arr, (value))
-#define pushArrayMulti(T, arr, values, len) T ## _PushArrayMulti(arr, values, len)
+#define newArray(T, size) T##_ArrayConstruct(size)
+#define newArrayFromSlice(T, s) T##_FromSlice(s)
+#define pushArray(T, arr, value) T##_PushArray(arr, (value))
+#define pushArrayMulti(T, arr, values, len) T##_PushArrayMulti(arr, values, len)
 
-#define insertArrayAt(T, arr, loc, value) T ## _InsertArrayAt(arr, loc, (value))
+#define insertArrayAt(T, arr, loc, value) T##_InsertArrayAt(arr, loc, (value))
 
-#define newSlice(T, data, len) T ## _SliceConstruct(data, len)
+#define newSlice(T, data, len) T##_SliceConstruct(data, len)
 
 arrayTemplate(uint8_t);
 sliceTemplate(uint8_t);
+arrayTemplate(uint32_t);
+sliceTemplate(uint32_t);
 
 #endif

src/file_io.h

@@ -1,7 +1,7 @@
 #ifndef ED_FILE_IO_INCLUDED
 #define ED_FILE_IO_INCLUDED
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
 
 #include "string.h"
 
@@ -11,12 +11,16 @@ bool load_file(string file_path, size_t size, void *buffer);
 #ifdef ED_FILE_IO_IMPLEMENTATION
 
 #if defined(__unix__)
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <assert.h>
 
-unsigned long get_file_size(const char *filePath) {
-    FILE *file = fopen(filePath, "r");
+unsigned long get_file_size(string file_path) {
+    char *file_path_with_sentinel = malloc(file_path.len + 1);
+    memcpy(file_path_with_sentinel, file_path.data, file_path.len + 1);
+    file_path_with_sentinel[file_path.len] = 0;
+
+    FILE *file = fopen(file_path_with_sentinel, "r");
     assert(file && "get_file_size: failed to open file");
 
     fseek(file, 0, SEEK_END);
@@ -25,21 +29,22 @@ unsigned long get_file_size(const char *filePath) {
 
     fclose(file);
 
+    free(file_path_with_sentinel);
     return fsize;
 }
 
-bool load_file(const char *filePath, unsigned long size, void *buffer) {
-    FILE *file = fopen(filePath, "r");
+bool load_file(string file_path, size_t size, void *buffer) {
+    char *file_path_with_sentinel = malloc(file_path.len + 1);
+    memcpy(file_path_with_sentinel, file_path.data, file_path.len + 1);
+    file_path_with_sentinel[file_path.len] = 0;
+
+    FILE *file = fopen(file_path_with_sentinel, "r");
     assert(file && "load_file: failed to open file");
 
-    fseek(file, 0, SEEK_END);
-    long fsize = ftell(file);
-    fseek(file, 0, SEEK_SET);
-
-    fread(buffer, fsize, 1, file);
-
+    fread(buffer, size, 1, file);
     fclose(file);
 
+    free(file_path_with_sentinel);
     return true;
 }
 
@@ -47,49 +52,41 @@ bool load_file(const char *filePath, unsigned long size, void *buffer) {
 #include <windows.h>
 #define assertm(exp, msg) assert(((void)msg, exp))
 
-VOID CALLBACK FileIOCompletionRoutine(
-        __in  DWORD dwErrorCode,
-        __in  DWORD dwNumberOfBytesTransfered,
-        __in  LPOVERLAPPED lpOverlapped )
-{
+VOID CALLBACK FileIOCompletionRoutine(__in DWORD dwErrorCode,
+                                      __in DWORD dwNumberOfBytesTransfered,
+                                      __in LPOVERLAPPED lpOverlapped) {
     printf("Error code: %li", dwErrorCode);
     printf("Number of bytes: %li", dwNumberOfBytesTransfered);
 }
 
 unsigned long get_file_size(const char *filePath) {
-    HANDLE hFile = CreateFile(filePath,
-            GENERIC_READ,
-            FILE_SHARE_READ,
-            NULL,
-            OPEN_EXISTING,
-            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
-            NULL);
+    HANDLE hFile =
+        CreateFile(filePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
+                   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
 
     LARGE_INTEGER size;
-    assert(GetFileSizeEx(hFile, &size) && "get_file_size: failed to get file size");
+    assert(GetFileSizeEx(hFile, &size) &&
+           "get_file_size: failed to get file size");
 
     return size.LowPart;
 }
 
 bool load_file(const char *filePath, unsigned long size, void *buffer) {
-    HANDLE hFile = CreateFile(filePath,
-            GENERIC_READ,
-            FILE_SHARE_READ,
-            NULL,
-            OPEN_EXISTING,
-            FILE_ATTRIBUTE_NORMAL,
-            NULL);
+    HANDLE hFile = CreateFile(filePath, GENERIC_READ, FILE_SHARE_READ, NULL,
+                              OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
     OVERLAPPED ol = {0};
     unsigned long bytesRead = 0;
     if (!ReadFile(hFile, buffer, size, &bytesRead, NULL)) {
         unsigned long error = GetLastError();
-        unsigned long msg = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, error, 0, buffer, size, NULL);
+        unsigned long msg = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL,
+                                          error, 0, buffer, size, NULL);
 
         printf("failed to load file: %s\n", (char *)buffer);
         assert(false && "failed to read file");
     }
-    assert(bytesRead == size && "load_file: didn't one-shot read the whole file");
+    assert(bytesRead == size &&
+           "load_file: didn't one-shot read the whole file");
 
     return true;
 }
@@ -97,11 +94,14 @@ bool load_file(const char *filePath, unsigned long size, void *buffer) {
 #include <Foundation/Foundation.h>
 
 uint64_t get_file_size(string file_path) {
-    NSFileManager* file_manager = [NSFileManager defaultManager];
-    NSString *path = [file_manager stringWithFileSystemRepresentation:(const char *)file_path.data length:file_path.len]; 
+    NSFileManager *file_manager = [NSFileManager defaultManager];
+    NSString *path = [file_manager
+        stringWithFileSystemRepresentation:(const char *)file_path.data
+                                    length:file_path.len];
 
     NSError *error = NULL;
-    NSDictionary<NSFileAttributeKey, id> *attributes = [file_manager attributesOfItemAtPath:path error:&error];
+    NSDictionary<NSFileAttributeKey, id> *attributes =
+        [file_manager attributesOfItemAtPath:path error:&error];
 
     if (error) {
         NSLog(@"error getting file attributes: %@\n", error.description);
@@ -109,22 +109,26 @@ uint64_t get_file_size(string file_path) {
     }
 
     NSNumber *file_size = [attributes objectForKey:NSFileSize];
-    
+
     return file_size.unsignedLongLongValue;
 }
 
 bool load_file(string file_path, size_t size, void *buffer) {
-    NSFileManager* file_manager = [NSFileManager defaultManager];
-    NSString *path = [file_manager stringWithFileSystemRepresentation:(const char *)file_path.data length:file_path.len]; 
+    NSFileManager *file_manager = [NSFileManager defaultManager];
+    NSString *path = [file_manager
+        stringWithFileSystemRepresentation:(const char *)file_path.data
+                                    length:file_path.len];
 
     NSData *data = [file_manager contentsAtPath:path];
     if (data == NULL) {
-        fprintf(stderr, "failed to load file: %.*s\n", (int)file_path.len, file_path.data);
+        fprintf(stderr, "failed to load file: %.*s\n", (int)file_path.len,
+                file_path.data);
         return false;
     }
 
     if (data.length > size) {
-        fprintf(stderr, "buffer not large enough for file: %.*s\n", (int)file_path.len, file_path.data);
+        fprintf(stderr, "buffer not large enough for file: %.*s\n",
+                (int)file_path.len, file_path.data);
     }
 
     memcpy(buffer, data.bytes, data.length);

src/gfx.h

@@ -2,12 +2,6 @@
 
 #ifndef ED_GFX_INCLUDED
 #define ED_GFX_INCLUDED
-#include <AppKit/AppKit.h>
-#include <CoreGraphics/CoreGraphics.h>
-#include <Foundation/Foundation.h>
-#include <Metal/Metal.h>
-#include <QuartzCore/CoreAnimation.h>
-#include <QuartzCore/QuartzCore.h>
 #include <stdint.h>
 
 #include "ed_array.h"
@@ -15,6 +9,13 @@
 
 bool keep_running = true;
 
+#if defined(__APPLE__)
+#include <AppKit/AppKit.h>
+#include <CoreGraphics/CoreGraphics.h>
+#include <Foundation/Foundation.h>
+#include <Metal/Metal.h>
+#include <QuartzCore/CoreAnimation.h>
+#include <QuartzCore/QuartzCore.h>
 @interface EDGFXView : NSView
 @property NSTrackingArea *tracking_area;
 @end
@@ -30,6 +31,7 @@ bool keep_running = true;
 wrapIdArray(MTLRenderPipelineState);
 wrapIdArray(MTLBuffer);
 wrapIdArray(MTLTexture);
+#endif
 
 typedef struct {
     float position[4];
@@ -50,6 +52,7 @@ arrayTemplate(GpuGlyph);
 
 typedef struct {
     float screen_size[2];
+    float font_size[2];
 } GpuUniformParams;
 
 #if defined(__APPLE__)
@@ -72,6 +75,63 @@ typedef struct {
     array(_MTLBuffer) buffers;
     array(_MTLTexture) textures;
 } _metal_gfx_context;
+#elif __linux__
+#include "wayland-crap/xdg-shell.h"
+#include <EGL/egl.h>
+#include <GL/gl.h>
+#include <X11/Xlib.h>
+#include <sys/mman.h>
+#include <syscall.h>
+#include <unistd.h>
+#include <wayland-client.h>
+#include <wayland-egl.h>
+
+#include "file_io.h"
+
+// And I thought MacOS needed a lot of state to create a window
+arrayTemplate(GLuint);
+typedef struct {
+    struct wl_display *display;
+    struct wl_registry *registry;
+    struct wl_surface *surface;
+    struct wl_compositor *compositor;
+    struct wl_shm *shared_memory;
+    struct wl_shm_pool *shared_memory_pool;
+    struct xdg_wm_base *wm_base;
+    struct wl_buffer *buffer;
+    struct xdg_surface *xdg_surface;
+    struct xdg_toplevel *xdg_toplevel;
+    struct wl_seat *seat;
+    struct wl_pointer *pointer;
+    uint8_t *pixels;
+
+    EGLDisplay egl_display;
+    EGLConfig egl_config;
+    EGLSurface egl_surface;
+    EGLContext egl_context;
+    struct wl_egl_window *egl_window;
+
+    int mouse_x, mouse_y;
+    int mouse_left_down, mouse_right_down;
+
+    GLuint ui_rect_vertex_shader;
+    GLuint ui_rect_fragment_shader;
+    GLuint text_atlas_vertex_shader;
+    GLuint text_atlas_fragment_shader;
+    GLuint ui_rect_shader_program;
+    GLuint text_atlas_shader_program;
+
+    array(GLuint) buffers;
+    array(GLuint) textures;
+} _opengl_gfx_context_wayland;
+
+static void _opengl_gfx_present_wayland(_opengl_gfx_context_wayland *cx);
+
+typedef struct {
+    Display *display;
+    Window window;
+    int screen;
+} _opengl_gfx_context_x11;
 #endif
 
 typedef void (*_gfx_frame_func)(int mouse_x, int mouse_y, bool mouse_left_down,
@@ -79,6 +139,9 @@ typedef void (*_gfx_frame_func)(int mouse_x, int mouse_y, bool mouse_left_down,
 typedef struct {
 #if defined(__APPLE__)
     _metal_gfx_context backend;
+#elif __linux__
+    // TODO: be able to use X11 or Wayland at runtime
+    _opengl_gfx_context_wayland backend;
 #else
 #error "Unsupported platform"
 #endif
@@ -205,8 +268,8 @@ void gfx_update_buffer(gfx_context_t *cx, size_t buffer_index, const void *data,
 
 - (void)mouseMoved:(NSEvent *)event {
     // NSPoint location = NSEvent.mouseLocation;
-    NSPoint location = [self convertPoint:[event locationInWindow]
-                                 fromView:nil];
+    NSPoint location =
+        [self convertPoint:[event locationInWindow] fromView:nil];
 
     _gfx_context.backend.mouse_x = location.x;
     _gfx_context.backend.mouse_y = location.y;
@@ -302,8 +365,8 @@ static _metal_gfx_context _metal_gfx_init_context(uint32_t width,
         exit(1);
     }
 
-    id<MTLLibrary> library = [device newLibraryWithURL:libraryURL
-                                                 error:&libraryError];
+    id<MTLLibrary> library =
+        [device newLibraryWithURL:libraryURL error:&libraryError];
 
     if (library == NULL) {
         if (libraryError.description != NULL) {
@@ -433,6 +496,11 @@ static void _metal_gfx_present(_metal_gfx_context *cx) {
                 (float)_gfx_context.frame_width,
                 (float)_gfx_context.frame_height,
             },
+        .font_size =
+            {
+                (float)_FONT_WIDTH,
+                (float)_FONT_HEIGHT,
+            },
     };
 
     gfx_update_buffer(&_gfx_context, 3, &gpu_uniform_params,
@@ -573,11 +641,519 @@ static void _metal_gfx_update_buffer(_metal_gfx_context *cx,
     // FIXME: actually check to see if this will fit in the buffer
     memcpy(buffer_contents, data, len);
 }
+#elif __linux__
+#include <linux/input-event-codes.h>
+
+static void _wayland_pointer_enter(void *data, struct wl_pointer *pointer,
+                                   uint32_t serial, struct wl_surface *surface,
+                                   wl_fixed_t x, wl_fixed_t y) {
+    // fprintf(stderr, "pointer enter: %d, %d\n", x, y);
+}
+static void _wayland_pointer_leave(void *data, struct wl_pointer *pointer,
+                                   uint32_t serial,
+                                   struct wl_surface *surface) {
+    // fprintf(stderr, "pointer leave\n");
+}
+static void _wayland_pointer_button(void *data, struct wl_pointer *pointer,
+                                    uint32_t serial, uint32_t time,
+                                    uint32_t button, uint32_t state) {
+    _opengl_gfx_context_wayland *cx = data;
+
+    if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
+        if (button == BTN_LEFT) {
+            cx->mouse_left_down = true;
+        } else if (button == BTN_RIGHT) {
+            cx->mouse_right_down = true;
+        }
+    } else if (state == WL_POINTER_BUTTON_STATE_RELEASED) {
+        if (button == BTN_LEFT) {
+            cx->mouse_left_down = false;
+        } else if (button == BTN_RIGHT) {
+            cx->mouse_right_down = false;
+        }
+    }
+}
+static void _wayland_pointer_axis(void *data, struct wl_pointer *pointer,
+                                  uint32_t time, uint32_t axis,
+                                  wl_fixed_t value) {}
+static void _wayland_pointer_motion(void *data, struct wl_pointer *pointer,
+                                    uint32_t time, wl_fixed_t x, wl_fixed_t y) {
+    _opengl_gfx_context_wayland *cx = data;
+    cx->mouse_x = wl_fixed_to_int(x);
+    cx->mouse_y = wl_fixed_to_int(y);
+}
+
+static const struct wl_pointer_listener pointer_listener = {
+    .enter = _wayland_pointer_enter,
+    .leave = _wayland_pointer_leave,
+    .motion = _wayland_pointer_motion,
+    .button = _wayland_pointer_button,
+    .axis = _wayland_pointer_axis,
+};
+
+static void _wayland_xdg_toplevel_configure(void *data,
+                                            struct xdg_toplevel *xdg_toplevel,
+                                            int32_t width, int32_t height,
+                                            struct wl_array *states) {}
+
+static void _wayland_xdg_toplevel_close(void *data,
+                                        struct xdg_toplevel *xdg_toplevel) {
+    keep_running = false;
+}
+
+static const struct xdg_toplevel_listener xdg_toplevel_listener = {
+    _wayland_xdg_toplevel_configure,
+    _wayland_xdg_toplevel_close,
+};
+
+static void _wayland_xdg_surface_configure(void *data,
+                                           struct xdg_surface *xdg_surface,
+                                           uint32_t serial) {
+    xdg_surface_ack_configure(xdg_surface, serial);
+}
+
+static const struct xdg_surface_listener xdg_surface_listener = {
+    _wayland_xdg_surface_configure,
+};
+
+static void _wayland_xdg_wm_base_ping(void *data, struct xdg_wm_base *shell,
+                                      uint32_t serial) {
+    xdg_wm_base_pong(shell, serial);
+}
+static const struct xdg_wm_base_listener xdg_wm_base_listener = {
+    _wayland_xdg_wm_base_ping,
+};
+
+static void _wayland_registry_handle_global(void *data,
+                                            struct wl_registry *registry,
+                                            uint32_t name,
+                                            const char *interface,
+                                            uint32_t version) {
+    _opengl_gfx_context_wayland *d = data;
+
+    fprintf(stderr, "global: %s\n", interface);
+
+    if (strcmp(interface, "wl_compositor") == 0) {
+        d->compositor =
+            wl_registry_bind(registry, name, &wl_compositor_interface, 3);
+    } else if (strcmp(interface, "wl_shm") == 0) {
+        d->shared_memory =
+            wl_registry_bind(registry, name, &wl_shm_interface, 1);
+    } else if (strcmp(interface, "xdg_wm_base") == 0) {
+        d->wm_base =
+            wl_registry_bind(registry, name, &xdg_wm_base_interface, 1);
+    } else if (strcmp(interface, "wl_seat") == 0) {
+        d->seat = wl_registry_bind(registry, name, &wl_seat_interface, 1);
+    }
+}
+
+static void _wayland_registry_handle_global_remove(void *data,
+                                                   struct wl_registry *registry,
+                                                   uint32_t name) {}
+
+static const struct wl_registry_listener registry_listener = {
+    _wayland_registry_handle_global,
+    _wayland_registry_handle_global_remove,
+};
+
+static void _opengl_gfx_message_callback(GLenum source, GLenum type, GLenum id,
+                                         GLenum severity, GLsizei length,
+                                         const GLchar *message,
+                                         const void *user_param) {
+    fprintf(stderr,
+            "GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
+            type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : "", type, severity,
+            message);
+}
+
+static void _opengl_gfx_check_shader_error(string msg, GLuint shader,
+                                           GLuint status) {
+    GLint good = 0;
+    glGetShaderiv(shader, status, &good);
+    if (good == GL_FALSE) {
+        GLint max_length = 0;
+        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &max_length);
+
+        uint8_t *log_buffer = malloc(max_length + 1);
+        glGetShaderInfoLog(shader, max_length, &max_length, log_buffer);
+        glDeleteShader(shader);
+
+        fprintf(stderr, "%.*s: %.*s\n", msg.len, msg.data, max_length,
+                log_buffer);
+        exit(1);
+    }
+}
+
+static void _opengl_gfx_check_shader_program_error(string msg,
+                                                   GLuint shader_program,
+                                                   GLuint status) {
+    GLint good = 0;
+    glGetProgramiv(shader_program, status, &good);
+    if (good == GL_FALSE) {
+        GLint max_length = 0;
+        glGetProgramiv(shader_program, GL_INFO_LOG_LENGTH, &max_length);
+
+        uint8_t *log_buffer = malloc(max_length + 1);
+        glGetProgramInfoLog(shader_program, max_length, &max_length,
+                            log_buffer);
+        glDeleteProgram(shader_program);
+
+        fprintf(stderr, "%.*s: %.*s\n", msg.len, msg.data, max_length,
+                log_buffer);
+        exit(1);
+    }
+}
+
+static GLuint _opengl_gfx_compile_shader(string file_path, GLuint shader_type) {
+    GLuint shader = glCreateShader(shader_type);
+    size_t shader_file_size = get_file_size(file_path);
+    uint8_t *shader_file_data = malloc(shader_file_size + 1);
+    load_file(file_path, shader_file_size, shader_file_data);
+    shader_file_data[shader_file_size] = 0;
+    // fprintf(stderr, "%s\n", shader_file_data);
+
+    glShaderSource(shader, 1, &shader_file_data, NULL);
+    glCompileShader(shader);
+
+    _opengl_gfx_check_shader_error(_String("failed to compile shader"), shader,
+                                   GL_COMPILE_STATUS);
+
+    return shader;
+}
+
+static _opengl_gfx_context_wayland
+_opengl_gfx_init_context_wayland(uint32_t width, uint32_t height) {
+    _opengl_gfx_context_wayland cx = {0};
+
+    cx.display = wl_display_connect(NULL);
+    if (!cx.display) {
+        fprintf(stderr, "Failed to connect to Wayland display\n");
+        exit(1);
+    }
+    struct wl_registry *registry = wl_display_get_registry(cx.display);
+    wl_registry_add_listener(registry, &registry_listener, &cx);
+
+    // wait for all the globals to be registered
+    wl_display_roundtrip(cx.display);
+    xdg_wm_base_add_listener(cx.wm_base, &xdg_wm_base_listener,
+                             &_gfx_context.backend);
+
+    cx.pointer = wl_seat_get_pointer(cx.seat);
+    wl_pointer_add_listener(cx.pointer, &pointer_listener,
+                            &_gfx_context.backend);
+
+    cx.surface = wl_compositor_create_surface(cx.compositor);
+    cx.xdg_surface = xdg_wm_base_get_xdg_surface(cx.wm_base, cx.surface);
+    xdg_surface_add_listener(cx.xdg_surface, &xdg_surface_listener,
+                             &_gfx_context.backend);
+
+    cx.xdg_toplevel = xdg_surface_get_toplevel(cx.xdg_surface);
+    xdg_toplevel_add_listener(cx.xdg_toplevel, &xdg_toplevel_listener,
+                              &_gfx_context.backend);
+    xdg_toplevel_set_title(cx.xdg_toplevel, "chat - [Slack sux]");
+    xdg_toplevel_set_app_id(cx.xdg_toplevel, "nl.spacegirl.a_chat_client");
+
+    wl_surface_commit(cx.surface);
+    wl_display_roundtrip(cx.display);
+
+    int buffer_size = width * height * 4;
+    int fd = syscall(SYS_memfd_create, "buffer", 0);
+    ftruncate(fd, buffer_size);
+
+    cx.pixels =
+        mmap(NULL, buffer_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+    for (int i = 0; i < buffer_size; i++) {
+        cx.pixels[i] = 0;
+    }
+
+    cx.shared_memory_pool =
+        wl_shm_create_pool(cx.shared_memory, fd, buffer_size);
+    cx.buffer =
+        wl_shm_pool_create_buffer(cx.shared_memory_pool, 0, width, height,
+                                  width * 4, WL_SHM_FORMAT_ARGB8888);
+
+    wl_surface_attach(cx.surface, cx.buffer, 0, 0);
+    wl_surface_commit(cx.surface);
+
+    /* Init EGL */
+    EGLint major, minor, count, n, size;
+    EGLConfig *configs;
+    EGLint config_attribs[] = {
+        EGL_SURFACE_TYPE,
+        EGL_WINDOW_BIT,
+        //
+        EGL_RED_SIZE,
+        8,
+        //
+        EGL_BLUE_SIZE,
+        8,
+        //
+        EGL_GREEN_SIZE,
+        8,
+        //
+        EGL_RENDERABLE_TYPE,
+        EGL_OPENGL_BIT,
+        //
+        EGL_NONE,
+    };
+
+    static const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2,
+                                             EGL_NONE};
+
+    cx.egl_display = eglGetDisplay(cx.display);
+    if (cx.egl_display == EGL_NO_DISPLAY) {
+        fprintf(stderr, "Failed to create EGL display\n");
+        exit(1);
+    }
+    fprintf(stderr, "Created EGL display\n");
+
+    if (eglInitialize(cx.egl_display, &major, &minor) != EGL_TRUE) {
+        fprintf(stderr, "Failed to initialize EGL display\n");
+        exit(1);
+    }
+    fprintf(stderr, "EGL major: %d, minor: %d\n", major, minor);
+
+    eglGetConfigs(cx.egl_display, NULL, 0, &count);
+    configs = calloc(count, sizeof(EGLConfig));
+
+    eglChooseConfig(cx.egl_display, config_attribs, configs, count, &n);
+
+    for (int i = 0; i < n; ++i) {
+        eglGetConfigAttrib(cx.egl_display, configs[i], EGL_BUFFER_SIZE, &size);
+        fprintf(stderr, "EGL Buffer size: %d\n", size);
+
+        eglGetConfigAttrib(cx.egl_display, configs[i], EGL_RED_SIZE, &size);
+        fprintf(stderr, "EGL Red size: %d\n", size);
+
+        cx.egl_config = configs[i];
+        break;
+    }
+
+    eglBindAPI(EGL_OPENGL_API);
+    cx.egl_context = eglCreateContext(cx.egl_display, cx.egl_config,
+                                      EGL_NO_CONTEXT, context_attribs);
+
+    cx.egl_window = wl_egl_window_create(cx.surface, width, height);
+    if (cx.egl_window == EGL_NO_SURFACE) {
+        fprintf(stderr, "Failed to create EGL window\n");
+        exit(1);
+    }
+    fprintf(stderr, "Created EGL window\n");
+
+    cx.egl_surface = eglCreateWindowSurface(cx.egl_display, cx.egl_config,
+                                            cx.egl_window, NULL);
+    if (eglMakeCurrent(cx.egl_display, cx.egl_surface, cx.egl_surface,
+                       cx.egl_context) != EGL_TRUE) {
+        fprintf(stderr, "eglMakeCurrent() failed\n");
+    }
+
+    glEnable(GL_DEBUG_OUTPUT);
+    glDebugMessageCallback(_opengl_gfx_message_callback, NULL);
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    cx.ui_rect_vertex_shader = _opengl_gfx_compile_shader(
+        _String("shaders/ui_rect_vertex.glsl"), GL_VERTEX_SHADER);
+    cx.ui_rect_fragment_shader = _opengl_gfx_compile_shader(
+        _String("shaders/ui_rect_fragment.glsl"), GL_FRAGMENT_SHADER);
+    cx.ui_rect_shader_program = glCreateProgram();
+    glAttachShader(cx.ui_rect_shader_program, cx.ui_rect_vertex_shader);
+    glAttachShader(cx.ui_rect_shader_program, cx.ui_rect_fragment_shader);
+    glLinkProgram(cx.ui_rect_shader_program);
+    _opengl_gfx_check_shader_program_error(
+        _String("failed to link ui_rect shader program"),
+        cx.ui_rect_shader_program, GL_LINK_STATUS);
+
+    cx.text_atlas_vertex_shader = _opengl_gfx_compile_shader(
+        _String("shaders/text_atlas_vertex.glsl"), GL_VERTEX_SHADER);
+    cx.text_atlas_fragment_shader = _opengl_gfx_compile_shader(
+        _String("shaders/text_atlas_fragment.glsl"), GL_FRAGMENT_SHADER);
+    cx.text_atlas_shader_program = glCreateProgram();
+    glAttachShader(cx.text_atlas_shader_program, cx.text_atlas_vertex_shader);
+    glAttachShader(cx.text_atlas_shader_program, cx.text_atlas_fragment_shader);
+    glLinkProgram(cx.text_atlas_shader_program);
+    _opengl_gfx_check_shader_program_error(
+        _String("failed to link text_atlas shader program"),
+        cx.text_atlas_shader_program, GL_LINK_STATUS);
+
+    cx.buffers = newArray(GLuint, 8);
+    cx.textures = newArray(GLuint, 8);
+    /* ******** */
+
+    return cx;
+}
+
+static _opengl_gfx_context_x11 _opengl_gfx_init_context_11(uint32_t width,
+                                                           uint32_t height) {
+    Display *display = XOpenDisplay(NULL);
+    if (display == NULL) {
+        fprintf(stderr, "Failed to open X display\n");
+        exit(1);
+    }
+
+    int screen = DefaultScreen(display);
+    Window window = XCreateSimpleWindow(
+        display, RootWindow(display, screen), 0, 0, width, height, 1,
+        BlackPixel(display, screen), WhitePixel(display, screen));
+    XSelectInput(display, window,
+                 ExposureMask | KeyPressMask | ButtonPressMask |
+                     ButtonReleaseMask);
+    XMapWindow(display, window);
+
+    return (_opengl_gfx_context_x11){
+        .display = display,
+        .window = window,
+        .screen = screen,
+    };
+}
+
+static void _opengl_gfx_send_events_wayland(_opengl_gfx_context_wayland *cx) {
+    wl_display_dispatch(cx->display);
+
+    // TODO: don't just render like crazy, limit framerate
+    _opengl_gfx_present_wayland(cx);
+}
+
+static void _opengl_gfx_send_events_x11(_opengl_gfx_context_x11 *cx) {
+    XEvent e;
+    XNextEvent(cx->display, &e);
+    if (e.type == Expose) {
+        XFillRectangle(cx->display, cx->window,
+                       DefaultGC(cx->display, cx->screen), 20, 20, 10, 10);
+    }
+
+    if (e.type == KeyPress) {
+        keep_running = false;
+
+        XCloseDisplay(cx->display);
+    }
+}
+
+static void _opengl_gfx_present_wayland(_opengl_gfx_context_wayland *cx) {
+    _gfx_context.gpu_glyphs.size = 0;
+    _gfx_context.gpu_ui_rects.size = 0;
+    _gfx_context.frame_func(cx->mouse_x, cx->mouse_y, cx->mouse_left_down,
+                            cx->mouse_right_down);
+
+    if (_gfx_context.gpu_glyphs.size > 0) {
+        gfx_update_buffer(&_gfx_context, 2, _gfx_context.gpu_glyphs.data,
+                          _gfx_context.gpu_glyphs.size * sizeof(GpuGlyph));
+    }
+    if (_gfx_context.gpu_ui_rects.size > 0) {
+        gfx_update_buffer(&_gfx_context, 4, _gfx_context.gpu_ui_rects.data,
+                          _gfx_context.gpu_ui_rects.size * sizeof(GpuUiRect));
+    }
+
+    GpuUniformParams gpu_uniform_params = {
+        .screen_size =
+            {
+                (float)_gfx_context.frame_width,
+                (float)_gfx_context.frame_height,
+            },
+        .font_size =
+            {
+                (float)_FONT_WIDTH,
+                (float)_FONT_HEIGHT,
+            },
+    };
+
+    gfx_update_buffer(&_gfx_context, 3, &gpu_uniform_params,
+                      sizeof(GpuUniformParams));
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glViewport(0, 0, _gfx_context.frame_width, _gfx_context.frame_height);
+
+    if (_gfx_context.gpu_ui_rects.size > 0) {
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, cx->buffers.data[0]);
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, cx->buffers.data[4]);
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, cx->buffers.data[3]);
+        glUseProgram(cx->ui_rect_shader_program);
+
+        const uint16_t indices[] = {0, 1, 2, 0, 2, 3};
+        glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices,
+                                _gfx_context.gpu_ui_rects.size);
+    }
+
+    if (_gfx_context.gpu_glyphs.size > 0) {
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, cx->buffers.data[0]);
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, cx->buffers.data[2]);
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, cx->buffers.data[3]);
+        glUseProgram(cx->text_atlas_shader_program);
+
+        const uint16_t indices[] = {0, 1, 2, 0, 2, 3};
+        glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices,
+                                _gfx_context.gpu_glyphs.size);
+    }
+
+    glFlush();
+
+    if (eglSwapBuffers(cx->egl_display, cx->egl_surface) != EGL_TRUE) {
+        fprintf(stderr, "eglSwapBuffers() failed\n");
+    }
+}
+
+static size_t
+_opengl_gfx_push_texture_buffer_wayland(_opengl_gfx_context_wayland *cx,
+                                        uint32_t width, uint32_t height,
+                                        const void *data, size_t len) {
+    pushArray(GLuint, &cx->textures, 0);
+    glCreateTextures(GL_TEXTURE_2D, 1,
+                     &cx->textures.data[cx->textures.size - 1]);
+    glTextureParameteri(cx->textures.data[cx->textures.size - 1],
+                        GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTextureParameteri(cx->textures.data[cx->textures.size - 1],
+                        GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTextureStorage2D(cx->textures.data[cx->textures.size - 1], 1, GL_RGBA8,
+                       width, height);
+    glTextureSubImage2D(cx->textures.data[cx->textures.size - 1], 0, 0, 0,
+                        width, height, GL_RED, GL_UNSIGNED_BYTE, data);
+    glBindTextureUnit(cx->textures.size - 1,
+                      cx->textures.data[cx->textures.size - 1]);
+
+    return cx->textures.size - 1;
+}
+
+static void
+_opengl_gfx_resize_texture_buffer_wayland(_opengl_gfx_context_wayland *cx,
+                                          uint32_t width, size_t texture_index,
+                                          uint32_t height) {
+    // TODO
+    assert(false && "_opengl_gfx_resize_texture_buffer_wayland unimplemented");
+}
+
+size_t _opengl_gfx_push_vertex_buffer_wayland(_opengl_gfx_context_wayland *cx,
+                                              const void *data, size_t len) {
+    pushArray(GLuint, &cx->buffers, 0);
+    glCreateBuffers(1, &cx->buffers.data[cx->buffers.size - 1]);
+    glNamedBufferStorage(cx->buffers.data[cx->buffers.size - 1], len, data,
+                         GL_DYNAMIC_STORAGE_BIT);
+
+    return cx->buffers.size - 1;
+}
+static size_t
+_opengl_gfx_allocate_vertex_buffer_wayland(_opengl_gfx_context_wayland *cx,
+                                           size_t len) {
+    pushArray(GLuint, &cx->buffers, 0);
+    glCreateBuffers(1, &cx->buffers.data[cx->buffers.size - 1]);
+    glNamedBufferStorage(cx->buffers.data[cx->buffers.size - 1], len, (void *)0,
+                         GL_DYNAMIC_STORAGE_BIT);
+
+    return cx->buffers.size - 1;
+}
+static void _opengl_gfx_update_buffer_wayland(_opengl_gfx_context_wayland *cx,
+                                              size_t buffer_index,
+                                              const void *data, size_t len) {
+    glNamedBufferSubData(cx->buffers.data[buffer_index], 0, len, data);
+}
 #endif
 
 void gfx_run_events(gfx_context_t *cx) {
 #if defined(__APPLE__)
     return _metal_gfx_send_events(&cx->backend);
+#elif __linux__
+    return _opengl_gfx_send_events_wayland(&cx->backend);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -588,6 +1164,9 @@ size_t gfx_push_texture_buffer(gfx_context_t *cx, uint32_t width,
 #if defined(__APPLE__)
     return _metal_gfx_push_texture_buffer(&cx->backend, width, height, data,
                                           len);
+#elif __linux__
+    return _opengl_gfx_push_texture_buffer_wayland(&cx->backend, width, height,
+                                                   data, len);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -596,6 +1175,8 @@ size_t gfx_push_texture_buffer(gfx_context_t *cx, uint32_t width,
 size_t gfx_push_vertex_buffer(gfx_context_t *cx, const void *data, size_t len) {
 #if defined(__APPLE__)
     return _metal_gfx_push_vertex_buffer(&cx->backend, data, len);
+#elif __linux__
+    return _opengl_gfx_push_vertex_buffer_wayland(&cx->backend, data, len);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -604,6 +1185,8 @@ size_t gfx_push_vertex_buffer(gfx_context_t *cx, const void *data, size_t len) {
 size_t gfx_allocate_vertex_buffer(gfx_context_t *cx, size_t len) {
 #if defined(__APPLE__)
     return _metal_gfx_allocate_vertex_buffer(&cx->backend, len);
+#elif __linux__
+    return _opengl_gfx_allocate_vertex_buffer_wayland(&cx->backend, len);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -614,6 +1197,9 @@ void gfx_update_buffer(gfx_context_t *cx, size_t buffer_index, const void *data,
                        size_t len) {
 #if defined(__APPLE__)
     return _metal_gfx_update_buffer(&cx->backend, buffer_index, data, len);
+#elif __linux__
+    return _opengl_gfx_update_buffer_wayland(&cx->backend, buffer_index, data,
+                                             len);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -661,6 +1247,8 @@ void *gfx_init_context(_gfx_frame_func frame_func, uint32_t width,
     __auto_type backend =
 #if defined(__APPLE__)
         _metal_gfx_init_context(width, height);
+#elif __linux__
+        _opengl_gfx_init_context_wayland(width, height);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -674,7 +1262,7 @@ void *gfx_init_context(_gfx_frame_func frame_func, uint32_t width,
     _gfx_context.gpu_glyphs = newArray(GpuGlyph, 8192 * 32);
     _gfx_context.glyph_cache = newArray(GpuGlyph, 97);
 
-    float vertices[] = {
+    const float vertices[] = {
         // positions       texture coords
         -1.0f, 1.0f,  0.0f, 0.0f, 1.0f,  1.0f,  1.0f, 0.0f,
         1.0f,  -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 1.0f,

src/ht.h

@@ -3,10 +3,10 @@
 #ifndef ED_HT_INCLUDED
 #define ED_HT_INCLUDED
 
-#include <stdlib.h>
-#include <stddef.h>
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 
 #include "string.h"
@@ -33,7 +33,7 @@ typedef uint64_t ht_hash_t;
 static ht_hash_t ht_hash(string key, uint64_t mod) {
     ht_hash_t hash = FNV_OFFSET;
 
-    for (size_t i=0; i<key.len; ++i) {
+    for (size_t i = 0; i < key.len; ++i) {
         hash *= FNV_PRIME;
         hash ^= key.data[i];
     }
@@ -42,13 +42,14 @@ static ht_hash_t ht_hash(string key, uint64_t mod) {
 }
 
 ed_ht ht_create(size_t max_entries, size_t value_size) {
-    ed_ht_slot *key_slots = (ed_ht_slot *)malloc(max_entries * sizeof(ed_ht_slot));
+    ed_ht_slot *key_slots =
+        (ed_ht_slot *)malloc(max_entries * sizeof(ed_ht_slot));
     void *value_slots = malloc(max_entries * value_size);
 
     memset(key_slots, 0, max_entries * sizeof(ed_ht_slot));
     memset(value_slots, 0, max_entries * value_size);
 
-    return (ed_ht) {
+    return (ed_ht){
         .key_slots = key_slots,
         .value_slots = value_slots,
         .value_size = value_size,
@@ -59,14 +60,15 @@ ed_ht ht_create(size_t max_entries, size_t value_size) {
 bool ht_set(ed_ht *ht, string key, void *value) {
     ht_hash_t hash = ht_hash(key, ht->capacity);
 
-    for (size_t i=hash; i<ht->capacity; ++i) {
-        if (ht->key_slots[i].key.data == NULL || string_eq(ht->key_slots[i].key, key)) {
+    for (size_t i = hash; i < ht->capacity; ++i) {
+        if (ht->key_slots[i].key.data == NULL ||
+            string_eq(ht->key_slots[i].key, key)) {
             if (ht->key_slots[i].key.data != NULL) {
                 free(ht->key_slots[i].key.data);
             }
             ht->key_slots[i].key = string_copy(key);
 
-            memcpy(ht->value_slots+i*ht->value_size, value, ht->value_size);
+            memcpy(ht->value_slots + i * ht->value_size, value, ht->value_size);
             return true;
         }
     }
@@ -75,7 +77,7 @@ bool ht_set(ed_ht *ht, string key, void *value) {
 }
 
 void *ht_get_slot(ed_ht *ht, size_t slot) {
-    void *value = ht->value_slots+slot*ht->value_size;
+    void *value = ht->value_slots + slot * ht->value_size;
 
     if (slot >= ht->capacity || !value)
         return NULL;
@@ -86,7 +88,7 @@ void *ht_get_slot(ed_ht *ht, size_t slot) {
 void *ht_get(ed_ht *ht, string key) {
     ht_hash_t hash = ht_hash(key, ht->capacity);
 
-    for (size_t i=hash; i<ht->capacity; ++i) {
+    for (size_t i = hash; i < ht->capacity; ++i) {
         if (ht->key_slots[i].key.data == NULL) {
             return NULL;
         }
@@ -102,13 +104,15 @@ void *ht_get(ed_ht *ht, string key) {
 void ht_remove(ed_ht *ht, string key) {
     ht_hash_t hash = ht_hash(key, ht->capacity);
 
-    for (size_t i=hash; i<ht->capacity; ++i) {
+    for (size_t i = hash; i < ht->capacity; ++i) {
         if (ht->key_slots[i].key.data == NULL) {
             return;
         }
 
         if (string_eq(ht->key_slots[i].key, key)) {
-            ht->key_slots[i] = (ed_ht_slot) { 0 };
+            free(ht->key_slots[i].key.data);
+            ht->key_slots[i] = (ed_ht_slot){0};
+            return;
         }
     }
 }

src/main.c

@@ -15,13 +15,14 @@
 #define ED_BUFFER_IMPLEMENTATION
 #define ED_FILE_IO_IMPLEMENTATION
 #define CHAT_SLACK_IMPLEMENTATION
+#include "ui.h"
+
 #include "ed_array.h"
 #include "file_io.h"
 #include "gfx.h"
 #include "ht.h"
 #include "slack_api.h"
 #include "string.h"
-#include "ui.h"
 
 // static Arena default_arena = {0};
 // static Arena temporary_arena = {0};
@@ -40,10 +41,20 @@ static struct {
 
     ui_context ui_cx;
     gfx_context_t *gfx_cx;
+
+    slack_client slack_client;
+    slack_user_info slack_user_info;
+    array(slack_channel) slack_channels;
+
+    ed_ht slack_messages;
+    ed_ht slack_users;
+
+    // strictly a weak reference to a channel id
+    string selected_channel_idx;
 } state;
 
-void ed_init(_gfx_frame_func frame_func) {
-    state.gfx_cx = gfx_init_context(frame_func, 640, 480);
+void init(_gfx_frame_func frame_func) {
+    state.gfx_cx = gfx_init_context(frame_func, 1280, 720);
     state.ui_cx = ui_init_context();
 
     // TODO: grab default font from the system
@@ -145,51 +156,144 @@ void ed_frame(int mouse_x, int mouse_y, bool mouse_left_down,
                                       .mouse_right_down = mouse_right_down,
                                   });
 
-    ui_element(&state.ui_cx, _String("channel sidebar"), UI_AXIS_VERTICAL,
-               ui_make_size(ui_children_sum, ui_fill), UI_FLAG_DRAW_BACKGROUND);
+    // TODO: make having custom title bar configurable
+    {
+        size_t title_bar_elm =
+            ui_element(&state.ui_cx, _String("chat - [slack sux]"),
+                       UI_AXIS_HORIZONTAL, ui_make_size(ui_fill, ui_exact(32)),
+                       UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT |
+                           UI_FLAG_CENTERED_TEXT);
+
+        ui_interaction title_bar_interaction =
+            _ui_test_interaction(&state.ui_cx, title_bar_elm);
+
+        if (title_bar_interaction.dragging) {
+            // TODO: drag the window around
+        }
+
+        ui_push_parent(&state.ui_cx);
+        {
+            ui_element(&state.ui_cx, _String("title bar spacer"),
+                       UI_AXIS_HORIZONTAL, ui_make_size(ui_fill, ui_exact(32)),
+                       0);
+
+            if (ui_button_centered(&state.ui_cx, _String("X")).clicked) {
+                keep_running = false;
+            }
+        }
+        ui_pop_parent(&state.ui_cx);
+    }
+
+    ui_element(&state.ui_cx, _String("main content"), UI_AXIS_HORIZONTAL,
+               ui_make_size(ui_fill, ui_fill), 0);
+
     ui_push_parent(&state.ui_cx);
     {
-        ui_element(&state.ui_cx, _String(buffer), UI_AXIS_HORIZONTAL,
-                   ui_make_size(ui_fit_text, ui_fit_text),
-                   UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT);
+        ui_element(&state.ui_cx, _String("channel sidebar"), UI_AXIS_VERTICAL,
+                   ui_make_size(ui_children_sum, ui_fill),
+                   UI_FLAG_DRAW_BACKGROUND);
+        ui_push_parent(&state.ui_cx);
+        {
+            ui_element(&state.ui_cx, state.slack_user_info.team,
+                       UI_AXIS_HORIZONTAL,
+                       ui_make_size(ui_fit_text, ui_fit_text),
+                       UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT);
 
-        if (ui_button(&state.ui_cx, _String("#dev-general")).clicked) {
-            printf("you clicked the dev-general button\n");
-            state.show_thing = !state.show_thing;
-        }
-        if (ui_button(&state.ui_cx, _String("#dev-help")).clicked) {
-            printf("you clicked the dev-help button\n");
-        }
+            for (int i = 0; i < state.slack_channels.size; ++i) {
+                if (ui_button(&state.ui_cx, state.slack_channels.data[i].name)
+                        .clicked) {
+                    state.selected_channel_idx =
+                        state.slack_channels.data[i].id;
 
-        if (state.show_thing) {
-            ui_interaction interaction = _ui_test_interaction(
-                &state.ui_cx,
-                ui_element(&state.ui_cx, _String("thread list"),
-                           UI_AXIS_VERTICAL,
-                           ui_make_size(ui_children_sum, ui_children_sum),
-                           UI_FLAG_DRAW_BACKGROUND));
+                    // FIXME: DO NOT DO THIS ON THE UI THREAD!
+                    if (!ht_get(&state.slack_messages,
+                                state.selected_channel_idx)) {
 
-            ui_push_parent(&state.ui_cx);
-            ui_element(&state.ui_cx, _String("List of Threads"),
-                       UI_AXIS_VERTICAL, ui_make_size(ui_fit_text, ui_fit_text),
-                       UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT |
-                           UI_FLAG_HOVERABLE);
-            if (interaction.hovering) {
-                if (ui_button(&state.ui_cx, _String("Thread 1")).clicked) {
-                    printf("thread 1\n");
-                }
-                if (ui_button(&state.ui_cx, _String("Thread 2")).clicked) {
-                    printf("thread 2\n");
-                }
-                if (ui_button(&state.ui_cx, _String("Thread 3")).clicked) {
-                    printf("thread 3\n");
-                }
-                if (ui_button(&state.ui_cx, _String("Thread 4")).clicked) {
-                    printf("thread 4\n");
+                        array(slack_message) messages = slack_api_message_list(
+                            &state.slack_client, state.selected_channel_idx);
+
+                        ht_set(&state.slack_messages,
+                               state.selected_channel_idx, &messages);
+                    }
                 }
             }
-            ui_pop_parent(&state.ui_cx);
+
+            // if (ui_button(&state.ui_cx, _String("#dev-general")).clicked) {
+            //     printf("you clicked the dev-general button\n");
+            //     state.show_thing = !state.show_thing;
+            // }
+            // if (ui_button(&state.ui_cx, _String("#dev-help")).clicked) {
+            //     printf("you clicked the dev-help button\n");
+            // }
+
+            if (state.show_thing) {
+                ui_interaction interaction = _ui_test_interaction(
+                    &state.ui_cx,
+                    ui_element(&state.ui_cx, _String("thread list"),
+                               UI_AXIS_VERTICAL,
+                               ui_make_size(ui_children_sum, ui_children_sum),
+                               UI_FLAG_DRAW_BACKGROUND));
+
+                ui_push_parent(&state.ui_cx);
+                ui_element(&state.ui_cx, _String("List of Threads"),
+                           UI_AXIS_VERTICAL,
+                           ui_make_size(ui_fit_text, ui_fit_text),
+                           UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT |
+                               UI_FLAG_HOVERABLE);
+                if (interaction.hovering) {
+                    if (ui_button(&state.ui_cx, _String("Thread 1")).clicked) {
+                        printf("thread 1\n");
+                    }
+                    if (ui_button(&state.ui_cx, _String("Thread 2")).clicked) {
+                        printf("thread 2\n");
+                    }
+                    if (ui_button(&state.ui_cx, _String("Thread 3")).clicked) {
+                        printf("thread 3\n");
+                    }
+                    if (ui_button(&state.ui_cx, _String("Thread 4")).clicked) {
+                        printf("thread 4\n");
+                    }
+                }
+                ui_pop_parent(&state.ui_cx);
+            }
         }
+        ui_pop_parent(&state.ui_cx);
+
+        ui_element(&state.ui_cx, _String("channel contents"), UI_AXIS_VERTICAL,
+                   ui_make_size(ui_fill, ui_fill), UI_FLAG_DRAW_BACKGROUND);
+        ui_push_parent(&state.ui_cx);
+        {
+            if (state.selected_channel_idx.data != NULL) {
+                array(slack_message) *messages =
+                    ht_get(&state.slack_messages, state.selected_channel_idx);
+
+                if (messages) {
+                    uint8_t text_buf[1024] = {0};
+                    for (int i = messages->size - 1; i >= 0; --i) {
+                        string message_text = messages->data[i].normal.text;
+                        slack_user *user = ht_get(
+                            &state.slack_users, messages->data[i].normal.user);
+
+                        if (user) {
+                            snprintf(text_buf, 1024, "%.*s: %.*s",
+                                     (int)user->real_name.len, user->name.data,
+                                     (int)message_text.len, message_text.data);
+                        } else {
+                            snprintf(text_buf, 1024, "Unknown: %.*s",
+                                     (int)message_text.len, message_text.data);
+                        }
+
+                        ui_button(&state.ui_cx, _CString_To_String(text_buf));
+                    }
+                }
+            } else {
+                ui_element(&state.ui_cx, _String("no channel selected"),
+                           UI_AXIS_VERTICAL, ui_make_size(ui_fill, ui_fit_text),
+                           UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT |
+                               UI_FLAG_CENTERED_TEXT);
+            }
+        }
+        ui_pop_parent(&state.ui_cx);
     }
     ui_pop_parent(&state.ui_cx);
 
@@ -203,13 +307,43 @@ void ed_frame(int mouse_x, int mouse_y, bool mouse_left_down,
 int main(int argc, char *argv[]) {
     curl_global_init(CURL_GLOBAL_ALL);
 
-    slack_client client = slack_init_client();
-    _slack_debug_print_auth_test(&client);
+    // just here to make development quicker for now
+    uint8_t token_buffer[4096];
+    uint8_t cookie_buffer[4096];
 
-    curl_global_cleanup();
-    return 0;
+    size_t token_buffer_size = get_file_size(_String("./bin/slack_token.txt"));
+    size_t cookie_buffer_size =
+        get_file_size(_String("./bin/slack_cookie.txt"));
+    assert("failed to open token file" &&
+           load_file(_String("./bin/slack_token.txt"), token_buffer_size,
+                     token_buffer));
+    assert("failed to open cookie file" &&
+           load_file(_String("./bin/slack_cookie.txt"), cookie_buffer_size,
+                     cookie_buffer));
 
-    ed_init(ed_frame);
+    token_buffer[token_buffer_size - 1] = 0;
+    cookie_buffer[cookie_buffer_size - 1] = 0;
+
+    state.slack_client = slack_init_client(_CString_To_String(token_buffer),
+                                           _CString_To_String(cookie_buffer));
+    state.slack_user_info = slack_api_auth_test(&state.slack_client);
+    state.slack_channels =
+        slack_api_channel_list(&state.slack_client, state.slack_user_info);
+    state.selected_channel_idx = (string){0};
+
+    // state.slack_messages = slack_api_message_list(
+    //     &state.slack_client, state.slack_channels.data[0].id);
+
+    state.slack_messages = ht_create(1000, sizeof(array(slack_message)));
+    state.slack_users = ht_create(1000, sizeof(slack_user));
+    // array(slack_user) users =
+    //     slack_api_user_list(&state.slack_client,
+    //     state.slack_user_info.team_id);
+    // for (int i = 0; i < users.size; ++i) {
+    //     ht_set(&state.slack_users, users.data[i].id, &users.data[i]);
+    // }
+
+    init(ed_frame);
 
     while (keep_running) {
         gfx_run_events(state.gfx_cx);

src/slack_api.h

@@ -9,13 +9,70 @@
 
 typedef struct {
     CURL *curl;
+
+    string token;
+    string cookie;
 } slack_client;
 
-void _slack_debug_print_auth_test(slack_client *client);
+typedef struct {
+    string url;
+    string team;
+    string user;
+    string team_id;
+    string user_id;
+} slack_user_info;
+
+typedef struct {
+    string id;
+    string name;
+
+    string topic;
+    string purpose;
+} slack_channel;
+arrayTemplate(slack_channel);
+
+typedef enum {
+    SLACK_MESSAGE_TYPE_MESSAGE,
+} slack_message_type_t;
+
+typedef struct {
+    slack_message_type_t type;
+} slack_message_type;
+
+typedef struct {
+    string user;
+    string text;
+} slack_message_normal;
+
+typedef struct {
+    slack_message_type type;
+    union {
+        slack_message_normal normal;
+    };
+} slack_message;
+arrayTemplate(slack_message);
+
+// TODO: merge with `slack_user_info`
+typedef struct {
+    string id;
+    string name;
+    string real_name;
+} slack_user;
+arrayTemplate(slack_user);
+
+slack_user_info slack_api_auth_test(slack_client *client);
+array(slack_channel)
+    slack_api_channel_list(slack_client *client, slack_user_info user);
+array(slack_message)
+    slack_api_message_list(slack_client *client, string channel_id);
+array(slack_user) slack_api_user_list(slack_client *client, string team_id);
 
 slack_client slack_init_client();
 
 #ifdef CHAT_SLACK_IMPLEMENTATION
+#include <cJSON/cJSON.h>
+
+#include <cJSON/cJSON.c>
 
 static size_t write_memory_callback(void *contents, size_t size, size_t nmemb,
                                     void *userp) {
@@ -24,53 +81,444 @@ static size_t write_memory_callback(void *contents, size_t size, size_t nmemb,
     return real_size;
 }
 
-void _slack_debug_print_auth_test(slack_client *client, string token,
-                                  string cookie) {
+slack_user_info slack_api_auth_test(slack_client *client) {
     if (client->curl) {
         struct curl_slist *headers = NULL;
-        headers = curl_slist_append(headers, "Content-Type: application/json");
-        // headers = curl_slist_append(headers, cookie);
+        headers = curl_slist_append(
+            headers, "Content-Type: application/x-www-form-urlencoded");
+        headers = curl_slist_append(headers, client->cookie.data);
 
         curl_easy_setopt(client->curl, CURLOPT_URL,
                          "https://slack.com/api/auth.test");
 
         curl_easy_setopt(client->curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BEARER);
-        // curl_easy_setopt(client->curl, CURLOPT_XOAUTH2_BEARER, token);
+        curl_easy_setopt(client->curl, CURLOPT_XOAUTH2_BEARER,
+                         client->token.data);
         curl_easy_setopt(client->curl, CURLOPT_USERAGENT,
                          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; "
                          "rv:76.0) Gecko/20100101 Firefox/76.0");
         curl_easy_setopt(client->curl, CURLOPT_HTTPHEADER, headers);
 
         curl_easy_setopt(client->curl, CURLOPT_POST, 1L);
-        curl_easy_setopt(client->curl, CURLOPT_POSTFIELDS, "{}");
+        curl_easy_setopt(client->curl, CURLOPT_POSTFIELDS, "");
 
         curl_easy_setopt(client->curl, CURLOPT_FOLLOWLOCATION, 1L);
 
-        array(uint8_t) chunk = newArray(uint8_t, 10000);
+        array(uint8_t) chunk = newArray(uint8_t, 4096);
 
         curl_easy_setopt(client->curl, CURLOPT_WRITEFUNCTION,
                          write_memory_callback);
         curl_easy_setopt(client->curl, CURLOPT_WRITEDATA, (void *)&chunk);
 
-        /* Perform the request, res gets the return code */
         CURLcode res = curl_easy_perform(client->curl);
-        /* Check for errors */
+
         if (res != CURLE_OK) {
             fprintf(stderr, "curl_easy_perform() failed: %s\n",
                     curl_easy_strerror(res));
-
         } else {
             fprintf(stderr, "Got data\n%.*s\n", (int)chunk.size, chunk.data);
         }
 
+        // parse json
+        cJSON *json = cJSON_ParseWithLength(chunk.data, chunk.size);
+        if (json == NULL) {
+            const char *error_ptr = cJSON_GetErrorPtr();
+            if (error_ptr != NULL) {
+                fprintf(stderr,
+                        "SLACK CLIENT: Failed to parse /auth.test: %s\n",
+                        error_ptr);
+
+                // FIXME: don't panic here
+                exit(1);
+            }
+        }
+        {
+            const cJSON *ok = cJSON_GetObjectItemCaseSensitive(json, "ok");
+            if (cJSON_IsBool(ok) && ok->valueint == 1) {
+                fprintf(stderr, "SLACK CLIENT: /auth.test succeeded!\n");
+
+                const cJSON *url =
+                    cJSON_GetObjectItemCaseSensitive(json, "url");
+                const cJSON *team =
+                    cJSON_GetObjectItemCaseSensitive(json, "team");
+                const cJSON *user =
+                    cJSON_GetObjectItemCaseSensitive(json, "user");
+                const cJSON *team_id =
+                    cJSON_GetObjectItemCaseSensitive(json, "team_id");
+                const cJSON *user_id =
+                    cJSON_GetObjectItemCaseSensitive(json, "user_id");
+
+                return (slack_user_info){
+                    .url = string_copy_cstring(url->valuestring),
+                    .team = string_copy_cstring(team->valuestring),
+                    .user = string_copy_cstring(user->valuestring),
+                    .team_id = string_copy_cstring(team_id->valuestring),
+                    .user_id = string_copy_cstring(user_id->valuestring),
+                };
+            } else {
+                const cJSON *error =
+                    cJSON_GetObjectItemCaseSensitive(json, "error");
+                if (cJSON_IsString(error)) {
+                    fprintf(stderr, "SLACK CLIENT: /auth.test failed: %s\n",
+                            error->valuestring);
+                } else {
+                    fprintf(stderr, "SLACK CLIENT: /auth.test failed: failed "
+                                    "to parse 'error' field\n");
+                }
+            }
+        }
+        cJSON_Delete(json);
+
         free(chunk.data);
     }
 }
 
+array(slack_channel)
+    slack_api_channel_list(slack_client *client, slack_user_info user) {
+    if (client->curl) {
+        struct curl_slist *headers = NULL;
+        headers = curl_slist_append(
+            headers, "Content-Type: application/x-www-form-urlencoded");
+        headers = curl_slist_append(headers, client->cookie.data);
+
+        curl_easy_setopt(client->curl, CURLOPT_URL,
+                         "https://slack.com/api/conversations.list");
+
+        curl_easy_setopt(client->curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BEARER);
+        curl_easy_setopt(client->curl, CURLOPT_XOAUTH2_BEARER,
+                         client->token.data);
+        curl_easy_setopt(client->curl, CURLOPT_USERAGENT,
+                         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; "
+                         "rv:76.0) Gecko/20100101 Firefox/76.0");
+        curl_easy_setopt(client->curl, CURLOPT_HTTPHEADER, headers);
+
+        curl_easy_setopt(client->curl, CURLOPT_POST, 1L);
+        curl_easy_setopt(client->curl, CURLOPT_POSTFIELDS, "limit=10");
+
+        curl_easy_setopt(client->curl, CURLOPT_FOLLOWLOCATION, 1L);
+
+        array(uint8_t) chunk = newArray(uint8_t, 4096);
+
+        curl_easy_setopt(client->curl, CURLOPT_WRITEFUNCTION,
+                         write_memory_callback);
+        curl_easy_setopt(client->curl, CURLOPT_WRITEDATA, (void *)&chunk);
+
+        CURLcode res = curl_easy_perform(client->curl);
+
+        if (res != CURLE_OK) {
+            fprintf(stderr, "curl_easy_perform() failed: %s\n",
+                    curl_easy_strerror(res));
+        } else {
+            fprintf(stderr, "Got data\n%.*s\n", (int)chunk.size, chunk.data);
+        }
+
+        // parse json
+        cJSON *json = cJSON_ParseWithLength(chunk.data, chunk.size);
+        if (json == NULL) {
+            const char *error_ptr = cJSON_GetErrorPtr();
+            if (error_ptr != NULL) {
+                fprintf(
+                    stderr,
+                    "SLACK CLIENT: Failed to parse /conversations.list: %s\n",
+                    error_ptr);
+
+                // FIXME: don't panic here
+                exit(1);
+            }
+        }
+        {
+            const cJSON *ok = cJSON_GetObjectItemCaseSensitive(json, "ok");
+            if (cJSON_IsBool(ok) && ok->valueint == 1) {
+                array(slack_channel) channels = newArray(slack_channel, 10);
+
+                fprintf(stderr,
+                        "SLACK CLIENT: /conversations.list succeeded!\n");
+
+                const cJSON *json_channels =
+                    cJSON_GetObjectItemCaseSensitive(json, "channels");
+
+                const cJSON *json_channel;
+                cJSON_ArrayForEach(json_channel, json_channels) {
+                    const cJSON *id =
+                        cJSON_GetObjectItemCaseSensitive(json_channel, "id");
+                    const cJSON *name =
+                        cJSON_GetObjectItemCaseSensitive(json_channel, "name");
+                    const cJSON *topic =
+                        cJSON_GetObjectItemCaseSensitive(json_channel, "topic");
+                    const cJSON *purpose = cJSON_GetObjectItemCaseSensitive(
+                        json_channel, "purpose");
+
+                    slack_channel channel = {
+                        .id = string_copy_cstring(id->valuestring),
+                        .name = string_copy_cstring(name->valuestring),
+                        .topic = string_copy_cstring(topic->valuestring),
+                        .purpose = string_copy_cstring(purpose->valuestring),
+                    };
+
+                    pushArray(slack_channel, &channels, channel);
+                }
+
+                return channels;
+            } else {
+                const cJSON *error =
+                    cJSON_GetObjectItemCaseSensitive(json, "error");
+                if (cJSON_IsString(error)) {
+                    fprintf(stderr,
+                            "SLACK CLIENT: /conversations.list failed: %s\n",
+                            error->valuestring);
+                } else {
+                    fprintf(stderr,
+                            "SLACK CLIENT: /conversations.list failed: failed "
+                            "to parse 'error' field\n");
+                }
+            }
+        }
+        cJSON_Delete(json);
+
+        free(chunk.data);
+    }
+
+    // TODO: create some slack api error type
+    return (array(slack_channel)){0};
+}
+
+array(slack_message)
+    slack_api_message_list(slack_client *client, string channel_id) {
+
+    if (client->curl) {
+        struct curl_slist *headers = NULL;
+        headers = curl_slist_append(
+            headers, "Content-Type: application/x-www-form-urlencoded");
+        headers = curl_slist_append(headers, client->cookie.data);
+
+        curl_easy_setopt(client->curl, CURLOPT_URL,
+                         "https://slack.com/api/conversations.history");
+
+        curl_easy_setopt(client->curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BEARER);
+        curl_easy_setopt(client->curl, CURLOPT_XOAUTH2_BEARER,
+                         client->token.data);
+        curl_easy_setopt(client->curl, CURLOPT_USERAGENT,
+                         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; "
+                         "rv:76.0) Gecko/20100101 Firefox/76.0");
+        curl_easy_setopt(client->curl, CURLOPT_HTTPHEADER, headers);
+
+        curl_easy_setopt(client->curl, CURLOPT_POST, 1L);
+
+        char *fields_buffer[2048];
+        snprintf(fields_buffer, 2048, "channel=%.*s&limit=10",
+                 (int)channel_id.len, channel_id.data);
+        fprintf(stderr, "fields_buffer: %s\n", fields_buffer);
+        curl_easy_setopt(client->curl, CURLOPT_POSTFIELDS, fields_buffer);
+
+        curl_easy_setopt(client->curl, CURLOPT_FOLLOWLOCATION, 1L);
+
+        array(uint8_t) chunk = newArray(uint8_t, 4096);
+
+        curl_easy_setopt(client->curl, CURLOPT_WRITEFUNCTION,
+                         write_memory_callback);
+        curl_easy_setopt(client->curl, CURLOPT_WRITEDATA, (void *)&chunk);
+
+        CURLcode res = curl_easy_perform(client->curl);
+
+        if (res != CURLE_OK) {
+            fprintf(stderr, "curl_easy_perform() failed: %s\n",
+                    curl_easy_strerror(res));
+        } else {
+            fprintf(stderr, "Got data\n%.*s\n", (int)chunk.size, chunk.data);
+        }
+
+        // parse json
+        cJSON *json = cJSON_ParseWithLength(chunk.data, chunk.size);
+        if (json == NULL) {
+            const char *error_ptr = cJSON_GetErrorPtr();
+            if (error_ptr != NULL) {
+                fprintf(stderr,
+                        "SLACK CLIENT: Failed to parse /conversations.history: "
+                        "%s\n",
+                        error_ptr);
+
+                // FIXME: don't panic here
+                exit(1);
+            }
+        }
+        {
+            const cJSON *ok = cJSON_GetObjectItemCaseSensitive(json, "ok");
+            if (cJSON_IsBool(ok) && ok->valueint == 1) {
+                array(slack_message) messages = newArray(slack_message, 10);
+
+                fprintf(stderr,
+                        "SLACK CLIENT: /conversations.history succeeded!\n");
+
+                const cJSON *json_messages =
+                    cJSON_GetObjectItemCaseSensitive(json, "messages");
+
+                const cJSON *json_message;
+                cJSON_ArrayForEach(json_message, json_messages) {
+                    const cJSON *type =
+                        cJSON_GetObjectItemCaseSensitive(json_message, "type");
+                    const cJSON *user =
+                        cJSON_GetObjectItemCaseSensitive(json_message, "user");
+                    const cJSON *text =
+                        cJSON_GetObjectItemCaseSensitive(json_message, "text");
+
+                    if (strcmp(type->valuestring, "message") == 0) {
+                        slack_message message = {
+                            .type = SLACK_MESSAGE_TYPE_MESSAGE,
+                            .normal =
+                                (slack_message_normal){
+                                    .user =
+                                        string_copy_cstring(user->valuestring),
+                                    .text =
+                                        string_copy_cstring(text->valuestring),
+                                },
+                        };
+
+                        pushArray(slack_message, &messages, message);
+                    } else {
+                        fprintf(stderr,
+                                "SLACK CLIENT: unknown message type: %s\n",
+                                type->valuestring);
+                    }
+                }
+
+                return messages;
+            } else {
+                const cJSON *error =
+                    cJSON_GetObjectItemCaseSensitive(json, "error");
+                if (cJSON_IsString(error)) {
+                    fprintf(stderr,
+                            "SLACK CLIENT: /conversations.history failed: %s\n",
+                            error->valuestring);
+                } else {
+                    fprintf(
+                        stderr,
+                        "SLACK CLIENT: /conversations.history failed: failed "
+                        "to parse 'error' field\n");
+                }
+            }
+        }
+        cJSON_Delete(json);
+
+        free(chunk.data);
+    }
+
+    // TODO: create some slack api error type
+    return (array(slack_message)){0};
+}
+
+array(slack_user) slack_api_user_list(slack_client *client, string team_id) {
+    if (client->curl) {
+        struct curl_slist *headers = NULL;
+        headers = curl_slist_append(
+            headers, "Content-Type: application/x-www-form-urlencoded");
+        headers = curl_slist_append(headers, client->cookie.data);
+
+        curl_easy_setopt(client->curl, CURLOPT_URL,
+                         "https://slack.com/api/users.list");
+
+        curl_easy_setopt(client->curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BEARER);
+        curl_easy_setopt(client->curl, CURLOPT_XOAUTH2_BEARER,
+                         client->token.data);
+        curl_easy_setopt(client->curl, CURLOPT_USERAGENT,
+                         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; "
+                         "rv:76.0) Gecko/20100101 Firefox/76.0");
+        curl_easy_setopt(client->curl, CURLOPT_HTTPHEADER, headers);
+
+        curl_easy_setopt(client->curl, CURLOPT_POST, 1L);
+
+        char *fields_buffer[2048];
+        snprintf(fields_buffer, 2048, "team_id=%.*s", (int)team_id.len,
+                 team_id.data);
+        fprintf(stderr, "fields_buffer: %s\n", fields_buffer);
+        curl_easy_setopt(client->curl, CURLOPT_POSTFIELDS, fields_buffer);
+
+        curl_easy_setopt(client->curl, CURLOPT_FOLLOWLOCATION, 1L);
+
+        // TODO: don't allocate this on every request
+        array(uint8_t) chunk = newArray(uint8_t, 4096);
+
+        curl_easy_setopt(client->curl, CURLOPT_WRITEFUNCTION,
+                         write_memory_callback);
+        curl_easy_setopt(client->curl, CURLOPT_WRITEDATA, (void *)&chunk);
+
+        CURLcode res = curl_easy_perform(client->curl);
+
+        if (res != CURLE_OK) {
+            fprintf(stderr, "curl_easy_perform() failed: %s\n",
+                    curl_easy_strerror(res));
+        } else {
+            fprintf(stderr, "Got data\n%.*s\n", (int)chunk.size, chunk.data);
+        }
+
+        // parse json
+        cJSON *json = cJSON_ParseWithLength(chunk.data, chunk.size);
+        if (json == NULL) {
+            const char *error_ptr = cJSON_GetErrorPtr();
+            if (error_ptr != NULL) {
+                fprintf(stderr,
+                        "SLACK CLIENT: Failed to parse /users.list: %s\n",
+                        error_ptr);
+
+                // FIXME: don't panic here
+                exit(1);
+            }
+        }
+        {
+            const cJSON *ok = cJSON_GetObjectItemCaseSensitive(json, "ok");
+            if (cJSON_IsBool(ok) && ok->valueint == 1) {
+                array(slack_user) users = newArray(slack_user, 10);
+
+                fprintf(stderr, "SLACK CLIENT: /users.list succeeded!\n");
+
+                const cJSON *json_users =
+                    cJSON_GetObjectItemCaseSensitive(json, "members");
+
+                const cJSON *json_user;
+                cJSON_ArrayForEach(json_user, json_users) {
+                    const cJSON *user_id =
+                        cJSON_GetObjectItemCaseSensitive(json_user, "id");
+                    const cJSON *name =
+                        cJSON_GetObjectItemCaseSensitive(json_user, "name");
+                    const cJSON *real_name = cJSON_GetObjectItemCaseSensitive(
+                        json_user, "real_name");
+
+                    slack_user user = {
+                        .id = string_copy_cstring(user_id->valuestring),
+                        .name = string_copy_cstring(name->valuestring),
+                        .real_name =
+                            string_copy_cstring(real_name->valuestring),
+                    };
+
+                    pushArray(slack_user, &users, user);
+                }
+
+                return users;
+            } else {
+                const cJSON *error =
+                    cJSON_GetObjectItemCaseSensitive(json, "error");
+                if (cJSON_IsString(error)) {
+                    fprintf(stderr, "SLACK CLIENT: /users.list failed: %s\n",
+                            error->valuestring);
+                } else {
+                    fprintf(stderr, "SLACK CLIENT: /users.list failed: failed "
+                                    "to parse 'error' field\n");
+                }
+            }
+        }
+        cJSON_Delete(json);
+
+        free(chunk.data);
+    }
+
+    // TODO: create some slack api error type
+    return (array(slack_user)){0};
+}
+
 slack_client slack_init_client(string token, string cookie) {
     CURL *curl = curl_easy_init();
 
-    slack_client client = (slack_client){.curl = curl};
+    slack_client client =
+        (slack_client){.curl = curl, .token = token, .cookie = cookie};
 
     return client;
 }

src/string.h

@@ -8,13 +8,21 @@
 
 #define _String(text)                                                          \
     ((string){.data = (uint8_t *)text, .len = sizeof(text), .owned = false})
+#define _CString_To_String(text)                                               \
+    ((string){.data = (uint8_t *)text, .len = strlen(text), .owned = false})
 typedef struct {
     uint8_t *data;
     size_t len;
 
+    // FIXME: this is so terribly bad please don't do this
     bool owned;
 } string;
 
+bool string_eq(string a, string b);
+bool string_eq_cstring(string a, const char *b);
+string string_copy(string s);
+string string_copy_cstring(const char *str);
+
 #ifdef ED_STRING_IMPLEMENTATION
 bool string_eq(string a, string b) {
     if (a.len != b.len)
@@ -28,6 +36,27 @@ bool string_eq(string a, string b) {
     return true;
 }
 
+bool string_eq_cstring(string a, const char *b) {
+    if (b == NULL) {
+        if (a.len == 0) {
+            return true;
+        }
+
+        return false;
+    }
+
+    size_t b_len = strlen(b);
+    if (a.len != b_len)
+        return false;
+
+    for (size_t i = 0; i < a.len; ++i) {
+        if (a.data[i] != b[i])
+            return false;
+    }
+
+    return true;
+}
+
 string string_copy(string a) {
     string new_string;
 
@@ -40,5 +69,23 @@ string string_copy(string a) {
     return new_string;
 }
 
+string string_copy_cstring(const char *str) {
+    if (str == NULL) {
+        return (string){.data = NULL, .len = 0, .owned = false};
+    }
+
+    string new_string;
+
+    size_t len = strlen(str);
+
+    new_string.data = malloc(len * sizeof(uint8_t));
+    new_string.len = len;
+    new_string.owned = true;
+
+    memcpy(new_string.data, str, new_string.len * sizeof(uint8_t));
+
+    return new_string;
+}
+
 #endif
 #endif

src/ui.h

@@ -3,11 +3,12 @@
 #ifndef ED_UI_INCLUDED
 #define ED_UI_INCLUDED
 
+#include "string.h"
 #define MAX_UI_ELEMENTS 8192
 
 // TODO: replace this with functions
-#define _FONT_WIDTH 12
 #define _FONT_HEIGHT 24
+#define _FONT_WIDTH _FONT_HEIGHT / 2
 
 #define _elm(index) (cx->frame_elements.data + index)
 #define _flags(index, flgs) ((_elm(index)->flags & (flgs)) == (flgs))
@@ -61,6 +62,9 @@ typedef struct {
     ((ui_semantic_size){.type = UI_SEMANTIC_SIZE_CHILDREN_SUM})
 #define ui_exact(value)                                                        \
     ((ui_semantic_size){.type = UI_SEMANTIC_SIZE_EXACT, .integer = value})
+#define ui_percent_of_parent(value)                                            \
+    ((ui_semantic_size){.type = UI_SEMANTIC_SIZE_PERCENT_OF_PARENT,            \
+                        .integer = value})
 
 typedef struct {
     ui_axis axis;
@@ -83,15 +87,16 @@ typedef struct {
 } ui_element_cache_data;
 
 typedef enum {
-    UI_FLAG_CLICKABLE = 0b000000001,
-    UI_FLAG_HOVERABLE = 0b000000010,
-    UI_FLAG_SCROLLABLE = 0b000000100,
-    UI_FLAG_DRAW_TEXT = 0b000001000,
-    UI_FLAG_DRAW_BORDER = 0b000010000,
-    UI_FLAG_DRAW_BACKGROUND = 0b000100000,
-    UI_FLAG_ROUNDED_BORDER = 0b001000000,
-    UI_FLAG_FLOATING = 0b010000000,
-    UI_FLAG_CUSTOM_DRAW_FUNC = 0b100000000,
+    UI_FLAG_CLICKABLE = 0b0000000001,
+    UI_FLAG_HOVERABLE = 0b0000000010,
+    UI_FLAG_SCROLLABLE = 0b0000000100,
+    UI_FLAG_DRAW_TEXT = 0b0000001000,
+    UI_FLAG_CENTERED_TEXT = 0b1000000000,
+    UI_FLAG_DRAW_BORDER = 0b0000010000,
+    UI_FLAG_DRAW_BACKGROUND = 0b0000100000,
+    UI_FLAG_ROUNDED_BORDER = 0b0001000000,
+    UI_FLAG_FLOATING = 0b0010000000,
+    UI_FLAG_CUSTOM_DRAW_FUNC = 0b0100000000,
 } ui_flags;
 
 // Ephemeral frame only UI Element data
@@ -161,7 +166,8 @@ ui_context ui_init_context() {
         .prev = -1,
         .parent = -1,
         .size = {
-            .axis = UI_AXIS_HORIZONTAL,
+            // TODO: make this configurable
+            .axis = UI_AXIS_VERTICAL,
             .computed_size = {640, 480},
         }};
     pushArray(ui_element_frame_data, &frame_elements, frame_data);
@@ -190,10 +196,10 @@ size_t ui_element(ui_context *cx, string label, ui_axis axis,
                   ui_semantic_size size[2], ui_flags flags) {
     ui_element_frame_data frame_data = (ui_element_frame_data){
         .index = cx->frame_elements.size,
-        // TODO: don't just set this to label, because then elements
+        // TODO: don't just set `key` to label, because then elements
         // with the same label can't be created together
-        .key = label,
-        .label = label,
+        .key = string_copy(label),
+        .label = string_copy(label),
         .first = -1,
         .last = -1,
         .next = -1,
@@ -218,7 +224,7 @@ size_t ui_element(ui_context *cx, string label, ui_axis axis,
     } else {
         bool did_insert = ht_set(&cx->cached_elements, label,
                                  &(ui_element_cache_data){
-                                     .label = label,
+                                     .label = string_copy(label),
                                      .size = {0},
                                      .last_instantiated_index = cx->frame_index,
                                  });
@@ -267,6 +273,15 @@ ui_interaction ui_button(ui_context *cx, string label) {
     return _ui_test_interaction(cx, id);
 }
 
+ui_interaction ui_button_centered(ui_context *cx, string label) {
+    size_t id = ui_element(
+        cx, label, UI_AXIS_HORIZONTAL, ui_make_size(ui_fit_text, ui_fit_text),
+        UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT | UI_FLAG_CENTERED_TEXT |
+            UI_FLAG_HOVERABLE | UI_FLAG_CLICKABLE);
+
+    return _ui_test_interaction(cx, id);
+}
+
 static uint32_t _ui_ancestor_size(ui_context *cx, size_t element_index,
                                   ui_axis axis) {
     if (element_index == SIZE_MAX || _parent(element_index) == SIZE_MAX) {
@@ -293,9 +308,9 @@ static void _ui_compute_simple_layout(ui_context *cx,
     switch (elm->size.semantic_size[axis].type) {
     case UI_SEMANTIC_SIZE_FIT_TEXT:
         if (axis == UI_AXIS_HORIZONTAL) {
-            elm->size.computed_size[axis] = elm->label.len * _FONT_WIDTH;
+            elm->size.computed_size[axis] = (elm->label.len + 2) * _FONT_WIDTH;
         } else if (axis == UI_AXIS_VERTICAL) {
-            elm->size.computed_size[axis] = _FONT_HEIGHT;
+            elm->size.computed_size[axis] = _FONT_HEIGHT + (_FONT_HEIGHT / 4);
         }
         break;
 
@@ -504,7 +519,16 @@ void ui_render(ui_context *cx, _ui_render_text_func text_func,
         ui_element_frame_data *elm = &cx->frame_elements.data[i];
 
         if (_flags(i, UI_FLAG_DRAW_TEXT)) {
-            text_func(text, (float[]){(float)elm->size.computed_pos[0],
+            uint32_t x_offset = 0;
+
+            if (_flags(i, UI_FLAG_CENTERED_TEXT)) {
+                uint32_t half_width = elm->size.computed_size[0] / 2;
+                uint32_t half_text_width = (text.len / 2) * _FONT_WIDTH;
+                x_offset = half_width - half_text_width;
+            }
+
+            text_func(text, (float[]){(float)elm->size.computed_pos[0] +
+                                          (float)x_offset,
                                       (float)elm->size.computed_pos[1]});
         }
 
@@ -537,6 +561,7 @@ void ui_prune(ui_context *cx) {
                 // %zu, frame index: %zu\n", (int)key.len, key.data,
                 // cached->last_instantiated_index, cx->frame_index);
 
+                free(cached->label.data);
                 ht_remove(&cx->cached_elements, key);
             }
         }
@@ -546,7 +571,9 @@ void ui_prune(ui_context *cx) {
     do {
         __auto_type elm = _elm(child_index);
         if (elm->label.owned) {
-            free(elm->label.data);
+            // FIXME: deal with potential memory leaks (really just use an temp
+            // allocator)
+            // free(elm->label.data);
         }
     } while ((child_index = _next(child_index)) < SIZE_MAX);
 

src/wayland-crap/xdg-shell.c

@@ -0,0 +1,173 @@
+/* Generated by wayland-scanner 1.22.0 */
+
+/*
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ * Copyright © 2015-2017 Samsung Electronics Co., Ltd
+ * Copyright © 2015-2017 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface wl_seat_interface;
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface xdg_popup_interface;
+extern const struct wl_interface xdg_positioner_interface;
+extern const struct wl_interface xdg_surface_interface;
+extern const struct wl_interface xdg_toplevel_interface;
+
+static const struct wl_interface *xdg_shell_types[] = {
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	&xdg_positioner_interface,
+	&xdg_surface_interface,
+	&wl_surface_interface,
+	&xdg_toplevel_interface,
+	&xdg_popup_interface,
+	&xdg_surface_interface,
+	&xdg_positioner_interface,
+	&xdg_toplevel_interface,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	&wl_output_interface,
+	&wl_seat_interface,
+	NULL,
+	&xdg_positioner_interface,
+	NULL,
+};
+
+static const struct wl_message xdg_wm_base_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "create_positioner", "n", xdg_shell_types + 4 },
+	{ "get_xdg_surface", "no", xdg_shell_types + 5 },
+	{ "pong", "u", xdg_shell_types + 0 },
+};
+
+static const struct wl_message xdg_wm_base_events[] = {
+	{ "ping", "u", xdg_shell_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_wm_base_interface = {
+	"xdg_wm_base", 6,
+	4, xdg_wm_base_requests,
+	1, xdg_wm_base_events,
+};
+
+static const struct wl_message xdg_positioner_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "set_size", "ii", xdg_shell_types + 0 },
+	{ "set_anchor_rect", "iiii", xdg_shell_types + 0 },
+	{ "set_anchor", "u", xdg_shell_types + 0 },
+	{ "set_gravity", "u", xdg_shell_types + 0 },
+	{ "set_constraint_adjustment", "u", xdg_shell_types + 0 },
+	{ "set_offset", "ii", xdg_shell_types + 0 },
+	{ "set_reactive", "3", xdg_shell_types + 0 },
+	{ "set_parent_size", "3ii", xdg_shell_types + 0 },
+	{ "set_parent_configure", "3u", xdg_shell_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_positioner_interface = {
+	"xdg_positioner", 6,
+	10, xdg_positioner_requests,
+	0, NULL,
+};
+
+static const struct wl_message xdg_surface_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "get_toplevel", "n", xdg_shell_types + 7 },
+	{ "get_popup", "n?oo", xdg_shell_types + 8 },
+	{ "set_window_geometry", "iiii", xdg_shell_types + 0 },
+	{ "ack_configure", "u", xdg_shell_types + 0 },
+};
+
+static const struct wl_message xdg_surface_events[] = {
+	{ "configure", "u", xdg_shell_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_surface_interface = {
+	"xdg_surface", 6,
+	5, xdg_surface_requests,
+	1, xdg_surface_events,
+};
+
+static const struct wl_message xdg_toplevel_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "set_parent", "?o", xdg_shell_types + 11 },
+	{ "set_title", "s", xdg_shell_types + 0 },
+	{ "set_app_id", "s", xdg_shell_types + 0 },
+	{ "show_window_menu", "ouii", xdg_shell_types + 12 },
+	{ "move", "ou", xdg_shell_types + 16 },
+	{ "resize", "ouu", xdg_shell_types + 18 },
+	{ "set_max_size", "ii", xdg_shell_types + 0 },
+	{ "set_min_size", "ii", xdg_shell_types + 0 },
+	{ "set_maximized", "", xdg_shell_types + 0 },
+	{ "unset_maximized", "", xdg_shell_types + 0 },
+	{ "set_fullscreen", "?o", xdg_shell_types + 21 },
+	{ "unset_fullscreen", "", xdg_shell_types + 0 },
+	{ "set_minimized", "", xdg_shell_types + 0 },
+};
+
+static const struct wl_message xdg_toplevel_events[] = {
+	{ "configure", "iia", xdg_shell_types + 0 },
+	{ "close", "", xdg_shell_types + 0 },
+	{ "configure_bounds", "4ii", xdg_shell_types + 0 },
+	{ "wm_capabilities", "5a", xdg_shell_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_toplevel_interface = {
+	"xdg_toplevel", 6,
+	14, xdg_toplevel_requests,
+	4, xdg_toplevel_events,
+};
+
+static const struct wl_message xdg_popup_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "grab", "ou", xdg_shell_types + 22 },
+	{ "reposition", "3ou", xdg_shell_types + 24 },
+};
+
+static const struct wl_message xdg_popup_events[] = {
+	{ "configure", "iiii", xdg_shell_types + 0 },
+	{ "popup_done", "", xdg_shell_types + 0 },
+	{ "repositioned", "3u", xdg_shell_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_popup_interface = {
+	"xdg_popup", 6,
+	3, xdg_popup_requests,
+	3, xdg_popup_events,
+};
+

vendor/cJSON/cJSON.h

@@ -0,0 +1,300 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 3 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+#define CJSON_CDECL __cdecl
+#define CJSON_STDCALL __stdcall
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type CJSON_STDCALL
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type CJSON_STDCALL
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type CJSON_STDCALL
+#endif
+#else /* !__WINDOWS__ */
+#define CJSON_CDECL
+#define CJSON_STDCALL
+
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 7
+#define CJSON_VERSION_PATCH 17
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON
+{
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks
+{
+      /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
+      void *(CJSON_CDECL *malloc_fn)(size_t sz);
+      void (CJSON_CDECL *free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* Check item type and return its value */
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item);
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
+/* Create an object/array that only references it's elements so
+ * they will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
+
+/* These utilities create an Array of count items.
+ * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detach items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+ * need to be released. With recurse!=0, it will duplicate any children connected to the item.
+ * The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
+
+/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
+ * The input pointer json cannot point to a read-only address area, such as a string constant, 
+ * but should point to a readable and writable address area. */
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring);
+
+/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/
+#define cJSON_SetBoolValue(object, boolValue) ( \
+    (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \
+    (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \
+    cJSON_Invalid\
+)
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif