4coder/platform_win32/win32_4ed.cpp

/*
 * Mr. 4th Dimention - Allen Webster
 *
 * 12.12.2014
 *
 * Win32 layer for 4coder
 *
 */

// TOP

#define IS_PLAT_LAYER

//
// Program setup
//

#define UNICODE

#define FPS 60
#define frame_useconds (1000000 / FPS)

#include "4coder_base_types.h"
#include "4coder_table.h"
#include "4coder_API/4coder_version.h"

#include <string.h>
#include "4coder_lib/4coder_utf8.h"

#if defined(FRED_SUPER)
# include "4coder_lib/4coder_heap.h"
# include "4coder_lib/4coder_heap.cpp"

# include "4coder_base_types.cpp"
# include "4coder_hash_functions.cpp"
# include "4coder_table.cpp"

# include "4coder_API/4coder_keycodes.h"
# include "4coder_API/4coder_default_colors.h"
# include "4coder_API/4coder_types.h"
#else
# include "4coder_default_bindings.cpp"
#endif

#include "4ed_font_interface.h"
#include "4ed_font_set.h"
#include "4ed_system.h"
#include "4ed_render_target.h"
#include "4ed_render_format.h"
#include "4ed.h"

#include <Windows.h>
#include "win32_gl.h"

# include "4coder_stringf.cpp"

#define GL_TEXTURE_MAX_LEVEL 0x813D

//////////////////////////////

enum{
    ErrorString_UseLog = 0,
    ErrorString_UseErrorBox = 1,
};

internal void
win32_output_error_string(i32 error_string_type);

//////////////////////////////

#include "win32_utf8.h"

#include "4ed_system_shared.h"

#include "4ed_shared_thread_constants.h"
#include "win32_threading_wrapper.h"

#define WM_4coder_ANIMATE (WM_USER + 0)

struct Control_Keys{
    b8 l_ctrl;
    b8 r_ctrl;
    b8 l_alt;
    b8 r_alt;
};
global Control_Keys null_control_keys = {};

struct Win32_Input_Chunk_Transient{
    Key_Input_Data key_data;
    b8 mouse_l_press;
    b8 mouse_l_release;
    b8 mouse_r_press;
    b8 mouse_r_release;
    b8 out_of_window;
    i8 mouse_wheel;
    b8 trying_to_kill;
};
global Win32_Input_Chunk_Transient null_input_chunk_transient = {};

struct Win32_Input_Chunk_Persistent{
    Vec2_i32 mouse;
    Control_Keys controls;
    b8 mouse_l;
    b8 mouse_r;
    b8 control_keys[MDFR_INDEX_COUNT];
};

struct Win32_Input_Chunk{
    Win32_Input_Chunk_Transient trans;
    Win32_Input_Chunk_Persistent pers;
};

////////////////////////////////

#define SLASH '\\'
#define DLL "dll"

global System_Functions sysfunc;
#include "4ed_shared_library_constants.h"
#include "win32_library_wrapper.h"

#include "4ed_standard_libraries.cpp"
#include "4ed_coroutine.cpp"
#include "4ed_font_face.cpp"

#include "4ed_mem.cpp"
#include "4coder_hash_functions.cpp"

#include "4ed_system_allocator.cpp"
#include "4ed_font_set.cpp"

////////////////////////////////

typedef i32 Win32_Object_Kind;
enum{
    Win32ObjectKind_ERROR = 0,
    Win32ObjectKind_Timer = 1,
};

struct Win32_Object{
    Node node;
    Win32_Object_Kind kind;
    union{
        // NOTE(allen): Timer object
        struct{
            UINT_PTR id;
        } timer;
    };
};

struct Win32_Vars{
    Win32_Input_Chunk input_chunk;
    b8 lctrl_lalt_is_altgr;
    b8 got_useful_event;
    
    b8 full_screen;
    b8 do_toggle;
    WINDOWPLACEMENT bordered_win_pos;
    b32 send_exit_signal;
    
    HCURSOR cursor_ibeam;
    HCURSOR cursor_arrow;
    HCURSOR cursor_leftright;
    HCURSOR cursor_updown;
    i32 cursor_show;
    i32 prev_cursor_show;
    
    String_Const_u8 binary_path;
    
    u8 *clip_buffer;
    u32 clip_max;
    String_Const_u8 clipboard_contents;
    b32 next_clipboard_is_self;
    DWORD clipboard_sequence;
    
    Arena clip_post_arena;
    String_Const_u8 clip_post;
    
    HWND window_handle;
    i32 dpi_x;
    i32 dpi_y;
    
    f64 count_per_usecond;
    b32 first;
    i32 running_cli;
    
    Node free_win32_objects;
    Node timer_objects;
    UINT_PTR timer_counter;
    
    u32 log_position;
};

////////////////////////////////

global Win32_Vars win32vars;
global Render_Target target;
global Application_Memory memory_vars;
global Plat_Settings plat_settings;

global Libraries libraries;
global App_Functions app;
global Custom_API custom_api;

global Coroutine_System_Auto_Alloc coroutines;

////////////////////////////////

#include "win32_error_box.cpp"

////////////////////////////////

internal void
win32_output_error_string(b32 use_error_box){
    DWORD error = GetLastError();
    
    char *str = 0;
    char *str_ptr = (char*)&str;
    if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0, error, 0, str_ptr, 0, 0)){
        //LOGF("win32 error:\n%s\n", str);
        if (use_error_box){
            system_error_box(str, false);
        }
    }
    else{
        //LOGF("win32 error raw: %d\n", error);
    }
}

////////////////////////////////

internal HANDLE
handle_type(Plat_Handle h){
    HANDLE result;
    block_copy(&result, &h, sizeof(result));
    return(result);
}

internal Plat_Handle
handle_type(HANDLE h){
    Plat_Handle result = {};
    block_copy(&result, &h, sizeof(h));
    return(result);
}

internal void*
handle_type_ptr(Plat_Handle h){
    void *result;
    block_copy(&result, &h, sizeof(result));
    return(result);
}

internal Plat_Handle
handle_type_ptr(void *ptr){
    Plat_Handle result = {};
    block_copy(&result, &ptr, sizeof(ptr));
    return(result);
}

////////////////////////////////

#include "win32_4ed_functions.cpp"

////////////////////////////////

internal void
system_schedule_step(){
    PostMessage(win32vars.window_handle, WM_4coder_ANIMATE, 0, 0);
}

////////////////////////////////

#include "4ed_work_queues.cpp"

////////////////////////////////

internal void
win32_toggle_fullscreen(){
    HWND win = win32vars.window_handle;
    DWORD style = GetWindowLongW(win, GWL_STYLE);
    b32 is_full = ((style & WS_OVERLAPPEDWINDOW) == 0);
    if (!is_full){
        MONITORINFO info = {sizeof(MONITORINFO)};
        if (GetWindowPlacement(win, &win32vars.bordered_win_pos) && GetMonitorInfo(MonitorFromWindow(win, MONITOR_DEFAULTTOPRIMARY), &info)){
            SetWindowLongW(win, GWL_STYLE, style & ~WS_OVERLAPPEDWINDOW);
            
            i32 x = info.rcMonitor.left;
            i32 y = info.rcMonitor.top;
            i32 w = info.rcMonitor.right - info.rcMonitor.left;
            i32 h = info.rcMonitor.bottom - info.rcMonitor.top;
            
            SetWindowPos(win, HWND_TOP, x, y, w, h, SWP_NOOWNERZORDER | SWP_FRAMECHANGED | SWP_SHOWWINDOW);
            win32vars.full_screen = true;
        }
    }
    else{
        SetWindowLongW(win, GWL_STYLE, style | WS_OVERLAPPEDWINDOW);
        SetWindowPlacement(win, &win32vars.bordered_win_pos);
        SetWindowPos(win, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
        win32vars.full_screen = false;
    }
}

// TODO(allen): add a "shown but auto-hides on timer" setting here.
internal
Sys_Show_Mouse_Cursor_Sig(system_show_mouse_cursor){
    win32vars.cursor_show = show;
}

internal
Sys_Set_Fullscreen_Sig(system_set_fullscreen){
    // NOTE(allen): If the new value of full_screen does not match the current value,
    // set toggle to true.
    win32vars.do_toggle = (win32vars.full_screen != full_screen);
    b32 success = true;
    return(success);
}

internal
Sys_Is_Fullscreen_Sig(system_is_fullscreen){
    // NOTE(allen): Report the fullscreen status as it would be set at the beginning of the next frame.
    // That is, take into account all fullscreen toggle requests that have come in already this frame.
    // Read: "full_screen XOR do_toggle"
    b32 result = (win32vars.full_screen != win32vars.do_toggle);
    return(result);
}

#include "4ed_coroutine_functions.cpp"

#include "4ed_system_shared.cpp"

//
// File Change Listener
//

union Directory_Track_Node{
    struct{
        Directory_Track_Node *next;
        Directory_Track_Node *prev;
    };
    struct{
        OVERLAPPED overlapped;
        HANDLE dir_handle;
        char buffer[(32 << 10) + 12];
        String_Const_u8 dir_name;
        i32 ref_count;
    };
};

union File_Track_Node{
    struct{
        File_Track_Node *next;
        File_Track_Node *prev;
    };
    struct{
        String_Const_u8 file_name;
        i32 ref_count;
        Directory_Track_Node *parent_dir;
    };
};
#if !defined(CString_Key_Reference_GAURD)
#define CString_Key_Reference_GAURD
struct CString_Key_Reference{
    char*key;
    i32 size;
};
#endif
struct CString_Ptr_Lookup_Result{
    b32 success;
    void **val;
};
struct CString_Ptr_Table{
    void *mem;
    u64 *hashes;
    CString_Key_Reference*keys;
    void **vals;
    i32 count;
    i32 dirty_slot_count;
    i32 max;
};

typedef i32 File_Track_Instruction;
enum{
    FileTrackInstruction_None,
    FileTrackInstruction_BeginTracking,
    FileTrackInstruction_Cancel,
};

union File_Track_Instruction_Node{
    struct{
        File_Track_Instruction instruction;
        Directory_Track_Node *dir_node;
    };
    struct{
        File_Track_Instruction_Node *next;
        File_Track_Instruction_Node *prev;
    };
};

struct File_Track_Note_Node{
    File_Track_Note_Node *next;
    File_Track_Note_Node *prev;
    String_Const_u8 file_name;
};

Heap file_track_heap = {};
Arena file_track_scratch = {};

CString_Ptr_Table file_track_dir_table = {};
Directory_Track_Node *file_track_dir_free_first = 0;
Directory_Track_Node *file_track_dir_free_last = 0;
CString_Ptr_Table file_track_table = {};
File_Track_Node *file_track_free_first = 0;
File_Track_Node *file_track_free_last = 0;
File_Track_Instruction_Node *file_track_ins_free_first = 0;
File_Track_Instruction_Node *file_track_ins_free_last = 0;
File_Track_Note_Node *file_track_note_first = 0;
File_Track_Note_Node *file_track_note_last = 0;
File_Track_Note_Node *file_track_note_free_first = 0;
File_Track_Note_Node *file_track_note_free_last = 0;

CRITICAL_SECTION file_track_critical_section;
HANDLE file_track_iocp;
HANDLE file_track_thread;

global_const u32 file_track_flags = 0
|FILE_NOTIFY_CHANGE_FILE_NAME
|FILE_NOTIFY_CHANGE_DIR_NAME
|FILE_NOTIFY_CHANGE_ATTRIBUTES
|FILE_NOTIFY_CHANGE_SIZE
|FILE_NOTIFY_CHANGE_LAST_WRITE
|FILE_NOTIFY_CHANGE_CREATION
|FILE_NOTIFY_CHANGE_SECURITY
;

////////////////////////////////

internal CString_Ptr_Table
make_CString_Ptr_table(void *mem, umem size){
    CString_Ptr_Table table = {};
    i32 max = (i32)(size/32ULL);
    if (max > 0){
        table.mem = mem;
        u8 *cursor = (u8*)mem;
        table.hashes = (u64*)cursor;
        cursor += 8*max;
        table.keys = (CString_Key_Reference*)cursor;
        cursor += 16*max;
        table.vals = (void **)cursor;
        table.count = 0;
        table.max = max;
        block_fill_ones(table.hashes, sizeof(*table.hashes)*max);
    }
    return(table);
}

internal i32
max_to_memsize_CString_Ptr_table(i32 max){
    return(max*32ULL);
}

internal b32
at_max_CString_Ptr_table(CString_Ptr_Table *table){
    if (table->max > 0 && (table->count + 1)*8 <= table->max*7){
        return(false);
    }
    return(true);
}

internal b32
insert_CString_Ptr_table(CString_Ptr_Table *table, char*key, i32 key_size, void **val){
    i32 max = table->max;
    if (max > 0){
        i32 count = table->count;
        if ((count + 1)*8 <= max*7){
            u64 hash = table_hash_u8((u8*)key, key_size);
            if (hash >= 18446744073709551614ULL){ hash += 2; }
            i32 first_index = hash%max;
            i32 index = first_index;
            u64 *hashes = table->hashes;
            for (;;){
                if (hashes[index] == 18446744073709551615ULL){
                    table->dirty_slot_count += 1;
                }
                if (hashes[index] == 18446744073709551615ULL || hashes[index] == 18446744073709551614ULL){
                    hashes[index] = hash;
                    CString_Key_Reference new_key = {key, key_size};
                    table->keys[index] = new_key;
                    table->vals[index] = *val;
                    table->count += 1;
                    return(true);
                }
                if (hashes[index] == hash) return(false);
                index = (index + 1)%max;
                if (index == first_index) return(false);
            }
        }
    }
    return(false);
}

internal CString_Ptr_Lookup_Result
lookup_CString_Ptr_table(CString_Ptr_Table *table, char*key, i32 key_size){
    CString_Ptr_Lookup_Result result = {};
    i32 max = table->max;
    if (max > 0){
        u64 hash = table_hash_u8((u8*)key, key_size);
        if (hash >= 18446744073709551614ULL){ hash += 2; }
        i32 first_index = hash%max;
        i32 index = first_index;
        u64 *hashes = table->hashes;
        for (;;){
            if (hashes[index] == 18446744073709551615ULL) break;
            if (hashes[index] == hash){
                CString_Key_Reference *key_check = &table->keys[index];
                b32 key_match = (key_size == key_check->size && block_compare(key, key_check->key, key_size*sizeof(*key)) == 0);
                if (key_match){
                    result.success = true;
                    result.val = &table->vals[index];
                    return(result);
                }
            }
            index = (index + 1)%max;
            if (index == first_index) break;
        }
    }
    return(result);
}

internal b32
erase_CString_Ptr_table(CString_Ptr_Table *table, char*key, i32 key_size){
    i32 max = table->max;
    if (max > 0 && table->count > 0){
        u64 hash = table_hash_u8((u8*)key, key_size);
        if (hash >= 18446744073709551614ULL){ hash += 2; }
        i32 first_index = hash%max;
        i32 index = first_index;
        u64 *hashes = table->hashes;
        for (;;){
            if (hashes[index] == 18446744073709551615ULL) break;
            if (hashes[index] == hash){
                CString_Key_Reference *key_check = &table->keys[index];
                b32 key_match = (key_size == key_check->size && block_compare(key, key_check->key, key_size*sizeof(*key)) == 0);
                if (key_match){
                    hashes[index] = 18446744073709551614ULL;
                    table->count -= 1;
                    return(true);
                }
            }
            index = (index + 1)%max;
            if (index == first_index) break;
        }
    }
    return(false);
}

internal b32
move_CString_Ptr_table(CString_Ptr_Table *dst_table, CString_Ptr_Table *src_table){
    if ((src_table->count + dst_table->count)*8 <= dst_table->max*7){
        i32 max = src_table->max;
        u64 *hashes = src_table->hashes;
        for (i32 index = 0; index < max; index += 1){
            if (hashes[index] != 18446744073709551615ULL && hashes[index] != 18446744073709551614ULL){
                char*key = src_table->keys[index].key;
                i32 key_size = src_table->keys[index].size;
                void **val = &src_table->vals[index];
                insert_CString_Ptr_table(dst_table, key, key_size, val);
            }
        }
        return(true);
    }
    return(false);
}

internal b32
lookup_CString_Ptr_table(CString_Ptr_Table *table, char *key, i32 key_size, void * *val_out){
    CString_Ptr_Lookup_Result result = lookup_CString_Ptr_table(table, key, key_size);
    if (result.success){
        *val_out = *result.val;
    }
    return(result.success);
}

internal b32
insert_CString_Ptr_table(CString_Ptr_Table *table, char*key, i32 key_size, void * val){
    return(insert_CString_Ptr_table(table, key, key_size, &val));
}

internal b32
alloc_insert_CString_Ptr_table(CString_Ptr_Table *table, char*key, i32 key_size, void *val){
    if (at_max_CString_Ptr_table(table)){
        i32 new_max = (table->max + 1)*2;
        i32 new_size = max_to_memsize_CString_Ptr_table(new_max);
        void *new_mem = system_memory_allocate(new_size);
        CString_Ptr_Table new_table = make_CString_Ptr_table(new_mem, new_size);
        if (table->mem != 0){
            i32 old_size = max_to_memsize_CString_Ptr_table(table->max);
            system_memory_free(table->mem, old_size);
        }
        *table = new_table;
    }
    return(insert_CString_Ptr_table(table, key, key_size, val));
}

////////////////////////////////

internal String_Const_u8
file_track_store_string_copy(String_Const_u8 string){
    i32 alloc_size = (i32)string.size + 1;
    alloc_size = round_up_i32(alloc_size, 16);
    char *buffer = (char*)heap_allocate(&file_track_heap, alloc_size);
    if (buffer == 0){
        i32 size = MB(1);
        void *new_block = system_memory_allocate(size);
        heap_extend(&file_track_heap, new_block, size);
        buffer = (char*)heap_allocate(&file_track_heap, alloc_size);
    }
    Assert(buffer != 0);
    memcpy(buffer, string.str, string.size);
    buffer[string.size] = 0;
    return(SCu8(buffer, string.size));
}

internal void
file_track_free_string(String_Const_u8 string){
    Assert(string.str != 0);
    heap_free(&file_track_heap, string.str);
}

internal Directory_Track_Node*
file_track_store_new_dir_node(String_Const_u8 dir_name_string, HANDLE dir_handle){
    if (file_track_dir_free_first == 0){
        u32 size = MB(1);
        void *new_block = system_memory_allocate(size);
        u32 count = size/sizeof(Directory_Track_Node);
        Directory_Track_Node *nodes = (Directory_Track_Node*)new_block;
        Directory_Track_Node *node = nodes;
        node->next = node + 1;
        node->prev = 0;
        node += 1;
        for (u32 i = 1; i < count - 1; i += 1, node += 1){
            node->next = node + 1;
            node->prev = node - 1;
        }
        node->next = 0;
        node->prev = node - 1;
        file_track_dir_free_first = nodes;
        file_track_dir_free_last = node;
    }
    Directory_Track_Node *new_node = file_track_dir_free_first;
    zdll_remove(file_track_dir_free_first, file_track_dir_free_last, new_node);
    alloc_insert_CString_Ptr_table(&file_track_dir_table, (char*)dir_name_string.str, (i32)dir_name_string.size, new_node);
    memset(&new_node->overlapped, 0, sizeof(new_node->overlapped));
    new_node->dir_handle = dir_handle;
    new_node->dir_name = file_track_store_string_copy(dir_name_string);
    new_node->ref_count = 0;
    return(new_node);
}

internal void
file_track_free_dir_node(Directory_Track_Node *node){
    erase_CString_Ptr_table(&file_track_dir_table, (char*)node->dir_name.str, (i32)node->dir_name.size);
    file_track_free_string(node->dir_name);
    memset(&node->dir_name, 0, sizeof(node->dir_name));
    zdll_push_back(file_track_dir_free_first, file_track_dir_free_last, node);
}

internal File_Track_Node*
file_track_store_new_file_node(String_Const_u8 file_name_string, Directory_Track_Node *existing_dir_node){
    if (file_track_free_first == 0){
        u32 size = KB(16);
        void *new_block = system_memory_allocate(size);
        u32 count = size/sizeof(File_Track_Node);
        File_Track_Node *nodes = (File_Track_Node*)new_block;
        File_Track_Node *node = nodes;
        node->next = node + 1;
        node->prev = 0;
        node += 1;
        for (u32 i = 1; i < count - 1; i += 1, node += 1){
            node->next = node + 1;
            node->prev = node - 1;
        }
        node->next = 0;
        node->prev = node - 1;
        file_track_free_first = nodes;
        file_track_free_last = node;
    }
    File_Track_Node *new_node = file_track_free_first;
    zdll_remove(file_track_free_first, file_track_free_last, new_node);
    alloc_insert_CString_Ptr_table(&file_track_table, (char*)file_name_string.str, (i32)file_name_string.size, new_node);
    new_node->file_name = file_track_store_string_copy(file_name_string);
    new_node->ref_count = 1;
    new_node->parent_dir = existing_dir_node;
    existing_dir_node->ref_count += 1;
    return(new_node);
}

internal void
file_track_free_file_node(File_Track_Node *node){
    erase_CString_Ptr_table(&file_track_table, (char*)node->file_name.str, (i32)node->file_name.size);
    file_track_free_string(node->file_name);
    memset(&node->file_name, 0, sizeof(node->file_name));
    zdll_push_back(file_track_free_first, file_track_free_last, node);
}

internal File_Track_Note_Node*
file_track_store_new_note_node(String_Const_u8 file_name){
    if (file_track_note_free_first == 0){
        u32 size = KB(16);
        void *new_block = system_memory_allocate(size);
        u32 count = size/sizeof(File_Track_Note_Node);
        File_Track_Note_Node *nodes = (File_Track_Note_Node*)new_block;
        File_Track_Note_Node *node = nodes;
        node->next = node + 1;
        node->prev = 0;
        node += 1;
        for (u32 i = 1; i < count - 1; i += 1, node += 1){
            node->next = node + 1;
            node->prev = node - 1;
        }
        node->next = 0;
        node->prev = node - 1;
        file_track_note_free_first = nodes;
        file_track_note_free_last = node;
    }
    File_Track_Note_Node *new_node = file_track_note_free_first;
    zdll_remove(file_track_note_free_first, file_track_note_free_last, new_node);
    zdll_push_back(file_track_note_first, file_track_note_last, new_node);
    new_node->file_name = file_track_store_string_copy(file_name);
    return(new_node);
}

internal void
file_track_free_note_node(File_Track_Note_Node *node){
    file_track_free_string(node->file_name);
    memset(&node->file_name, 0, sizeof(node->file_name));
    zdll_remove(file_track_note_first, file_track_note_last, node);
    zdll_push_back(file_track_note_free_first, file_track_note_free_last, node);
}

internal File_Track_Instruction_Node*
file_track_new_instruction_node(){
    if (file_track_ins_free_first == 0){
        u32 size = KB(16);
        void *new_block = system_memory_allocate(size);
        u32 count = size/sizeof(File_Track_Instruction_Node);
        File_Track_Instruction_Node *nodes = (File_Track_Instruction_Node*)new_block;
        File_Track_Instruction_Node *node = nodes;
        node->next = node + 1;
        node->prev = 0;
        node += 1;
        for (u32 i = 1; i < count - 1; i += 1, node += 1){
            node->next = node + 1;
            node->prev = node - 1;
        }
        node->next = 0;
        node->prev = node - 1;
        file_track_ins_free_first = nodes;
        file_track_ins_free_last = node;
    }
    File_Track_Instruction_Node *new_node = file_track_ins_free_first;
    zdll_remove(file_track_ins_free_first, file_track_ins_free_last, new_node);
    return(new_node);
}

internal void
file_track_free_instruction_node(File_Track_Instruction_Node *node){
    zdll_push_back(file_track_ins_free_first, file_track_ins_free_last, node);
}

internal Directory_Track_Node*
file_track_dir_lookup(String_Const_u8 dir_name_string){
    void *ptr = 0;
    lookup_CString_Ptr_table(&file_track_dir_table, (char*)dir_name_string.str, (i32)dir_name_string.size, &ptr);
    return((Directory_Track_Node*)ptr);
}

internal File_Track_Node*
file_track_file_lookup(String_Const_u8 file_name_string){
    void *ptr = 0;
    lookup_CString_Ptr_table(&file_track_table, (char*)file_name_string.str, (i32)file_name_string.size, &ptr);
    return((File_Track_Node*)ptr);
}

internal DWORD CALL_CONVENTION
file_track_worker(void*){
    for (;;){
        DWORD number_of_bytes = 0;
        ULONG_PTR key = 0;
        OVERLAPPED *overlapped = 0;
        if (GetQueuedCompletionStatus(file_track_iocp, &number_of_bytes, &key, &overlapped, INFINITE)){
            EnterCriticalSection(&file_track_critical_section);
            if (number_of_bytes == 0 && key == 0){
                File_Track_Instruction_Node *instruction = (File_Track_Instruction_Node*)overlapped;
                switch (instruction->instruction){
                    case FileTrackInstruction_None:
                    {}break;
                    case FileTrackInstruction_BeginTracking:
                    {
                        Directory_Track_Node *dir_node = instruction->dir_node;
                        CreateIoCompletionPort(dir_node->dir_handle, file_track_iocp, (ULONG_PTR)&dir_node->overlapped, 1);
                        ReadDirectoryChangesW(dir_node->dir_handle, dir_node->buffer, sizeof(dir_node->buffer), FALSE,
                                              file_track_flags, 0, &dir_node->overlapped, 0);
                    }break;
                    case FileTrackInstruction_Cancel:
                    {
                        Directory_Track_Node *dir_node = instruction->dir_node;
                        CancelIo(dir_node->dir_handle);
                        CloseHandle(dir_node->dir_handle);
                        file_track_free_dir_node(dir_node);
                    }break;
                }
                file_track_free_instruction_node(instruction);
            }
            else if (number_of_bytes != 0 && key != 0){
                Directory_Track_Node *dir_node = (Directory_Track_Node*)overlapped;
                Directory_Track_Node node_copy = *dir_node;
                memset(&dir_node->overlapped, 0, sizeof(dir_node->overlapped));
                ReadDirectoryChangesW(dir_node->dir_handle, dir_node->buffer, sizeof(dir_node->buffer), FALSE,
                                      file_track_flags, 0, &dir_node->overlapped, 0);
                
                FILE_NOTIFY_INFORMATION *info = (FILE_NOTIFY_INFORMATION*)node_copy.buffer;
                
                i32 len = info->FileNameLength/2;
                i32 dir_len = GetFinalPathNameByHandle_utf8(&file_track_scratch, dir_node->dir_handle, 0, 0, FILE_NAME_NORMALIZED);
                
                i32 req_size = dir_len + (len + 1)*2 + 4;
                
                Temp_Memory temp = begin_temp(&file_track_scratch);
                u8 *buffer = push_array(&file_track_scratch, u8, req_size);
                
                if (buffer != 0){
                    u32 path_pos = GetFinalPathNameByHandle_utf8(&file_track_scratch, dir_node->dir_handle, buffer, req_size, FILE_NAME_NORMALIZED);
                    buffer[path_pos] = '\\';
                    path_pos += 1;
                    
                    u32 name_max = req_size - path_pos;
                    u8 *name_buffer = buffer + path_pos;
                    
                    b32 convert_error = false;
                    u32 name_pos = (u32)utf16_to_utf8_minimal_checking(name_buffer, name_max, (u16*)info->FileName, len, &convert_error);
                    if (name_pos < name_max && !convert_error){
                        u32 pos = path_pos + name_pos;
                        if (buffer[0] == '\\'){
                            for (u32 i = 0; i + 4 < pos; i += 1){
                                buffer[i] = buffer[i + 4];
                            }
                            pos -= 4;
                        }
                        String_Const_u8 file_name = SCu8(buffer, pos);
                        file_track_store_new_note_node(file_name);
                        
                        system_schedule_step();
                    }
                }
                
                end_temp(temp);
            }
            LeaveCriticalSection(&file_track_critical_section);
        }
    }
}

internal void
file_track_init(){
    heap_init(&file_track_heap);
    file_track_scratch = make_arena_system(&sysfunc);
    InitializeCriticalSection(&file_track_critical_section);
    file_track_iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 1);
    file_track_thread = CreateThread(0, 0, file_track_worker, 0, 0, 0);
}

internal
Sys_Add_Listener_Sig(system_add_listener){
    b32 added_new_listener = false;
    
    EnterCriticalSection(&file_track_critical_section);
    
    String_Const_u8 file_name_string = SCu8(filename);
    File_Track_Node *existing_file_node = file_track_file_lookup(file_name_string);
    
    if (existing_file_node != 0){
        existing_file_node->ref_count += 1;
        added_new_listener = true;
    }
    else{
        String_Const_u8 dir_name_string = string_remove_last_folder(file_name_string);
        Directory_Track_Node *existing_dir_node = file_track_dir_lookup(dir_name_string);
        
        if (existing_dir_node == 0){
            Temp_Memory temp = begin_temp(&file_track_scratch);
            String_Const_u8 dir_name_string_terminated = push_string_copy(&file_track_scratch, dir_name_string);
            HANDLE dir_handle = CreateFile_utf8(&file_track_scratch, (u8*)dir_name_string_terminated.str,
                                                FILE_LIST_DIRECTORY,
                                                FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 0,
                                                OPEN_EXISTING,
                                                FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_OVERLAPPED, 0);
            
            if (dir_handle != 0 && dir_handle != INVALID_HANDLE_VALUE){
                Directory_Track_Node *new_node = file_track_store_new_dir_node(dir_name_string, dir_handle);
                File_Track_Instruction_Node *instruction_node = file_track_new_instruction_node();
                instruction_node->instruction = FileTrackInstruction_BeginTracking;
                instruction_node->dir_node = new_node;
                PostQueuedCompletionStatus(file_track_iocp, 0, 0, (LPOVERLAPPED)instruction_node);
                existing_dir_node = new_node;
            }
            
            end_temp(temp);
        }
        
        if (existing_dir_node != 0){
            file_track_store_new_file_node(file_name_string, existing_dir_node);
            added_new_listener = true;
        }
    }
    
    LeaveCriticalSection(&file_track_critical_section);
    
    return(added_new_listener);
}

internal
Sys_Remove_Listener_Sig(system_remove_listener){
    b32 removed_listener = false;
    
    EnterCriticalSection(&file_track_critical_section);
    
    String_Const_u8 file_name_string = SCu8(filename);
    File_Track_Node *existing_file_node = file_track_file_lookup(file_name_string);
    
    if (existing_file_node != 0){
        existing_file_node->ref_count -= 1;
        if (existing_file_node->ref_count == 0){
            Directory_Track_Node *existing_dir_node = existing_file_node->parent_dir;
            existing_dir_node->ref_count -= 1;
            if (existing_dir_node->ref_count == 0){
                File_Track_Instruction_Node *instruction_node = file_track_new_instruction_node();
                instruction_node->instruction = FileTrackInstruction_Cancel;
                instruction_node->dir_node = existing_dir_node;
                PostQueuedCompletionStatus(file_track_iocp, 0, 0, (LPOVERLAPPED)instruction_node);
            }
            file_track_free_file_node(existing_file_node);
        }
        removed_listener = true;
    }
    
    LeaveCriticalSection(&file_track_critical_section);
    
    return(removed_listener);
}

internal
Sys_Get_File_Change_Sig(system_get_file_change){
    b32 has_or_got_a_change = false;
    
    EnterCriticalSection(&file_track_critical_section);
    
    if (file_track_note_first != 0){
        has_or_got_a_change = true;
        File_Track_Note_Node *node = file_track_note_first;
        *required_size = (i32)node->file_name.size + 1;
        if (node->file_name.size < max){
            memcpy(buffer, node->file_name.str, node->file_name.size);
            buffer[node->file_name.size] = 0;
            file_track_free_note_node(node);
        }
        else{
            *mem_too_small = true;
        }
    }
    
    LeaveCriticalSection(&file_track_critical_section);
    
    return(has_or_got_a_change);
}

//
// Clipboard
//

internal void
win32_post_clipboard(char *text, i32 len){
    if (OpenClipboard(win32vars.window_handle)){
        if (!EmptyClipboard()){
            win32_output_error_string(ErrorString_UseLog);
        }
        HANDLE memory_handle = GlobalAlloc(GMEM_MOVEABLE, len  + 1);
        if (memory_handle){
            char *dest = (char*)GlobalLock(memory_handle);
            memmove(dest, text, len);
            dest[len] = 0;
            GlobalUnlock(memory_handle);
            SetClipboardData(CF_TEXT, memory_handle);
            win32vars.next_clipboard_is_self = true;
        }
        CloseClipboard();
    }
}

internal
Sys_Post_Clipboard_Sig(system_post_clipboard){
    Arena *arena = &win32vars.clip_post_arena;
    if (arena->base_allocator == 0){
        *arena = make_arena_system(&sysfunc);
    }
    else{
        linalloc_clear(arena);
    }
    win32vars.clip_post.str = push_array(arena, u8, str.size + 1);
    if (win32vars.clip_post.str != 0){
        block_copy(win32vars.clip_post.str, str.str, str.size);
        win32vars.clip_post.str[str.size] = 0;
        win32vars.clip_post.size = str.size;
    }
    else{
        //LOGF("Failed to allocate buffer for clipboard post (%d)\n", (i32)str.size + 1);
    }
}

internal b32
win32_read_clipboard_contents(void){
    Arena *scratch = &shared_vars.scratch;
    Temp_Memory temp = begin_temp(scratch);
    
    b32 result = false;
    
    b32 has_text = false;
    b32 has_unicode = IsClipboardFormatAvailable(CF_UNICODETEXT);
    if (!has_unicode){
        has_text = IsClipboardFormatAvailable(CF_TEXT);
    }
    b32 can_read = has_unicode || has_text;
    
    if (can_read){
        if (OpenClipboard(win32vars.window_handle)){
            result = true;
            HANDLE clip_data = 0;
            i32 contents_length = 0;
            if (has_unicode){
                clip_data = GetClipboardData(CF_UNICODETEXT);
                if (clip_data != 0){
                    u16 *clip_16 = (u16*)GlobalLock(clip_data);
                    if (clip_16 != 0){
                        u32 clip_16_len = 0;
                        for(;clip_16[clip_16_len];++clip_16_len);
                        
                        b32 error = false;
                        u32 clip_8_len = (u32)utf16_to_utf8_minimal_checking(win32vars.clip_buffer, win32vars.clip_max-1, clip_16, clip_16_len, &error);
                        
                        for (;clip_8_len >= win32vars.clip_max && !error;){
                            system_memory_free(win32vars.clip_buffer, win32vars.clip_max);
                            win32vars.clip_max = round_up_u32(clip_8_len + 1, KB(4));
                            win32vars.clip_buffer = (u8*)system_memory_allocate(win32vars.clip_max);
                            clip_8_len = (u32)utf16_to_utf8_minimal_checking(win32vars.clip_buffer, win32vars.clip_max - 1, clip_16, clip_16_len, &error);
                        }
                        
                        if (clip_8_len < win32vars.clip_max && !error){
                            win32vars.clip_buffer[clip_8_len] = 0;
                            contents_length = clip_8_len + 1;
                        }
                    }
                }
            }
            else{
                clip_data = GetClipboardData(CF_TEXT);
                if (clip_data != 0){
                    char *clip_ascii = (char*)GlobalLock(clip_data);
                    if (clip_ascii != 0){
                        u32 clip_ascii_len = 0;
                        for(;clip_ascii[clip_ascii_len];++clip_ascii_len);
                        
                        if (clip_ascii_len >= win32vars.clip_max){
                            system_memory_free(win32vars.clip_buffer, win32vars.clip_max);
                            win32vars.clip_max = round_up_u32(clip_ascii_len + 1, KB(4));
                            win32vars.clip_buffer = (u8*)system_memory_allocate(win32vars.clip_max);
                        }
                        memcpy(win32vars.clip_buffer, clip_ascii, clip_ascii_len + 1);
                        contents_length = clip_ascii_len + 1;
                    }
                }
            }
            
            if (contents_length > 0){
                win32vars.clipboard_contents = SCu8(win32vars.clip_buffer, contents_length - 1);
            }
            
            GlobalUnlock(clip_data);
            
            CloseClipboard();
        }
    }
    
    end_temp(temp);
    
    return(result);
}


//
// Command Line Exectuion
//

internal
Sys_CLI_Call_Sig(system_cli_call, path, script_name, cli_out){
    Assert(sizeof(Plat_Handle) >= sizeof(HANDLE));
    
    char cmd[] = "c:\\windows\\system32\\cmd.exe";
    char *env_variables = 0;
    char command_line[2048];
    
    Arena *scratch = &shared_vars.scratch;
    
    Temp_Memory temp = begin_temp(scratch);
    String_Const_u8 s = push_u8_stringf(scratch, "/C %s", script_name);
    
    b32 success = false;
    
    *(HANDLE*)&cli_out->proc = INVALID_HANDLE_VALUE;
    *(HANDLE*)&cli_out->out_read = INVALID_HANDLE_VALUE;
    *(HANDLE*)&cli_out->out_write = INVALID_HANDLE_VALUE;
    *(HANDLE*)&cli_out->in_read = INVALID_HANDLE_VALUE;
    *(HANDLE*)&cli_out->in_write = INVALID_HANDLE_VALUE;
    
    SECURITY_ATTRIBUTES security_atrb = {};
    security_atrb.nLength = sizeof(SECURITY_ATTRIBUTES);
    security_atrb.bInheritHandle = TRUE;
    
    HANDLE out_read = INVALID_HANDLE_VALUE;
    HANDLE out_write = INVALID_HANDLE_VALUE;
    if (CreatePipe(&out_read, &out_write, &security_atrb, 0)){
        if (SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)){
            STARTUPINFO startup = {};
            startup.cb = sizeof(STARTUPINFO);
            startup.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
            
            HANDLE in_read = CreateFileA("nul", GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, &security_atrb, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
            
            startup.hStdInput = in_read;
            startup.hStdOutput = out_write;
            startup.hStdError = out_write;
            startup.wShowWindow = SW_HIDE;
            
            PROCESS_INFORMATION info = {};
            if (CreateProcess_utf8(&shared_vars.scratch, (u8*)cmd, (u8*)command_line, 0, 0, TRUE, 0, env_variables, (u8*)path, &startup, &info)){
                success = true;
                CloseHandle(info.hThread);
                *(HANDLE*)&cli_out->proc = info.hProcess;
                *(HANDLE*)&cli_out->out_read = out_read;
                *(HANDLE*)&cli_out->out_write = out_write;
                
                ++win32vars.running_cli;
            }
            else{
                CloseHandle(out_read);
                CloseHandle(out_write);
                CloseHandle(in_read);
            }
        }
        else{
            // TODO(allen): failed SetHandleInformation
            CloseHandle(out_read);
            CloseHandle(out_write);
        }
    }
    else{
        // TODO(allen): failed CreatePipe
    }
    
    end_temp(temp);
    
    return(success);
}

struct CLI_Loop_Control{
    u32 remaining_amount;
};

internal
Sys_CLI_Begin_Update_Sig(system_cli_begin_update){
    Assert(sizeof(cli->scratch_space) >= sizeof(CLI_Loop_Control));
    CLI_Loop_Control *loop = (CLI_Loop_Control*)cli->scratch_space;
    loop->remaining_amount = 0;
}

internal
Sys_CLI_Update_Step_Sig(system_cli_update_step){
    HANDLE handle = *(HANDLE*)&cli->out_read;
    CLI_Loop_Control *loop = (CLI_Loop_Control*)cli->scratch_space;
    b32 has_more = 0;
    DWORD remaining = loop->remaining_amount;
    u32 pos = 0;
    DWORD read_amount = 0;
    
    for (;;){
        if (remaining == 0){
            if (!PeekNamedPipe(handle, 0, 0, 0, &remaining, 0)) break;
            if (remaining == 0) break;
        }
        
        if (remaining + pos < max){
            has_more = 1;
            ReadFile(handle, dest + pos, remaining, &read_amount, 0);
            Assert(remaining == read_amount);
            pos += remaining;
            remaining = 0;
        }
        else{
            has_more = 1;
            ReadFile(handle, dest + pos, max - pos, &read_amount, 0);
            Assert(max - pos == read_amount);
            loop->remaining_amount = remaining - (max - pos);
            pos = max;
            break;
        }
    }
    *amount = pos;
    
    return(has_more);
}

internal
Sys_CLI_End_Update_Sig(system_cli_end_update){
    b32 close_me = false;
    HANDLE proc = *(HANDLE*)&cli->proc;
    DWORD result = 0;
    
    if (WaitForSingleObject(proc, 0) == WAIT_OBJECT_0){
        if (GetExitCodeProcess(proc, &result) == 0){
            cli->exit = -1;
        }
        else{
            cli->exit = (i32)result;
        }
        
        close_me = true;
        CloseHandle(*(HANDLE*)&cli->proc);
        CloseHandle(*(HANDLE*)&cli->out_read);
        CloseHandle(*(HANDLE*)&cli->out_write);
        if (*(HANDLE*)&cli->in_read != INVALID_HANDLE_VALUE){
            CloseHandle(*(HANDLE*)&cli->in_read);
        }
        if (*(HANDLE*)&cli->in_write != INVALID_HANDLE_VALUE){
            CloseHandle(*(HANDLE*)&cli->in_write);
        }
        
        --win32vars.running_cli;
    }
    
    return(close_me);
}

#include "4ed_font_provider_freetype.h"
#include "4ed_font_provider_freetype.cpp"

#include <GL/gl.h>
#include "opengl/4ed_opengl_render.cpp"

//
// Helpers
//

global Key_Code keycode_lookup_table[255];

internal void
win32_keycode_init(void){
    keycode_lookup_table[VK_BACK] = key_back;
    keycode_lookup_table[VK_DELETE] = key_del;
    keycode_lookup_table[VK_UP] = key_up;
    keycode_lookup_table[VK_DOWN] = key_down;
    keycode_lookup_table[VK_LEFT] = key_left;
    keycode_lookup_table[VK_RIGHT] = key_right;
    keycode_lookup_table[VK_INSERT] = key_insert;
    keycode_lookup_table[VK_HOME] = key_home;
    keycode_lookup_table[VK_END] = key_end;
    keycode_lookup_table[VK_PRIOR] = key_page_up;
    keycode_lookup_table[VK_NEXT] = key_page_down;
    keycode_lookup_table[VK_ESCAPE] = key_esc;
    
    keycode_lookup_table[VK_CONTROL] = key_ctrl;
    keycode_lookup_table[VK_LCONTROL] = key_ctrl;
    keycode_lookup_table[VK_RCONTROL] = key_ctrl;
    
    keycode_lookup_table[VK_MENU] = key_alt;
    keycode_lookup_table[VK_LMENU] = key_alt;
    keycode_lookup_table[VK_RMENU] = key_alt;
    
    keycode_lookup_table[VK_SHIFT] = key_shift;
    keycode_lookup_table[VK_LSHIFT] = key_shift;
    keycode_lookup_table[VK_RSHIFT] = key_shift;
    
    keycode_lookup_table[VK_PAUSE] = key_pause;
    keycode_lookup_table[VK_CAPITAL] = key_caps;
    keycode_lookup_table[VK_NUMLOCK] = key_num_lock;
    keycode_lookup_table[VK_SCROLL] = key_scroll_lock;
    keycode_lookup_table[VK_APPS] = key_menu;
    
    keycode_lookup_table[VK_F1] = key_f1;
    keycode_lookup_table[VK_F2] = key_f2;
    keycode_lookup_table[VK_F3] = key_f3;
    keycode_lookup_table[VK_F4] = key_f4;
    keycode_lookup_table[VK_F5] = key_f5;
    keycode_lookup_table[VK_F6] = key_f6;
    keycode_lookup_table[VK_F7] = key_f7;
    keycode_lookup_table[VK_F8] = key_f8;
    keycode_lookup_table[VK_F9] = key_f9;
    
    keycode_lookup_table[VK_F10] = key_f10;
    keycode_lookup_table[VK_F11] = key_f11;
    keycode_lookup_table[VK_F12] = key_f12;
    keycode_lookup_table[VK_F13] = key_f13;
    keycode_lookup_table[VK_F14] = key_f14;
    keycode_lookup_table[VK_F15] = key_f15;
    keycode_lookup_table[VK_F16] = key_f16;
}

internal void
win32_resize(i32 width, i32 height){
    if (width > 0 && height > 0){
        target.width = width;
        target.height = height;
    }
}

#if 0
internal void
win32_init_gl(HDC hdc){
    //LOG("trying to load wgl extensions...\n");
    
#define GLInitFail(s) system_error_box(FNLN "\nOpenGL init fail - " s )
    
    // Init First Context
    WNDCLASSA wglclass = {};
    wglclass.lpfnWndProc = DefWindowProcA;
    wglclass.hInstance = GetModuleHandle(0);
    wglclass.lpszClassName = "4ed-wgl-loader";
    if (RegisterClassA(&wglclass) == 0){
        GLInitFail("RegisterClassA");
    }
    
    HWND hwglwnd = CreateWindowExA(0, wglclass.lpszClassName, "", 0, 0, 0, 0, 0, 0, 0, wglclass.hInstance, 0);
    if (hwglwnd == 0){
        GLInitFail("CreateWindowExA");
    }
    
    HDC hwgldc = GetDC(hwglwnd);
    
    PIXELFORMATDESCRIPTOR format = {};
    format.nSize = sizeof(format);
    format.nVersion = 1;
    //format.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER;
    format.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
    format.iPixelType = PFD_TYPE_RGBA;
    format.cColorBits = 32;
    format.cAlphaBits = 8;
    format.cDepthBits = 24;
    format.iLayerType = PFD_MAIN_PLANE;
    i32 suggested_format_index = ChoosePixelFormat(hwgldc, &format);
    if (suggested_format_index == 0){
        win32_output_error_string(ErrorString_UseErrorBox);
        GLInitFail("ChoosePixelFormat");
    }
    
    DescribePixelFormat(hwgldc, suggested_format_index, sizeof(format), &format);
    if (!SetPixelFormat(hwgldc, suggested_format_index, &format)){
        win32_output_error_string(ErrorString_UseErrorBox);
        GLInitFail("SetPixelFormat");
    }
    
    HGLRC wglcontext = wglCreateContext(hwgldc);
    if (wglcontext == 0){
        win32_output_error_string(ErrorString_UseErrorBox);
        GLInitFail("wglCreateContext");
    }
    
    if (!wglMakeCurrent(hwgldc, wglcontext)){
        win32_output_error_string(ErrorString_UseErrorBox);
        GLInitFail("wglMakeCurrent");
    }
    
    // Load wgl Extensions
#define LoadWGL(f, s) f = (f##_Function*)wglGetProcAddress(#f); b32 got_##f = GLFuncGood(f); \
    if (!got_##f) { if (s) { GLInitFail(#f " missing"); } else { f = 0; } }
    LoadWGL(wglCreateContextAttribsARB, true);
    LoadWGL(wglChoosePixelFormatARB, true);
    LoadWGL(wglGetExtensionsStringEXT, true);
    
    //LOG("got wgl functions\n");
    
    char *extensions_c = wglGetExtensionsStringEXT();
    String extensions = make_string_slowly(extensions_c);
    if (has_substr(extensions, make_lit_string("WGL_EXT_swap_interval"))){
        LoadWGL(wglSwapIntervalEXT, false);
        if (wglSwapIntervalEXT != 0){
            //LOG("got wglSwapIntervalEXT\n");
        }
    }
    
    // Init the Second Context
    int pixel_attrib_list[] = {
        WGL_DRAW_TO_WINDOW_ARB, TRUE,
        WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
        WGL_SUPPORT_OPENGL_ARB, TRUE,
        //WGL_DOUBLE_BUFFER_ARB, TRUE,
        WGL_DOUBLE_BUFFER_ARB, FALSE,
        WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
        0,
    };
    
    u32 ignore = 0;
    if (!wglChoosePixelFormatARB(hdc, pixel_attrib_list, 0, 1, &suggested_format_index, &ignore)){
        GLInitFail("wglChoosePixelFormatARB");
    }
    
    DescribePixelFormat(hdc, suggested_format_index, sizeof(format), &format);
    if (!SetPixelFormat(hdc, suggested_format_index, &format)){
        GLInitFail("SetPixelFormat");
    }
    
    i32 context_attrib_list[] = {
        WGL_CONTEXT_MAJOR_VERSION_ARB, 2,
        WGL_CONTEXT_MINOR_VERSION_ARB, 1,
        WGL_CONTEXT_FLAGS_ARB, 0,
        WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
        0
    };
    
    HGLRC context = wglCreateContextAttribsARB(hdc, 0, context_attrib_list);
    if (context == 0){
        GLInitFail("wglCreateContextAttribsARB");
    }
    
    wglMakeCurrent(hdc, context);
    
    if (wglSwapIntervalEXT != 0){
        //LOGF("setting swap interval %d\n", 1);
        wglSwapIntervalEXT(1);
    }
    
    ReleaseDC(hwglwnd, hwgldc);
    DestroyWindow(hwglwnd);
    wglDeleteContext(wglcontext);
    
    //LOG("successfully enabled opengl\n");
}
#endif

internal void
Win32SetCursorFromUpdate(Application_Mouse_Cursor cursor){
    switch (cursor){
        case APP_MOUSE_CURSOR_ARROW:
        {
            SetCursor(win32vars.cursor_arrow);
        }break;
        
        case APP_MOUSE_CURSOR_IBEAM:
        {
            SetCursor(win32vars.cursor_ibeam);
        }break;
        
        case APP_MOUSE_CURSOR_LEFTRIGHT:
        {
            SetCursor(win32vars.cursor_leftright);
        }break;
        
        case APP_MOUSE_CURSOR_UPDOWN:
        {
            SetCursor(win32vars.cursor_updown);
        }break;
    }
}

internal Win32_Object*
win32_alloc_object(void){
    Win32_Object *result = 0;
    if (win32vars.free_win32_objects.next != &win32vars.free_win32_objects){
        result = CastFromMember(Win32_Object, node, win32vars.free_win32_objects.next);
    }
    if (result == 0){
        i32 count = 512;
        Win32_Object *objects = (Win32_Object*)system_memory_allocate(count*sizeof(Win32_Object));
        objects[0].node.prev = &win32vars.free_win32_objects;
        win32vars.free_win32_objects.next = &objects[0].node;
        for (i32 i = 1; i < count; i += 1){
            objects[i - 1].node.next = &objects[i].node;
            objects[i].node.prev = &objects[i - 1].node;
        }
        objects[count - 1].node.next = &win32vars.free_win32_objects;
        win32vars.free_win32_objects.prev = &objects[count - 1].node;
        result = CastFromMember(Win32_Object, node, win32vars.free_win32_objects.next);
    }
    Assert(result != 0);
    dll_remove(&result->node);
    return(result);
}

internal void
win32_free_object(Win32_Object *object){
    if (object->node.next != 0){
        dll_remove(&object->node);
    }
    dll_insert(&win32vars.free_win32_objects, &object->node);
}

internal
Sys_Now_Time_Sig(system_now_time){
    u64 result = 0;
    LARGE_INTEGER t;
    if (QueryPerformanceCounter(&t)){
        result = (u64)(t.QuadPart/win32vars.count_per_usecond);
    }
    return(result);
}

internal
Sys_Wake_Up_Timer_Create_Sig(system_wake_up_timer_create){
    Win32_Object *object = win32_alloc_object();
    block_zero_struct(object);
    dll_insert(&win32vars.timer_objects, &object->node);
    object->kind = Win32ObjectKind_Timer;
    object->timer.id = ++win32vars.timer_counter;
    return(handle_type(object));
}

internal
Sys_Wake_Up_Timer_Release_Sig(system_wake_up_timer_release){
    Win32_Object *object = (Win32_Object*)handle_type_ptr(handle);
    if (object->kind == Win32ObjectKind_Timer){
        KillTimer(win32vars.window_handle, object->timer.id);
        win32_free_object(object);
    }
}

internal
Sys_Wake_Up_Timer_Set_Sig(system_wake_up_timer_set){
    Win32_Object *object = (Win32_Object*)handle_type_ptr(handle);
    if (object->kind == Win32ObjectKind_Timer){
        object->timer.id = SetTimer(win32vars.window_handle, object->timer.id, time_milliseconds, 0);
    }
}

internal LRESULT
win32_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam){
    LRESULT result = 0;
    
    switch (uMsg){
        case WM_MENUCHAR:break;
        
        case WM_SYSKEYDOWN:
        case WM_SYSKEYUP:
        case WM_KEYDOWN:
        case WM_KEYUP:
        {
            b8 release = HasFlag(lParam, bit_32);
            b8 down = !release;
            b8 is_right = HasFlag(lParam, bit_25);
            
            switch (wParam){
                case VK_CONTROL:case VK_LCONTROL:case VK_RCONTROL:
                case VK_MENU:case VK_LMENU:case VK_RMENU:
                case VK_SHIFT:case VK_LSHIFT:case VK_RSHIFT:
                {
                    Control_Keys *controls = &win32vars.input_chunk.pers.controls;
                    b8 *control_keys = win32vars.input_chunk.pers.control_keys;
                    
                    if (wParam != 255){
                        switch (wParam){
                            case VK_SHIFT:
                            {
                                control_keys[MDFR_SHIFT_INDEX] = down;
                            }break;
                            case VK_CONTROL:
                            {
                                if (is_right){
                                    controls->r_ctrl = down;
                                }
                                else{
                                    controls->l_ctrl = down;
                                }
                            }break;
                            case VK_MENU:
                            {
                                if (is_right){
                                    controls->r_alt = down;
                                }
                                else{
                                    controls->l_alt = down;
                                }
                            }break;
                        }
                        
                        b8 ctrl = (controls->r_ctrl || (controls->l_ctrl && !controls->r_alt));
                        b8 alt = (controls->l_alt || (controls->r_alt && !controls->l_ctrl));
                        if (win32vars.lctrl_lalt_is_altgr && controls->l_alt && controls->l_ctrl){
                            ctrl = false;
                            alt = false;
                        }
                        control_keys[MDFR_CONTROL_INDEX] = ctrl;
                        control_keys[MDFR_ALT_INDEX] = alt;
                    }
                }break;
            }
            
            if (down){
                Key_Code key = keycode_lookup_table[(u8)wParam];
                if (key != 0){
                    i32 *count = &win32vars.input_chunk.trans.key_data.count;
                    Key_Event_Data *data = win32vars.input_chunk.trans.key_data.keys;
                    b8 *control_keys = win32vars.input_chunk.pers.control_keys;
                    i32 control_keys_size = sizeof(win32vars.input_chunk.pers.control_keys);
                    
                    if (*count < KEY_INPUT_BUFFER_SIZE){
                        data[*count].character = 0;
                        data[*count].character_no_caps_lock = 0;
                        data[*count].keycode = key;
                        memcpy(data[*count].modifiers, control_keys, control_keys_size);
                        ++(*count);
                    }
                    
                    win32vars.got_useful_event = true;
                }
            }
        }break;
        
        case WM_CHAR: case WM_SYSCHAR: case WM_UNICHAR:
        {
            u16 character = (u16)wParam;
            
            if (character == '\r'){
                character = '\n';
            }
            else if (character == '\t'){
                // Do nothing
            }
            else if (character < 32 || character == 127){
                break;
            }
            
            u16 character_no_caps_lock = character;
            
            i32 *count = &win32vars.input_chunk.trans.key_data.count;
            Key_Event_Data *data = win32vars.input_chunk.trans.key_data.keys;
            b8 *control_keys = win32vars.input_chunk.pers.control_keys;
            i32 control_keys_size = sizeof(win32vars.input_chunk.pers.control_keys);
            
            BYTE state[256];
            GetKeyboardState(state);
            if (state[VK_CAPITAL]){
                if (character_no_caps_lock >= 'a' && character_no_caps_lock <= 'z'){
                    character_no_caps_lock -= (u8)('a' - 'A');
                }
                else if (character_no_caps_lock >= 'A' && character_no_caps_lock <= 'Z'){
                    character_no_caps_lock += (u8)('a' - 'A');
                }
            }
            
            if (*count < KEY_INPUT_BUFFER_SIZE){
                data[*count].character = character;
                data[*count].character_no_caps_lock = character_no_caps_lock;
                data[*count].keycode = character_no_caps_lock;
                memcpy(data[*count].modifiers, control_keys, control_keys_size);
                ++(*count);
            }
            
            win32vars.got_useful_event = true;
        }break;
        
        case WM_MOUSEMOVE:
        {
            Vec2_i32 new_m = V2i32(LOWORD(lParam), HIWORD(lParam));
            if (new_m != win32vars.input_chunk.pers.mouse){
                win32vars.input_chunk.pers.mouse = new_m;
                win32vars.got_useful_event = true;
            }
        }break;
        
        case WM_MOUSEWHEEL:
        {
            win32vars.got_useful_event = true;
            i32 rotation = GET_WHEEL_DELTA_WPARAM(wParam);
            if (rotation > 0){
                win32vars.input_chunk.trans.mouse_wheel = -100;
            }
            else{
                win32vars.input_chunk.trans.mouse_wheel =  100;
            }
        }break;
        
        case WM_LBUTTONDOWN:
        {
            win32vars.got_useful_event = true;
            win32vars.input_chunk.trans.mouse_l_press = 1;
            win32vars.input_chunk.pers.mouse_l = 1;
        }break;
        
        case WM_RBUTTONDOWN:
        {
            win32vars.got_useful_event = true;
            win32vars.input_chunk.trans.mouse_r_press = 1;
            win32vars.input_chunk.pers.mouse_r = 1;
        }break;
        
        case WM_LBUTTONUP:
        {
            win32vars.got_useful_event = true;
            win32vars.input_chunk.trans.mouse_l_release = 1;
            win32vars.input_chunk.pers.mouse_l = 0;
        }break;
        
        case WM_RBUTTONUP:
        {
            win32vars.got_useful_event = true;
            win32vars.input_chunk.trans.mouse_r_release = 1;
            win32vars.input_chunk.pers.mouse_r = 0;
        }break;
        
        case WM_KILLFOCUS:
        case WM_SETFOCUS:
        {
            win32vars.got_useful_event = true;
            win32vars.input_chunk.pers.mouse_l = 0;
            win32vars.input_chunk.pers.mouse_r = 0;
            for (i32 i = 0; i < MDFR_INDEX_COUNT; ++i){
                win32vars.input_chunk.pers.control_keys[i] = 0;
            }
            win32vars.input_chunk.pers.controls = null_control_keys;
        }break;
        
        case WM_SIZE:
        {
            win32vars.got_useful_event = true;
            i32 new_width = LOWORD(lParam);
            i32 new_height = HIWORD(lParam);
            
            win32_resize(new_width, new_height);
        }break;
        
        case WM_DISPLAYCHANGE:
        {
            win32vars.got_useful_event = true;
            
            LONG_PTR style = GetWindowLongPtr(hwnd, GWL_STYLE);
            if (!(style & WS_OVERLAPPEDWINDOW)){
                MONITORINFO monitor_info = {sizeof(MONITORINFO)};
                if(GetMonitorInfo(MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY), &monitor_info))
                {
                    SetWindowPos(hwnd, HWND_TOP,
                                 monitor_info.rcMonitor.left, monitor_info.rcMonitor.top,
                                 monitor_info.rcMonitor.right - monitor_info.rcMonitor.left,
                                 monitor_info.rcMonitor.bottom - monitor_info.rcMonitor.top,
                                 SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
                }
            }
        }break;
        
        case WM_PAINT:
        {
            win32vars.got_useful_event = true;
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);
            // NOTE(allen): Do nothing?
            EndPaint(hwnd, &ps);
        }break;
        
        case WM_CLIPBOARDUPDATE:
        {
            win32vars.got_useful_event = true;
        }break;
        
        case WM_CLOSE:
        case WM_DESTROY:
        {
            win32vars.got_useful_event = true;
            win32vars.input_chunk.trans.trying_to_kill = true;
        }break;
        
        case WM_TIMER:
        {
            UINT_PTR timer_id = (UINT_PTR)wParam;
            KillTimer(win32vars.window_handle, timer_id);
            win32vars.got_useful_event = true;
        }break;
        
        case WM_4coder_ANIMATE:
        {
            win32vars.got_useful_event = true;
        }break;
        
        default:
        {
            result = DefWindowProc(hwnd, uMsg, wParam, lParam);
        }break;
    }
    
    return(result);
}

////////////////////////////////

internal b32
win32_wgl_good(Void_Func *f){
    return(f != 0 &&
           f != (Void_Func*)1 &&
           f != (Void_Func*)2 &&
           f != (Void_Func*)3 &&
           f != (Void_Func*)-1);
}

typedef HGLRC (wglCreateContextAttribsARB_Function)(HDC,HGLRC,i32*);
typedef BOOL (wglChoosePixelFormatARB_Function)(HDC,i32*,f32*,u32,i32*,u32*);
typedef char* (wglGetExtensionsStringEXT_Function)();
typedef VOID (wglSwapIntervalEXT_Function)(i32);

global wglCreateContextAttribsARB_Function *wglCreateContextAttribsARB = 0;
global wglChoosePixelFormatARB_Function *wglChoosePixelFormatARB = 0;
global wglGetExtensionsStringEXT_Function *wglGetExtensionsStringEXT = 0;
global wglSwapIntervalEXT_Function *wglSwapIntervalEXT = 0;

// TODO(allen): This requires all windows to be handled on a single thread.
// We would need a platform side thread context to get around this which would
// probably mean thread local storage would have to get involved.
global HWND win32_current_gl_window = 0;

internal b32
win32_gl_create_window(HWND *wnd_out, HGLRC *context_out, DWORD style, RECT rect){
    HINSTANCE this_instance = GetModuleHandle(0);
    
    local_persist b32 srgb_support = false;
    local_persist b32 register_success = true;
    local_persist b32 first_call = true;
    if (first_call){
        first_call = false;
        
        // NOTE(allen): Create the GL bootstrap window
        WNDCLASSW wglclass = {};
        wglclass.lpfnWndProc = DefWindowProcW;
        wglclass.hInstance = this_instance;
        wglclass.lpszClassName = L"wgl-loader";
        if (RegisterClassW(&wglclass) == 0){
            register_success = false;
            goto fail_register;
        }
        
        HWND wglwindow = CreateWindowW(wglclass.lpszClassName, L"", 0, 0, 0, 0, 0,
                                       0, 0, this_instance, 0);
        if (wglwindow == 0){
            register_success = false;
            goto fail_register;
        }
        
        // NOTE(allen): Create the GL bootstrap context
        HDC wgldc = GetDC(wglwindow);
        
        PIXELFORMATDESCRIPTOR format = {};
        format.nSize = sizeof(format);
        format.nVersion = 1;
        format.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER;
        format.iPixelType = PFD_TYPE_RGBA;
        format.cColorBits = 32;
        format.cAlphaBits = 8;
        format.cDepthBits = 24;
        format.iLayerType = PFD_MAIN_PLANE;
        i32 suggested_format_index = ChoosePixelFormat(wgldc, &format);
        if (!SetPixelFormat(wgldc, suggested_format_index, &format)){
            register_success = false;
            goto fail_register;
        }
        
        HGLRC wglcontext = wglCreateContext(wgldc);
        if (wglcontext == 0){
            register_success = false;
            goto fail_register;
        }
        
        if (!wglMakeCurrent(wgldc, wglcontext)){
            register_success = false;
            goto fail_register;
        }
        
        // NOTE(allen): Load wgl extensions
#define LoadWGL(f,l) Stmnt((f) = (f##_Function*)wglGetProcAddress(#f); \
        (l) = (l) && win32_wgl_good((Void_Func*)(f));)
        
        b32 load_success = true;
        LoadWGL(wglCreateContextAttribsARB, load_success);
        LoadWGL(wglChoosePixelFormatARB, load_success);
        LoadWGL(wglGetExtensionsStringEXT, load_success);
        
        if (!load_success){
            register_success = false;
            goto fail_register;
        }
        
        char *extensions_c = wglGetExtensionsStringEXT();
        String_Const_u8 extensions = SCu8((u8*)extensions_c);
        
        {
            String_Const_u8 s = string_skip_whitespace(extensions);
            for (;s.size > 0;){
                umem end = string_find_first_whitespace(s);
                String_Const_u8 m = string_prefix(s, end);
                if (string_match(m, string_u8_litexpr("WGL_EXT_framebuffer_sRGB")) ||
                    string_match(m, string_u8_litexpr("WGL_ARB_framebuffer_sRGB"))){
                    srgb_support = true;
                }
                else if (string_match(m, string_u8_litexpr("WGL_EXT_swap_interval"))){
                    b32 wgl_swap_interval_ext = true;
                    LoadWGL(wglSwapIntervalEXT, wgl_swap_interval_ext);
                    if (!wgl_swap_interval_ext){
                        wglSwapIntervalEXT = 0;
                    }
                }
                s = string_skip_whitespace(string_skip(s, end));
            }
        }
        
        // NOTE(allen): Load gl functions
#define GL_FUNC(f,R,P) LoadWGL(f,load_success);
#include "opengl/4ed_opengl_funcs.h"
        
        if (!load_success){
            register_success = false;
            goto fail_register;
        }
        
        // NOTE(allen): Cleanup the GL bootstrap resources
        ReleaseDC(wglwindow, wgldc);
        DestroyWindow(wglwindow);
        wglDeleteContext(wglcontext);
        
        // NOTE(allen): Register the graphics window class
        WNDCLASSW wndclass = {};
        wndclass.style = CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
        wndclass.lpfnWndProc = win32_proc;
        wndclass.hInstance = this_instance;
        wndclass.lpszClassName = L"GRAPHICS-WINDOW-NAME";
        if (RegisterClassW(&wndclass) == 0){
            register_success = false;
            goto fail_register;
        }
    }
    fail_register:;
    
    b32 result = false;
    if (register_success){
        // NOTE(allen): Create the graphics window
        HWND wnd = CreateWindowExW(0, L"GRAPHICS-WINDOW-NAME", L"GRAPHICS", style,
                                   CW_USEDEFAULT, CW_USEDEFAULT, rect.right - rect.left, rect.bottom - rect.top,
                                   0, 0, this_instance, 0);
        
        *wnd_out = 0;
        *context_out = 0;
        if (wnd != 0){
            HDC dc = GetDC(wnd);
            
            PIXELFORMATDESCRIPTOR format = {};
            
            i32 pixel_attrib_list[] = {
                /* 0*/WGL_DRAW_TO_WINDOW_ARB, TRUE,
                /* 2*/WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
                /* 4*/WGL_SUPPORT_OPENGL_ARB, TRUE,
                /* 6*/WGL_DOUBLE_BUFFER_ARB, false,
                /* 8*/WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
                /*10*/WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB, GL_TRUE,
                /*12*/0,
            };
            if (!srgb_support){
                pixel_attrib_list[10] = 0;
            }
            
            i32 suggested_format_index = 0;
            u32 ignore = 0;
            if (!wglChoosePixelFormatARB(dc, pixel_attrib_list, 0, 1, &suggested_format_index, &ignore)){
                goto fail_window_init;
            }
            
            DescribePixelFormat(dc, suggested_format_index, sizeof(format), &format);
            if (!SetPixelFormat(dc, suggested_format_index, &format)){
                goto fail_window_init;
            }
            
#if 1
            i32 context_attrib_list[] = {
                /*0*/WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
                /*2*/WGL_CONTEXT_MINOR_VERSION_ARB, 2,
                /*4*/WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB
#if GL_DEBUG_MODE
                    |WGL_CONTEXT_DEBUG_BIT_ARB
#endif
                    ,
                /*6*/WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
                /*8*/0
            };
#else
            i32 context_attrib_list[] = {
                WGL_CONTEXT_MAJOR_VERSION_ARB, 2,
                WGL_CONTEXT_MINOR_VERSION_ARB, 1,
                WGL_CONTEXT_FLAGS_ARB, 0,
                WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
                0
            };
#endif
            
            HGLRC context = wglCreateContextAttribsARB(dc, 0, context_attrib_list);
            if (context == 0){
                goto fail_window_init;
            }
            
            wglMakeCurrent(dc, context);
            win32_current_gl_window = wnd;
            if (wglSwapIntervalEXT != 0){
                wglSwapIntervalEXT(1);
            }
            *wnd_out = wnd;
            *context_out = context;
            result = true;
            
            if (false){
                fail_window_init:;
                DWORD error = GetLastError();
                ReleaseDC(wnd, dc);
                DestroyWindow(wnd);
                SetLastError(error);
            }
        }
    }
    
    return(result);
}

////////////////////////////////

#include "4ed_link_system_functions.cpp"
#include "4ed_shared_init_logic.cpp"

int CALL_CONVENTION
WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow){
    i32 argc = __argc;
    char **argv = __argv;
    
    //
    // System Linkage
    //
    
    sysfunc.font_make_face = ft__font_make_face;
    sysfunc.get_texture = gl__get_texture;
    sysfunc.fill_texture = gl__fill_texture;
    link_system_code();
    
    //
    // Memory init
    //
    
    memset(&win32vars, 0, sizeof(win32vars));
    memset(&target, 0, sizeof(target));
    memset(&memory_vars, 0, sizeof(memory_vars));
    memset(&plat_settings, 0, sizeof(plat_settings));
    
    memset(&libraries, 0, sizeof(libraries));
    memset(&app, 0, sizeof(app));
    memset(&custom_api, 0, sizeof(custom_api));
    
    memory_init();
    
    win32vars.cursor_show = MouseCursorShow_Always;
    win32vars.prev_cursor_show = MouseCursorShow_Always;
    
    dll_init_sentinel(&win32vars.free_win32_objects);
    dll_init_sentinel(&win32vars.timer_objects);
    
    //
    // HACK(allen):
    // Previously zipped stuff is here, it should be zipped in the new pattern now.
    //
    
    init_shared_vars();
    
    //
    // Init Filetrack
    //
    file_track_init();
    
    //
    // Load Core Code
    //
    load_app_code();
    
    //
    // Read Command Line
    //
    read_command_line(&shared_vars.scratch, argc, argv);
    
    //
    // Load Custom Code
    //
    
#if defined(FRED_SUPER)
    load_custom_code();
#else
    custom_api.get_bindings = get_bindings;
#endif
    
    //
    // Threads
    //
    
    work_system_init();
    
    //
    // Coroutines
    //
    
    coroutines_init();
    
    //
    // Window and GL Initialization
    //
    
    RECT window_rect = {};
    if (plat_settings.set_window_size){
        window_rect.right = plat_settings.window_w;
        window_rect.bottom = plat_settings.window_h;
    }
    else{
        window_rect.right = 800;
        window_rect.bottom = 600;
    }
    
    if (!AdjustWindowRect(&window_rect, WS_OVERLAPPEDWINDOW, false)){
        //LOG("Could not get adjusted window.\n");
    }
    
    i32 window_style = WS_OVERLAPPEDWINDOW;
    if (!plat_settings.fullscreen_window && plat_settings.maximize_window){
        window_style |= WS_MAXIMIZE;
    }
    
#if 0    
    WNDCLASS window_class = {};
    window_class.style = CS_HREDRAW|CS_VREDRAW;
    window_class.lpfnWndProc = (WNDPROC)(win32_proc);
    window_class.hInstance = hInstance;
    window_class.lpszClassName = L"4coder-win32-wndclass";
    window_class.hIcon = LoadIcon(hInstance, L"main");
    
    if (!RegisterClass(&window_class)){
        exit(1);
    }
    
    i32 window_x = CW_USEDEFAULT;
    i32 window_y = CW_USEDEFAULT;
    
    if (plat_settings.set_window_pos){
        window_x = plat_settings.window_x;
        window_y = plat_settings.window_y;
        //LOGF("Setting window position (%d, %d)\n", window_x, window_y);
    }
    
    //LOG("Creating window... ");
    win32vars.window_handle = CreateWindowEx(0, window_class.lpszClassName, L_WINDOW_NAME, window_style, window_x, window_y, window_rect.right - window_rect.left, window_rect.bottom - window_rect.top, 0, 0, hInstance, 0);
    
    if (win32vars.window_handle == 0){
        //LOG("Failed\n");
        exit(1);
    }
    else{
        //LOG("Success\n");
    }
    
    {
        HDC hdc = GetDC(win32vars.window_handle);
        
        // TODO(allen): not Windows XP compatible, how do I handle that?
        SetProcessDPIAware();
        win32vars.dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
        win32vars.dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
        
        GetClientRect(win32vars.window_handle, &window_rect);
        
        win32_init_gl(hdc);
        
        ReleaseDC(win32vars.window_handle, hdc);
    }
#endif
    
    HGLRC window_opengl_context = 0;
    if (!win32_gl_create_window(&win32vars.window_handle, &window_opengl_context, window_style, window_rect)){
        //LOG("Window creation failed\n");
        exit(1);
    }
    
    GetClientRect(win32vars.window_handle, &window_rect);
    win32_resize(window_rect.right - window_rect.left, window_rect.bottom - window_rect.top);
    
    //
    // Misc System Initializations
    //
    
    //LOG("Initializing clipboard\n");
    if (!AddClipboardFormatListener(win32vars.window_handle)){
        win32_output_error_string(ErrorString_UseLog);
    }
    
    win32vars.clip_max = KB(16);
    win32vars.clip_buffer = (u8*)system_memory_allocate(win32vars.clip_max);
    
    win32vars.clipboard_sequence = GetClipboardSequenceNumber();
    if (win32vars.clipboard_sequence == 0){
        win32_post_clipboard("", 0);
        
        win32vars.clipboard_sequence = GetClipboardSequenceNumber();
        win32vars.next_clipboard_is_self = 0;
        
        if (win32vars.clipboard_sequence == 0){
            OutputDebugStringA("Failure while initializing clipboard\n");
        }
    }
    else{
        win32_read_clipboard_contents();
    }
    
    win32_keycode_init();
    
    win32vars.cursor_ibeam = LoadCursor(NULL, IDC_IBEAM);
    win32vars.cursor_arrow = LoadCursor(NULL, IDC_ARROW);
    win32vars.cursor_leftright = LoadCursor(NULL, IDC_SIZEWE);
    win32vars.cursor_updown = LoadCursor(NULL, IDC_SIZENS);
    
    LARGE_INTEGER f;
    if (QueryPerformanceFrequency(&f)){
        win32vars.count_per_usecond = (f32)f.QuadPart / 1000000.f;
        //LOGF("Got performance frequency %f\n", win32vars.count_per_usecond);
    }
    else{
        // NOTE(allen): Just guess.
        win32vars.count_per_usecond = 1.f;
        //LOG("Did not get performance frequency, just guessing with 1.\n");
    }
    Assert(win32vars.count_per_usecond > 0.f);
    
    //
    // App init
    //
    
    //LOG("Initializing application variables\n");
    {
        Temp_Memory temp = begin_temp(&shared_vars.scratch);
        String_Const_u8 curdir = sysfunc.get_current_path(&shared_vars.scratch);
        curdir = string_mod_replace_character(curdir, '\\', '/');
        app.init(&sysfunc, &target, &memory_vars, win32vars.clipboard_contents, curdir, custom_api);
        end_temp(temp);
    }
    
    //
    // Main loop
    //
    
    b32 keep_running = true;
    win32vars.first = true;
    timeBeginPeriod(1);
    
    if (plat_settings.fullscreen_window){
        win32_toggle_fullscreen();
    }
    
    SetForegroundWindow(win32vars.window_handle);
    SetActiveWindow(win32vars.window_handle);
    ShowWindow(win32vars.window_handle, SW_SHOW);
    
    //LOG("Beginning main loop\n");
    u64 timer_start = system_now_time();
    system_acquire_lock(FRAME_LOCK);
    MSG msg;
    for (;keep_running;){
        // TODO(allen): Find a good way to wait on a pipe
        // without interfering with the reading process.
        // NOTE(allen): Looks like we can ReadFile with a
        // size of zero in an IOCP for this effect.
        if (!win32vars.first){
            system_release_lock(FRAME_LOCK);
            
            if (win32vars.running_cli == 0){
                win32vars.got_useful_event = false;
            }
            
            b32 get_more_messages = true;
            do{
                if (win32vars.got_useful_event == 0){
                    get_more_messages = GetMessage(&msg, 0, 0, 0);
                }
                else{
                    get_more_messages = PeekMessage(&msg, 0, 0, 0, 1);
                }
                
                if (get_more_messages){
                    if (msg.message == WM_QUIT){
                        keep_running = false;
                    }else{
                        b32 treat_normally = true;
                        if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN){
                            switch (msg.wParam){
                                case VK_CONTROL:case VK_LCONTROL:case VK_RCONTROL:
                                case VK_MENU:case VK_LMENU:case VK_RMENU:
                                case VK_SHIFT:case VK_LSHIFT:case VK_RSHIFT:break;
                                
                                default: treat_normally = false; break;
                            }
                        }
                        
                        if (treat_normally){
                            TranslateMessage(&msg);
                            DispatchMessage(&msg);
                        }
                        else{
                            Control_Keys *controls = &win32vars.input_chunk.pers.controls;
                            
                            b8 ctrl = (controls->r_ctrl || (controls->l_ctrl && !controls->r_alt));
                            b8 alt = (controls->l_alt || (controls->r_alt && !controls->l_ctrl));
                            
                            if (win32vars.lctrl_lalt_is_altgr){
                                if (controls->l_alt && controls->l_ctrl){
                                    ctrl = 0;
                                    alt = 0;
                                }
                            }
                            
                            BYTE ctrl_state = 0, alt_state = 0;
                            BYTE state[256];
                            if (ctrl || alt){
                                GetKeyboardState(state);
                                if (ctrl){
                                    ctrl_state = state[VK_CONTROL];
                                    state[VK_CONTROL] = 0;
                                }
                                if (alt){
                                    alt_state = state[VK_MENU];
                                    state[VK_MENU] = 0;
                                }
                                SetKeyboardState(state);
                                
                                TranslateMessage(&msg);
                                DispatchMessage(&msg);
                                
                                if (ctrl){
                                    state[VK_CONTROL] = ctrl_state;
                                }
                                if (alt){
                                    state[VK_MENU] = alt_state;
                                }
                                SetKeyboardState(state);
                            }
                            else{
                                TranslateMessage(&msg);
                                DispatchMessage(&msg);
                            }
                        }
                    }
                }
            }while (get_more_messages);
            
            system_acquire_lock(FRAME_LOCK);
        }
        
        // NOTE(allen): Mouse Out of Window Detection
        POINT mouse_point;
        if (GetCursorPos(&mouse_point) &&
            ScreenToClient(win32vars.window_handle, &mouse_point)){
            
            i32_Rect screen;
            screen.x0 = 0;
            screen.y0 = 0;
            screen.x1 = target.width;
            screen.y1 = target.height;
            
            i32 mx = mouse_point.x;
            i32 my = mouse_point.y;
            
            b32 is_hit = false;
            if (mx >= screen.x0 && mx < screen.x1 && my >= screen.y0 && my < screen.y1){
                is_hit = true;
            }
            
            if (!is_hit){
                win32vars.input_chunk.trans.out_of_window = true;
            }
            
            win32vars.input_chunk.pers.mouse = V2i32(mouse_point.x, mouse_point.y);
        }
        else{
            win32vars.input_chunk.trans.out_of_window = true;
        }
        
        // NOTE(allen): Prepare the Frame Input
        
        // TODO(allen): CROSS REFERENCE WITH LINUX SPECIAL CODE "TIC898989"
        Win32_Input_Chunk input_chunk = win32vars.input_chunk;
        win32vars.input_chunk.trans = null_input_chunk_transient;
        
        input_chunk.pers.control_keys[MDFR_CAPS_INDEX] = GetKeyState(VK_CAPITAL) & 0x1;
        
        Application_Step_Input input = {};
        
        input.first_step = win32vars.first;
        input.dt = frame_useconds/1000000.f;
        
        input.keys = input_chunk.trans.key_data;
        memcpy(input.keys.modifiers, input_chunk.pers.control_keys, sizeof(input.keys.modifiers));
        
        input.mouse.out_of_window = input_chunk.trans.out_of_window;
        
        input.mouse.l = input_chunk.pers.mouse_l;
        input.mouse.press_l = input_chunk.trans.mouse_l_press;
        input.mouse.release_l = input_chunk.trans.mouse_l_release;
        
        input.mouse.r = input_chunk.pers.mouse_r;
        input.mouse.press_r = input_chunk.trans.mouse_r_press;
        input.mouse.release_r = input_chunk.trans.mouse_r_release;
        
        input.mouse.wheel = input_chunk.trans.mouse_wheel;
        input.mouse.p = input_chunk.pers.mouse;
        
        input.trying_to_kill = input_chunk.trans.trying_to_kill;
        
        // TODO(allen): Not really appropriate to round trip this all the way to the OS layer, redo this system.
        // NOTE(allen): Ask the Core About Exiting if We Have an Exit Signal
        if (win32vars.send_exit_signal){
            input.trying_to_kill = true;
            win32vars.send_exit_signal = false;
        }
        
        // NOTE(allen): Frame Clipboard Input
        memset(&win32vars.clipboard_contents, 0, sizeof(win32vars.clipboard_contents));
        input.clipboard_changed = false;
        if (win32vars.clipboard_sequence != 0){
            DWORD new_number = GetClipboardSequenceNumber();
            if (new_number != win32vars.clipboard_sequence){
                if (win32vars.next_clipboard_is_self){
                    win32vars.next_clipboard_is_self = false;
                }
                else{
                    for (i32 R = 0; R < 4; ++R){
                        if (win32_read_clipboard_contents()){
                            input.clipboard_changed = true;
                            break;
                        }
                    }
                }
                win32vars.clipboard_sequence = new_number;
            }
        }
        input.clipboard = win32vars.clipboard_contents;
        
        win32vars.clip_post.size = 0;
        
        
        // NOTE(allen): Application Core Update
        Application_Step_Result result = {};
        if (app.step != 0){
            result = app.step(&sysfunc, &target, &memory_vars, &input);
        }
        else{
            //LOG("app.step == 0 -- skipping\n");
        }
        
        // NOTE(allen): Finish the Loop
        if (result.perform_kill){
            keep_running = false;
        }
        
        // NOTE(allen): Post New Clipboard Content
        if (win32vars.clip_post.size > 0){
            win32_post_clipboard((char*)win32vars.clip_post.str, (i32)win32vars.clip_post.size);
        }
        
        // NOTE(allen): Switch to New Title
        if (result.has_new_title){
            SetWindowText_utf8(&shared_vars.scratch, win32vars.window_handle, (u8*)result.title_string);
        }
        
        // NOTE(allen): Switch to New Cursor
        Win32SetCursorFromUpdate(result.mouse_cursor_type);
        if (win32vars.cursor_show != win32vars.prev_cursor_show){
            win32vars.prev_cursor_show = win32vars.cursor_show;
            switch (win32vars.cursor_show){
                case MouseCursorShow_Never:
                {
                    i32 counter = 0;
                    do{
                        counter = ShowCursor(false);
                    }while(counter >= 0);
                }break;
                
                case MouseCursorShow_Always:
                {
                    i32 counter = 0;
                    do{
                        counter = ShowCursor(true);
                    }while(counter <= 0);
                }break;
                
                // TODO(allen): MouseCursorShow_HideWhenStill
            }
        }
        
        // NOTE(allen): update lctrl_lalt_is_altgr status
        win32vars.lctrl_lalt_is_altgr = (b8)result.lctrl_lalt_is_altgr;
        
        // NOTE(allen): render
        HDC hdc = GetDC(win32vars.window_handle);
        gl_render(&target, &shared_vars.pixel_scratch);
        SwapBuffers(hdc);
        ReleaseDC(win32vars.window_handle, hdc);
        
        // NOTE(allen): toggle full screen
        if (win32vars.do_toggle){
            win32_toggle_fullscreen();
            win32vars.do_toggle = false;
        }
        
        // NOTE(allen): schedule another step if needed
        if (result.animating){
            system_schedule_step();
        }
        
        // NOTE(allen): sleep a bit to cool off :)
        flush_thread_group(BACKGROUND_THREADS);
        
        u64 timer_end = system_now_time();
        u64 end_target = timer_start + frame_useconds;
        
        system_release_lock(FRAME_LOCK);
        for (;timer_end < end_target;){
            DWORD samount = (DWORD)((end_target - timer_end)/1000);
            if (samount > 0){
                Sleep(samount);
            }
            timer_end = system_now_time();
        }
        system_acquire_lock(FRAME_LOCK);
        timer_start = system_now_time();
        
        win32vars.first = false;
    }
    
    return(0);
}

#include "win32_utf8.cpp"

#if 0
// NOTE(allen): In case I want to switch back to a console application at some point.
int main(int argc, char **argv){
    HINSTANCE hInstance = GetModuleHandle(0);
}
#endif

// BOTTOM