initial commit

1 files changed, 1267 insertions, 0 deletions

diff --git a/src/windows/platform.c b/src/windows/platform.c
new file mode 100644
index 0000000..2187806
--- /dev/null
+++ b/src/windows/platform.c
@@ -0,0 +1,1267 @@
+/* 
+*  BSD 2-Clause “Simplified” License
+*  Copyright (c) 2019, Aldrik Ramaekers, aldrik.ramaekers@protonmail.com
+*  All rights reserved.
+*/
+
+#include <locale.h>
+#include <windows.h>
+#include <GL/gl.h>
+#include <stdbool.h>
+#include <sysinfoapi.h>
+#include <wingdi.h>
+#include <errno.h>
+#include <shlwapi.h>
+#include <objbase.h>
+#include <shellapi.h>
+#include <gdiplus.h>
+#include <shlobj.h>
+#include "../external/LooplessSizeMove.c"
+
+struct t_platform_window
+{
+	HWND window_handle;
+	HDC hdc;
+	HGLRC gl_context;
+	WNDCLASS window_class;
+	
+    s32 min_width;
+	s32 min_height;
+	s32 max_width;
+	s32 max_height;
+	
+	// shared window properties
+	s32 width;
+	s32 height;
+	bool is_open;
+	bool has_focus;
+	cursor_type curr_cursor_type;
+	cursor_type next_cursor_type;
+};
+
+extern BOOL GetPhysicallyInstalledSystemMemory(PULONGLONG TotalMemoryInKilobytes);
+
+LARGE_INTEGER perf_frequency;
+static HINSTANCE instance;
+platform_window *current_window_to_handle;
+keyboard_input *current_keyboard_to_handle;
+mouse_input *current_mouse_to_handle;
+
+int cmd_show;
+
+bool platform_get_clipboard(platform_window *window, char *buffer)
+{
+	if (!OpenClipboard(NULL))
+		return false;
+	
+	if (!IsClipboardFormatAvailable(CF_UNICODETEXT)) 
+	{
+		CloseClipboard();
+		return false;
+	}
+	
+	wchar_t* clip_str = GetClipboardData(CF_UNICODETEXT);
+	if (!clip_str)
+	{
+		CloseClipboard();
+		return false;
+	}
+	
+	WideCharToMultiByte(CP_UTF8, 0, clip_str, -1, buffer, MAX_INPUT_LENGTH ,0,0);
+	
+	CloseClipboard();
+	return true;
+}
+
+bool platform_set_clipboard(platform_window *window, char *buffer)
+{
+	HANDLE clipboard_data;
+	
+	int char_num = MultiByteToWideChar(CP_UTF8, 0, buffer, -1, 0, 0);
+	wchar_t *convstr = mem_alloc(char_num*2);
+	int result = MultiByteToWideChar(CP_UTF8, 0, buffer, -1, convstr, char_num);
+	
+	size_t len = result;
+	size_t size = (len+1) * sizeof(wchar_t);
+	LPSTR dst;
+	
+	if (!OpenClipboard(NULL))
+		return false;
+	
+	clipboard_data = GlobalAlloc(GMEM_MOVEABLE, size);
+	if (clipboard_data)
+	{
+		dst = GlobalLock(clipboard_data);
+		memmove(dst, convstr, size);
+		dst[len*2] = 0;
+		GlobalUnlock(clipboard_data);
+		
+		SetClipboardData(CF_UNICODETEXT, clipboard_data);
+	}
+	else
+	{
+		CloseClipboard();
+		return false;
+	}
+	
+	CloseClipboard();
+	return true;
+}
+
+inline void platform_show_alert(char *title, char *message)
+{
+	// not implemented
+}
+
+inline void platform_destroy()
+{
+	assets_destroy();
+	
+#if defined(MODE_DEVELOPER)
+	memory_print_leaks();
+#endif
+}
+
+bool is_platform_in_darkmode()
+{
+	char *key = "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize\\";
+	
+	HKEY result;
+	LSTATUS o = RegOpenKeyExA(HKEY_CURRENT_USER, key, 0, KEY_READ, &result);
+	
+	if (o == 0)
+	{
+		BYTE data;
+		DWORD len = 4;
+		RegQueryValueExA(result, "AppsUseLightTheme", NULL, NULL, &data, &len);
+		
+		if (data == 1) return true;
+	}
+	
+	return false;
+}
+
+inline void platform_set_cursor(platform_window *window, cursor_type type)
+{
+	if (window->next_cursor_type != type)
+	{
+		window->next_cursor_type = type;
+	}
+}
+
+bool platform_directory_exists(char *path)
+{
+	return PathFileExistsA(path) == TRUE;
+}
+
+static void create_key_tables()
+{
+	keycode_map[0x30] = KEY_0;
+	keycode_map[0x31] = KEY_1;
+	keycode_map[0x32] = KEY_2;
+	keycode_map[0x33] = KEY_3;
+	keycode_map[0x34] = KEY_4;
+	keycode_map[0x35] = KEY_5;
+	keycode_map[0x36] = KEY_6;
+	keycode_map[0x37] = KEY_7;
+	keycode_map[0x38] = KEY_8;
+	keycode_map[0x39] = KEY_9;
+	keycode_map[0x41] = KEY_A;
+	keycode_map[0x42] = KEY_B;
+	keycode_map[0x43] = KEY_C;
+	keycode_map[0x44] = KEY_D;
+	keycode_map[0x45] = KEY_E;
+	keycode_map[0x46] = KEY_F;
+	keycode_map[0x47] = KEY_G;
+	keycode_map[0x48] = KEY_H;
+	keycode_map[0x49] = KEY_I;
+	keycode_map[0x4A] = KEY_J;
+	keycode_map[0x4B] = KEY_K;
+	keycode_map[0x4C] = KEY_L;
+	keycode_map[0x4D] = KEY_M;
+	keycode_map[0x4E] = KEY_N;
+	keycode_map[0x4F] = KEY_O;
+	keycode_map[0x50] = KEY_P;
+	keycode_map[0x51] = KEY_Q;
+	keycode_map[0x52] = KEY_R;
+	keycode_map[0x53] = KEY_S;
+	keycode_map[0x54] = KEY_T;
+	keycode_map[0x55] = KEY_U;
+	keycode_map[0x56] = KEY_V;
+	keycode_map[0x57] = KEY_W;
+	keycode_map[0x58] = KEY_X;
+	keycode_map[0x59] = KEY_Y;
+	keycode_map[0x5A] = KEY_Z;
+	
+	keycode_map[VK_OEM_7] = KEY_APOSTROPHE;
+	keycode_map[VK_OEM_102] = KEY_BACKSLASH;
+	keycode_map[VK_OEM_COMMA] = KEY_COMMA;
+	keycode_map[VK_OEM_3] = KEY_GRAVE_ACCENT;
+	keycode_map[VK_OEM_4] = KEY_LEFT_BRACKET;
+	keycode_map[VK_OEM_MINUS] = KEY_MINUS;
+	keycode_map[VK_OEM_PERIOD] = KEY_PERIOD;
+	
+	keycode_map[VK_BACK] = KEY_BACKSPACE;
+	keycode_map[VK_DELETE] = KEY_DELETE;
+	keycode_map[VK_END] = KEY_END;
+	keycode_map[VK_RETURN] = KEY_ENTER;
+	keycode_map[VK_ESCAPE] = KEY_ESCAPE;
+	keycode_map[VK_HOME] = KEY_HOME;
+	keycode_map[VK_INSERT] = KEY_INSERT;
+	keycode_map[VK_MENU] = KEY_MENU;
+	keycode_map[VK_NEXT] = KEY_PAGE_DOWN;
+	keycode_map[VK_PRIOR] = KEY_PAGE_UP;
+	keycode_map[VK_PAUSE] = KEY_PAUSE;
+	keycode_map[VK_TAB] = KEY_TAB;
+	keycode_map[VK_CAPITAL] = KEY_CAPS_LOCK;
+	keycode_map[VK_NUMLOCK] = KEY_NUM_LOCK;
+	keycode_map[VK_SCROLL] = KEY_SCROLL_LOCK;
+	keycode_map[0x70] = KEY_F1;
+	keycode_map[0x71] = KEY_F2;
+	keycode_map[0x72] = KEY_F3;
+	keycode_map[0x73] = KEY_F4;
+	keycode_map[0x74] = KEY_F5;
+	keycode_map[0x75] = KEY_F6;
+	keycode_map[0x76] = KEY_F7;
+	keycode_map[0x77] = KEY_F8;
+	keycode_map[0x78] = KEY_F9;
+	keycode_map[0x79] = KEY_F10;
+	keycode_map[0x7A] = KEY_F11;
+	keycode_map[0x7B] = KEY_F12;
+	keycode_map[0x7C] = KEY_F13;
+	keycode_map[0x7D] = KEY_F14;
+	keycode_map[0x7E] = KEY_F15;
+	keycode_map[0x7F] = KEY_F16;
+	keycode_map[0x80] = KEY_F17;
+	keycode_map[0x81] = KEY_F18;
+	keycode_map[0x82] = KEY_F19;
+	keycode_map[0x83] = KEY_F20;
+	keycode_map[0x84] = KEY_F21;
+	keycode_map[0x85] = KEY_F22;
+	keycode_map[0x86] = KEY_F23;
+	keycode_map[0x87] = KEY_F24;
+	keycode_map[0x88] = KEY_LEFT_ALT;
+	keycode_map[VK_CONTROL] = KEY_LEFT_CONTROL;
+	keycode_map[VK_LCONTROL] = KEY_LEFT_CONTROL;
+	keycode_map[VK_LSHIFT] = KEY_LEFT_SHIFT;
+	keycode_map[VK_LWIN] = KEY_LEFT_SUPER;
+	keycode_map[VK_SNAPSHOT] = KEY_PRINT_SCREEN;
+	keycode_map[VK_RMENU] = KEY_RIGHT_ALT;
+	keycode_map[VK_RCONTROL] = KEY_RIGHT_CONTROL;
+	keycode_map[VK_RSHIFT] = KEY_RIGHT_SHIFT;
+	keycode_map[VK_RWIN] = KEY_RIGHT_SUPER;
+	keycode_map[VK_DOWN] = KEY_DOWN;
+	keycode_map[VK_LEFT] = KEY_LEFT;
+	keycode_map[VK_RIGHT] = KEY_RIGHT;
+	keycode_map[VK_UP] = KEY_UP;
+	
+	keycode_map[VK_NUMPAD0] = KEY_KP_0;
+	keycode_map[VK_NUMPAD1] = KEY_KP_1;
+	keycode_map[VK_NUMPAD2] = KEY_KP_2;
+	keycode_map[VK_NUMPAD3] = KEY_KP_3;
+	keycode_map[VK_NUMPAD4] = KEY_KP_4;
+	keycode_map[VK_NUMPAD5] = KEY_KP_5;
+	keycode_map[VK_NUMPAD6] = KEY_KP_6;
+	keycode_map[VK_NUMPAD7] = KEY_KP_7;
+	keycode_map[VK_NUMPAD8] = KEY_KP_8;
+	keycode_map[VK_NUMPAD9] = KEY_KP_9;
+	keycode_map[VK_ADD] = KEY_KP_ADD;
+	keycode_map[VK_DECIMAL] = KEY_KP_DECIMAL;
+	keycode_map[VK_DIVIDE] = KEY_KP_DIVIDE;
+	keycode_map[VK_MULTIPLY] = KEY_KP_MULTIPLY;
+	keycode_map[VK_SUBTRACT] = KEY_KP_SUBTRACT;
+}
+
+bool platform_file_exists(char *path)
+{
+	DWORD dwAttrib = GetFileAttributes(path);
+	
+	return (dwAttrib != INVALID_FILE_ATTRIBUTES && 
+			!(dwAttrib & FILE_ATTRIBUTE_DIRECTORY));
+}
+
+void platform_create_config_directory()
+{
+	char tmp[PATH_MAX];
+	if(SUCCEEDED(SHGetFolderPathA(0, CSIDL_LOCAL_APPDATA|CSIDL_FLAG_CREATE, NULL, 0, tmp)))
+	{
+		string_appendn(tmp, "/text-search", PATH_MAX);
+	}
+	
+	
+	if (!platform_directory_exists(tmp))
+	{
+		CreateDirectoryA(tmp, NULL);
+	}
+}
+
+char* get_config_save_location(char *buffer)
+{
+	if(SUCCEEDED(SHGetFolderPathA(0, CSIDL_LOCAL_APPDATA|CSIDL_FLAG_CREATE, NULL, 0, buffer)))
+	{
+		string_appendn(buffer, "\\text-search\\config.txt", MAX_INPUT_LENGTH);
+		return buffer;
+	}
+	
+	return 0;
+}
+
+void platform_show_message(platform_window *window, char *message, char *title)
+{
+	HWND handle = window ? window->window_handle : NULL;
+	MessageBox(handle, message, title, MB_ICONINFORMATION | MB_OK);
+}
+
+LRESULT CALLBACK main_window_callback(HWND window, UINT message, WPARAM wparam, LPARAM lparam)
+{
+	LRESULT result = 0;
+	
+	if (message == WM_SIZE)
+	{
+		u32 width = lparam&0xFFFF;
+		u32 height = lparam>>16;
+		
+		current_window_to_handle->width = width;
+		current_window_to_handle->height = height;
+	}
+	else if (message == WM_CHAR)
+	{
+		if (current_keyboard_to_handle->take_input)
+		{
+			char buf[5];
+			memset(buf, 0, 5);
+			char *ch = 0;
+			
+			wchar_t codep = wparam;
+			
+			WideCharToMultiByte(CP_UTF8, 0, &codep, 1, buf, 5 ,0,0);
+			
+			if (utf8len(buf) == 1)
+			{
+				char val = buf[0];
+				
+				if (current_keyboard_to_handle->input_mode == INPUT_NUMERIC)
+				{
+					if (!(val >= 48 && val <= 57))
+					{
+						ch = 0;
+					}
+					else
+					{
+						snprintf(buf, 2,  "%c", val);
+						ch = buf;
+					}
+				}
+				else if (val >= 32 && val <= 126)
+				{
+					snprintf(buf, 5, "%c", val);
+					ch = buf;
+				}
+			}
+			
+			if (ch != 0)
+				keyboard_handle_input_string(current_window_to_handle, current_keyboard_to_handle, ch);
+		}
+	}
+	else if (message == WM_MOUSELEAVE)
+	{
+		//current_mouse_to_handle->x = MOUSE_OFFSCREEN;
+		//current_mouse_to_handle->y = MOUSE_OFFSCREEN;
+	}
+	else if (message == WM_KILLFOCUS)
+	{
+		current_mouse_to_handle->x = MOUSE_OFFSCREEN;
+		current_mouse_to_handle->y = MOUSE_OFFSCREEN;
+		
+		current_window_to_handle->has_focus = false;
+		memset(current_keyboard_to_handle->keys, 0, MAX_KEYCODE);
+	}
+	else if (message == WM_SETFOCUS)
+	{
+		current_window_to_handle->has_focus = true;
+	}
+	else if (message == WM_KEYDOWN)
+	{
+		s32 key = wparam;
+		
+		current_keyboard_to_handle->keys[keycode_map[key]] = true;
+		current_keyboard_to_handle->input_keys[keycode_map[key]] = true;
+		
+		if (current_keyboard_to_handle->take_input)
+			keyboard_handle_input_string(current_window_to_handle, 
+										 current_keyboard_to_handle, 0);
+	}
+	else if (message == WM_KEYUP)
+	{
+		s32 key = wparam;
+		current_keyboard_to_handle->keys[keycode_map[key]] = false;
+		current_keyboard_to_handle->input_keys[keycode_map[key]] = false;
+	}
+	else if (message == WM_LBUTTONDOWN || 
+			 message == WM_RBUTTONDOWN ||
+			 message == WM_MBUTTONDOWN ||
+			 message == WM_MOUSEWHEEL)
+	{
+		bool is_left_down = wparam & MK_LBUTTON;
+		bool is_right_down = wparam & MK_RBUTTON;
+		bool is_middle_down = wparam & MK_MBUTTON;
+		
+		u64 ev_time = platform_get_time(TIME_FULL, TIME_MILI_S);
+		static u64  last_ev_time = 0;
+		
+		if (message == WM_MOUSEWHEEL)
+		{
+			s16 scroll_val = wparam>>16;
+			
+			if (scroll_val < 0)
+				current_mouse_to_handle->scroll_state = SCROLL_DOWN;
+			else
+				current_mouse_to_handle->scroll_state = SCROLL_UP;
+		}
+		
+		if (is_left_down)
+		{
+			if (ev_time - last_ev_time < 200)
+			{
+				current_mouse_to_handle->left_state |= MOUSE_DOUBLE_CLICK;
+			}
+			
+			current_mouse_to_handle->left_state |= MOUSE_DOWN;
+			current_mouse_to_handle->left_state |= MOUSE_CLICK;
+			
+			current_mouse_to_handle->total_move_x = 0;
+			current_mouse_to_handle->total_move_y = 0;
+			last_ev_time = ev_time;
+		}
+		if (is_right_down)
+		{
+			current_mouse_to_handle->right_state |= MOUSE_DOWN;
+			current_mouse_to_handle->right_state |= MOUSE_CLICK;
+		}
+	}
+	else if (message == WM_LBUTTONUP || 
+			 message == WM_RBUTTONUP ||
+			 message == WM_MBUTTONUP)
+	{
+		bool is_left_up = message == WM_LBUTTONUP;
+		bool is_right_up = message == WM_RBUTTONUP;
+		bool is_middle_up = message == WM_MBUTTONUP;
+		
+		if (is_left_up)
+		{
+			current_mouse_to_handle->left_state = MOUSE_RELEASE;
+		}
+		if (is_right_up)
+		{
+			current_mouse_to_handle->right_state = MOUSE_RELEASE;
+		}
+	}
+	else if (message == WM_MOUSEMOVE)
+	{
+		current_window_to_handle->curr_cursor_type = -999;
+		
+#if 0
+		s32 x = lparam&0xFFFF;
+		s32 y = lparam>>16;
+		
+		current_mouse_to_handle->x = x;
+		current_mouse_to_handle->y = y;
+#endif
+		
+		TRACKMOUSEEVENT track;
+		track.cbSize = sizeof(track);
+		track.dwFlags = TME_LEAVE;
+		track.hwndTrack = current_window_to_handle->window_handle;
+		TrackMouseEvent(&track);
+	}
+	else if (message == WM_GETMINMAXINFO)
+	{
+		MINMAXINFO *info = (MINMAXINFO*)lparam;
+		
+		info->ptMinTrackSize.x = current_window_to_handle->min_width;
+		info->ptMinTrackSize.y = current_window_to_handle->min_height;
+		
+		if (current_window_to_handle->max_width)
+			info->ptMaxTrackSize.x = current_window_to_handle->max_width;
+		if (current_window_to_handle->max_height)
+			info->ptMaxTrackSize.y = current_window_to_handle->max_height;
+	}
+	else if (message == WM_DESTROY)
+	{
+		current_window_to_handle->is_open = false;
+	}
+	else if (message == WM_CLOSE)
+	{
+		current_window_to_handle->is_open = false;
+	}
+	else
+	{
+		result = LSMProc(window, message, wparam, lparam);
+	}
+	
+	return result;
+}
+
+void platform_window_set_title(platform_window *window, char *name)
+{
+	SetWindowText(window->window_handle, name);
+}
+
+vec2 platform_get_window_size(platform_window *window)
+{
+	RECT rec;
+	GetWindowRect(window->window_handle, &rec);
+	vec2 res;
+	res.x = rec.right - rec.left;
+	res.y = rec.bottom - rec.top;
+	return res;
+}
+
+void platform_get_focus(platform_window *window)
+{
+	SetFocus(window->window_handle);
+}
+
+platform_window platform_open_window(char *name, u16 width, u16 height, u16 max_w, u16 max_h, u16 min_w, u16 min_h)
+{
+#if !defined(MODE_GDBDEBUG) && !defined(MODE_DEVELOPER)
+	ShowWindow(GetConsoleWindow(), SW_HIDE);
+#endif
+	
+	platform_window window;
+	window.has_focus = true;
+	window.window_handle = 0;
+	window.hdc = 0;
+	window.width = width;
+	window.height = height;
+	window.min_width = min_w;
+	window.min_height = min_h;
+	window.max_width = max_w;
+	window.max_height = max_h;
+	window.curr_cursor_type = -1;
+	window.next_cursor_type = CURSOR_DEFAULT;
+	
+	current_window_to_handle = &window;
+	
+	memset(&window.window_class, 0, sizeof(WNDCLASS));
+	window.window_class.style = CS_OWNDC;
+	window.window_class.lpfnWndProc = main_window_callback;
+	window.window_class.hInstance = instance;
+	window.window_class.lpszClassName = name;
+	window.window_class.hIcon = LoadIcon(NULL, IDI_WINLOGO);
+	//window.window_class.hCursor = LoadCursor(NULL, IDC_ARROW);
+	
+	if (RegisterClass(&window.window_class))
+	{
+		int style = WS_VISIBLE|WS_SYSMENU|WS_CAPTION|WS_MINIMIZEBOX;
+		
+		if (min_w != max_w && min_h != max_h)
+			style |= WS_SIZEBOX;
+		else
+			style |= WS_THICKFRAME;
+		
+		window.window_handle = CreateWindowEx(0,
+											  window.window_class.lpszClassName,
+											  name,
+											  style,
+											  CW_USEDEFAULT,
+											  CW_USEDEFAULT,
+											  width,
+											  height,
+											  0,
+											  0,
+											  instance,
+											  0);
+		
+		if (window.window_handle)
+		{
+			window.hdc = GetDC(window.window_handle);
+			
+			PIXELFORMATDESCRIPTOR format;
+			memset(&format, 0, sizeof(PIXELFORMATDESCRIPTOR));
+			format.nSize = sizeof(PIXELFORMATDESCRIPTOR);
+			format.nVersion = 1;
+			format.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER;
+			format.cColorBits = 24;
+			format.cAlphaBits = 8;
+			format.iLayerType = PFD_MAIN_PLANE; // PFD_TYPE_RGBA
+			s32 suggested_format_index = ChoosePixelFormat(window.hdc, &format);
+			
+			PIXELFORMATDESCRIPTOR actual_format;
+			DescribePixelFormat(window.hdc, suggested_format_index, sizeof(actual_format), &actual_format);
+			SetPixelFormat(window.hdc, suggested_format_index, &actual_format);
+			
+			window.gl_context = wglCreateContext(window.hdc);
+			
+			static HGLRC share_list = 0;
+			if (share_list == 0)
+			{
+				share_list = window.gl_context;
+			}
+			else
+			{
+				wglShareLists(share_list, window.gl_context);
+			}
+			
+			wglMakeCurrent(window.hdc, window.gl_context);
+			
+			ShowWindow(window.window_handle, cmd_show);
+			
+			// blending
+			glEnable(GL_DEPTH_TEST);
+			//glDepthMask(true);
+			//glClearDepth(50);
+			glDepthFunc(GL_LEQUAL);
+			
+			glEnable(GL_BLEND);
+			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+			
+			// setup multisampling
+#if 0
+			glEnable(GL_ALPHA_TEST);
+			glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
+			glEnable(GL_SAMPLE_ALPHA_TO_ONE);
+			glEnable(GL_MULTISAMPLE);
+			glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST);
+#endif
+			
+			// https://stackoverflow.com/questions/5627229/sub-pixel-drawing-with-opengl
+			//glHint(GL_POINT_SMOOTH, GL_NICEST);
+			//glHint(GL_LINE_SMOOTH, GL_NICEST);
+			//glHint(GL_POLYGON_SMOOTH, GL_NICEST);
+			
+			//glEnable(GL_SMOOTH);
+			//glEnable(GL_POINT_SMOOTH);
+			//glEnable(GL_LINE_SMOOTH);
+			//glEnable(GL_POLYGON_SMOOTH);
+			//////////////////
+			
+			window.is_open = true;
+			
+			glMatrixMode(GL_PROJECTION);
+			glLoadIdentity();
+			glOrtho(0, width, height, 0, -1, 1);
+			
+			//GLint m_viewport[4];
+			//glGetIntegerv( GL_VIEWPORT, m_viewport );
+			//printf("%d %d %d %d\n", m_viewport[0], m_viewport[1], m_viewport[2], m_viewport[3]);
+			
+			glMatrixMode(GL_MODELVIEW);
+			
+			TRACKMOUSEEVENT track;
+			track.cbSize = sizeof(track);
+			track.dwFlags = TME_LEAVE;
+			track.hwndTrack = window.window_handle;
+			TrackMouseEvent(&track);
+		}
+		else
+		{
+			platform_show_message(0, "An error occured within Windows, please restart the program.", "Error");
+			abort();
+		}
+	}
+	else
+	{
+		platform_show_message(0, "An error occured within Windows, please restart the program.", "Error");
+		abort();
+	}
+	
+	platform_get_focus(&window);
+	
+	return window;
+}
+
+void platform_window_set_size(platform_window *window, u16 width, u16 height)
+{
+	s32 style = GetWindowLong(window->window_handle, GWL_STYLE);
+	BOOL menu = FALSE;
+	
+	RECT rec;
+	rec.left = 0;
+	rec.top = 0;
+	rec.right = width;
+	rec.bottom = height;
+	AdjustWindowRectEx(&rec, style, menu, 0);
+	SetWindowPos(window->window_handle,NULL,rec.left,rec.top,rec.right,rec.bottom,SWP_NOMOVE|SWP_NOZORDER);
+}
+
+void platform_window_set_position(platform_window *window, u16 x, u16 y)
+{
+	RECT rec;
+	GetWindowRect(window->window_handle, &rec);
+	MoveWindow(window->window_handle, x, y, rec.right-rec.left, rec.bottom-rec.top, FALSE);
+}
+
+bool platform_window_is_valid(platform_window *window)
+{
+	return window->hdc && window->window_handle;
+}
+
+void platform_destroy_window(platform_window *window)
+{
+	wglMakeCurrent(NULL, NULL);
+	wglDeleteContext(window->gl_context);
+	
+	ReleaseDC(window->window_handle, window->hdc);
+	CloseWindow(window->window_handle);
+	DestroyWindow(window->window_handle);
+	UnregisterClassA(window->window_class.lpszClassName, instance);
+	window->hdc = 0;
+	window->window_handle = 0;
+}
+
+void platform_handle_events(platform_window *window, mouse_input *mouse, keyboard_input *keyboard)
+{
+	current_window_to_handle = window;
+	current_keyboard_to_handle = keyboard;
+	current_mouse_to_handle = mouse;
+	
+	mouse->left_state &= ~MOUSE_CLICK;
+	mouse->right_state &= ~MOUSE_CLICK;
+	mouse->left_state &= ~MOUSE_DOUBLE_CLICK;
+	mouse->right_state &= ~MOUSE_DOUBLE_CLICK;
+	mouse->left_state &= ~MOUSE_RELEASE;
+	mouse->right_state &= ~MOUSE_RELEASE;
+	memset(keyboard->input_keys, 0, MAX_KEYCODE);
+	mouse->move_x = 0;
+	mouse->move_y = 0;
+	mouse->scroll_state = 0;
+	keyboard->text_changed = false;
+	
+	// mouse position (including outside of window)
+	current_window_to_handle->has_focus = GetFocus() == current_window_to_handle->window_handle;
+	
+	if (current_window_to_handle->has_focus)
+	{
+		if((GetKeyState(VK_LBUTTON) & 0x100) == 0)
+		{
+			current_mouse_to_handle->left_state = MOUSE_RELEASE;
+		}
+		
+		RECT rec;
+		GetWindowRect(window->window_handle, &rec);
+		POINT p;
+		GetCursorPos(&p);
+		mouse->x = p.x - rec.left - GetSystemMetrics(SM_CYSIZEFRAME);
+		mouse->y = p.y - rec.top - GetSystemMetrics(SM_CYSIZE) - GetSystemMetrics(SM_CYFRAME);
+		//printf("%d %d\n",GetSystemMetrics(SM_CYSIZE), GetSystemMetrics(SM_CYFRAME));
+	}
+	
+	MSG message;
+	while(PeekMessageA(&message, window->window_handle, 0, 0, TRUE))
+	{
+		TranslateMessage(&message); 
+		SizingCheck(&message);
+		DispatchMessage(&message); 
+	}
+	
+	glViewport(0, 0, window->width, window->height);
+}
+
+void platform_window_swap_buffers(platform_window *window)
+{
+	// set cursor if changed
+	if (window->curr_cursor_type != window->next_cursor_type)
+	{
+		char *cursor_shape = 0;
+		switch(window->next_cursor_type)
+		{
+			case CURSOR_DEFAULT: cursor_shape = IDC_ARROW; break;
+			case CURSOR_POINTER: cursor_shape = IDC_HAND; break;
+		}
+		
+		HCURSOR cursor = LoadCursorA(NULL, cursor_shape);
+		
+		window->curr_cursor_type = window->next_cursor_type;
+		SetCursor(cursor);
+	}
+	
+	SwapBuffers(window->hdc);
+}
+
+file_content platform_read_file_content(char *path, const char *mode)
+{
+	file_content result;
+	result.content = 0;
+	result.content_length = 0;
+	result.file_error = 0;
+	
+	FILE *file = fopen(path, mode);
+	if (!file) 
+	{
+		if (errno == EMFILE)
+			result.file_error = FILE_ERROR_TOO_MANY_OPEN_FILES_PROCESS;
+		else if (errno == ENFILE)
+			result.file_error = FILE_ERROR_TOO_MANY_OPEN_FILES_SYSTEM;
+		else if (errno == EACCES)
+			result.file_error = FILE_ERROR_NO_ACCESS;
+		else if (errno == EPERM)
+			result.file_error = FILE_ERROR_NO_ACCESS;
+		else if (errno == ENOENT)
+			result.file_error = FILE_ERROR_NOT_FOUND;
+		else if (errno == ECONNABORTED)
+			result.file_error = FILE_ERROR_CONNECTION_ABORTED;
+		else if (errno == ECONNREFUSED)
+			result.file_error = FILE_ERROR_CONNECTION_REFUSED;
+		else if (errno == ENETDOWN)
+			result.file_error = FILE_ERROR_NETWORK_DOWN;
+		else
+		{
+			result.file_error = FILE_ERROR_GENERIC;
+			printf("ERROR: %d\n", errno);
+		}
+		
+		goto done_failure;
+	}
+	
+	fseek(file, 0 , SEEK_END);
+	int length = ftell(file);
+	fseek(file, 0, SEEK_SET);
+	
+	s32 length_to_alloc = length+1;
+	
+	result.content = mem_alloc(length_to_alloc);
+	if (!result.content) goto done;
+	
+	memset(result.content, 0, length);
+	s32 read_result = fread(result.content, 1, length, file);
+	if (read_result == 0 && length != 0)
+	{
+		mem_free(result.content);
+		result.content = 0;
+		return result;
+	}
+	
+	result.content_length = read_result;
+	
+	((char*)result.content)[length] = 0;
+	
+	done:
+	fclose(file);
+	done_failure:
+	return result;
+}
+
+bool platform_write_file_content(char *path, const char *mode, char *buffer, s32 len)
+{
+	bool result = false;
+	
+	FILE *file = fopen(path, mode);
+	
+	if (!file)
+	{
+		goto done_failure;
+	}
+	else
+	{
+		fprintf(file, buffer);
+	}
+	
+	//done:
+	fclose(file);
+	done_failure:
+	return result;
+}
+
+void platform_destroy_file_content(file_content *content)
+{
+	assert(content);
+	mem_free(content->content);
+}
+
+bool get_active_directory(char *buffer)
+{
+	return GetCurrentDirectory(MAX_INPUT_LENGTH, buffer);
+}
+
+bool set_active_directory(char *path)
+{
+	return SetCurrentDirectory(path);
+}
+
+void platform_list_files_block(array *list, char *start_dir, array filters, bool recursive, memory_bucket *bucket,  bool include_directories, bool *is_cancelled)
+{
+	assert(list);
+	s32 len = 0;
+	char *matched_filter = 0;
+	
+	char *subdirname_buf;
+	if (bucket)
+		subdirname_buf = memory_bucket_reserve(bucket, MAX_INPUT_LENGTH);
+	else
+		subdirname_buf = mem_alloc(MAX_INPUT_LENGTH);
+	
+	char *start_dir_fix;
+	if (bucket)
+		start_dir_fix = memory_bucket_reserve(bucket, MAX_INPUT_LENGTH);
+	else
+		start_dir_fix = mem_alloc(MAX_INPUT_LENGTH);
+	snprintf(start_dir_fix, MAX_INPUT_LENGTH, "%s*", start_dir);
+	
+	char *start_dir_clean;
+	if (bucket)
+		start_dir_clean = memory_bucket_reserve(bucket, MAX_INPUT_LENGTH);
+	else
+		start_dir_clean = mem_alloc(MAX_INPUT_LENGTH);
+	string_copyn(start_dir_clean, start_dir, MAX_INPUT_LENGTH);
+	
+	WIN32_FIND_DATAA file_info;
+	HWND handle = FindFirstFileA(start_dir_fix, &file_info);
+	
+	if (!bucket)
+		mem_free(start_dir_fix);
+	
+	if (handle == INVALID_HANDLE_VALUE)
+	{
+		return;
+	}
+	
+	do
+	{
+		if (*is_cancelled) break;
+		char *name = file_info.cFileName;
+		
+		// symbolic link is not allowed..
+		if ((file_info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
+			continue;
+		
+		
+		if ((file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
+		{
+			if ((strcmp(name, ".") == 0) || (strcmp(name, "..") == 0))
+				continue;
+			
+			if (include_directories)
+			{
+				if ((len = filter_matches(&filters, name, 
+										  &matched_filter)) && len != -1)
+				{
+					// is file
+					char *buf;
+					if (bucket)
+						buf = memory_bucket_reserve(bucket, MAX_INPUT_LENGTH);
+					else
+						buf = mem_alloc(MAX_INPUT_LENGTH);
+					snprintf(buf, MAX_INPUT_LENGTH, "%s%s",start_dir, name);
+					
+					found_file f;
+					f.path = buf;
+					
+					if (bucket)
+						f.matched_filter= memory_bucket_reserve(bucket, len+1);
+					else
+						f.matched_filter= mem_alloc(len+1);
+					
+					string_copyn(f.matched_filter, matched_filter, len+1);
+					
+					mutex_lock(&list->mutex);
+					array_push_size(list, &f, sizeof(found_file));
+					mutex_unlock(&list->mutex);
+				}
+			}
+			
+			if (recursive)
+			{
+				string_copyn(subdirname_buf, start_dir_clean, MAX_INPUT_LENGTH);
+				string_appendn(subdirname_buf, name, MAX_INPUT_LENGTH);
+				string_appendn(subdirname_buf, "\\", MAX_INPUT_LENGTH);
+				
+				// is directory
+				platform_list_files_block(list, subdirname_buf, filters, recursive, bucket, include_directories, is_cancelled);
+			}
+		}
+		else if ((file_info.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) ||
+				 (file_info.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) ||
+				 (file_info.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) ||
+				 (file_info.dwFileAttributes & FILE_ATTRIBUTE_NORMAL) || 
+				 (file_info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ||
+				 (file_info.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE))
+		{
+			if ((len = filter_matches(&filters, name, 
+									  &matched_filter)) && len != -1)
+			{
+				// is file
+				char *buf;
+				if (bucket)
+					buf = memory_bucket_reserve(bucket, MAX_INPUT_LENGTH);
+				else
+					buf = mem_alloc(MAX_INPUT_LENGTH);
+				
+				snprintf(buf, MAX_INPUT_LENGTH, "%s%s",start_dir, name);
+				
+				found_file f;
+				f.path = buf;
+				
+				if (bucket)
+					f.matched_filter = memory_bucket_reserve(bucket, len+1);
+				else
+					f.matched_filter = mem_alloc(len+1);
+				
+				string_copyn(f.matched_filter, matched_filter, len+1);
+				
+				mutex_lock(&list->mutex);
+				array_push_size(list, &f, sizeof(found_file));
+				mutex_unlock(&list->mutex);
+			}
+		}
+	}
+	while (FindNextFile(handle, &file_info) != 0);
+	
+	if (!bucket)
+		mem_free(start_dir_clean);
+	
+	FindClose(handle);
+}
+
+static void* platform_open_file_dialog_implementation(void *data)
+{
+	struct open_dialog_args *args = data;
+	
+	OPENFILENAME info;
+	info.lStructSize = sizeof(OPENFILENAME);
+	info.hwndOwner = NULL;
+	info.hInstance = NULL;
+	
+	char filter[MAX_INPUT_LENGTH];
+	memset(filter, 0, MAX_INPUT_LENGTH);
+	
+	if (args->file_filter)
+	{
+		string_copyn(filter, args->file_filter, MAX_INPUT_LENGTH);
+		filter[strlen(filter)] = 0;
+		filter[strlen(filter)+1] = 0;
+		info.lpstrFilter = filter;
+	}
+	else
+	{
+		info.lpstrFilter = NULL;
+	}
+	
+	char szFile[MAX_INPUT_LENGTH];
+	memset(szFile, 0, MAX_INPUT_LENGTH);
+	
+	info.lpstrCustomFilter = NULL;
+	info.nMaxCustFilter = MAX_INPUT_LENGTH;
+	info.nFilterIndex = 0;
+	info.lpstrFile = (char*)szFile;
+	info.nMaxFile = MAX_INPUT_LENGTH;
+	
+	info.lpstrDefExt = args->default_save_file_extension;
+	
+	info.lpstrFileTitle = NULL;
+	info.lpstrInitialDir = args->start_path;
+	info.lpstrTitle = NULL;
+	
+	if (args->type == SAVE_FILE)
+	{
+		info.Flags = OFN_EXTENSIONDIFFERENT | OFN_OVERWRITEPROMPT;
+		GetSaveFileNameA(&info);
+		string_copyn(args->buffer, info.lpstrFile, MAX_INPUT_LENGTH);
+	}
+	else if (args->type == OPEN_DIRECTORY)
+	{
+		BROWSEINFOA inf;
+		PIDLIST_ABSOLUTE result = SHBrowseForFolderA(&inf);
+		if (!result) return 0;
+		
+		SHGetPathFromIDListA(result, args->buffer);
+	}
+	else if (args->type == OPEN_FILE)
+	{
+		info.Flags = OFN_FILEMUSTEXIST;
+		GetOpenFileNameA(&info);
+		string_copyn(args->buffer, info.lpstrFile, MAX_INPUT_LENGTH);
+	}
+	
+	return 0;
+}
+
+void *platform_open_file_dialog_block(void *arg)
+{
+	platform_open_file_dialog_implementation(arg);
+	mem_free(arg);
+	return 0;
+}
+
+char *platform_get_full_path(char *file)
+{
+	char *buf = mem_alloc(MAX_INPUT_LENGTH);
+	if (!GetFullPathNameA(file, MAX_INPUT_LENGTH, buf, NULL))
+	{
+		buf[0] = 0;
+	}
+	
+	return buf;
+}
+
+void platform_open_url(char *command)
+{
+	platform_run_command(command);
+}
+
+void platform_run_command(char *command)
+{
+	// might be start instead of open
+	ShellExecuteA(NULL, "open", command, NULL, NULL, SW_SHOWDEFAULT);
+}
+
+void platform_window_make_current(platform_window *window)
+{
+	wglMakeCurrent(window->hdc, window->gl_context);
+}
+
+void platform_init(int argc, char **argv)
+{
+	setlocale(LC_ALL, "en_US.UTF-8");
+	
+	QueryPerformanceFrequency(&perf_frequency);
+	CoInitialize(NULL);
+	create_key_tables();
+	
+	instance = GetModuleHandle(NULL);
+	cmd_show = argc;
+	
+	// get fullpath of the directory the exe is residing in
+	binary_path = platform_get_full_path(argv[0]);
+	
+	platform_create_config_directory();
+	
+	char buf[MAX_INPUT_LENGTH];
+	get_directory_from_path(buf, binary_path);
+	string_copyn(binary_path, buf, MAX_INPUT_LENGTH);
+	
+	assets_create();
+}
+
+void platform_set_icon(platform_window *window, image *img)
+{
+	BYTE *bmp;
+	s32 data_len = img->width * img->height * 4;
+	s32 total_len = data_len + 40 * 4;
+	
+	bmp = mem_alloc(total_len);
+	
+	struct {
+		int32_t header_size, width, geight;
+		int16_t color_plane, bits_per_pixel;
+		int32_t compression_mode, img_length, obsolete[4];
+	} bmp_header = {40, img->width, img->height * 2, 1, 32, BI_RGB, data_len, {0,0,0,0} };
+	
+	memcpy(bmp, &bmp_header, 40);
+	
+	s32 index = 0;
+	for (s32 y = img->height-1; y >= 0; y--)
+	{
+		for (s32 x = 0; x < img->width; x++)
+		{
+			s32 img_pixel = *(((s32*)img->data+(x+(y*img->width))));
+			
+			// 0xAABBGGRR
+			s32 a = (img_pixel>>24) & 0x000000FF;
+			s32 b = (img_pixel>>16) & 0x000000FF;
+			s32 g = (img_pixel>> 8) & 0x000000FF;
+			s32 r = (img_pixel>> 0) & 0x000000FF;
+			
+			//s32 c = (r << 24) | (g << 16) | (b << 8) | (a << 0);
+			s32 c = (a << 24) | (r << 16) | (g << 8) | (b << 0);
+			memcpy(bmp+40+(index*4), &c, 4);
+			
+			++index;
+		}
+	}
+	
+	HICON icon = CreateIconFromResourceEx(bmp, total_len, TRUE, 0x00030000, img->width, img->height, LR_DEFAULTCOLOR);
+	
+	SendMessage(window->window_handle, WM_SETICON, ICON_SMALL, (LPARAM)icon);
+	SendMessage(window->window_handle, WM_SETICON, ICON_BIG, (LPARAM)icon);
+	
+	mem_free(bmp);
+	
+	if (!icon)
+		printf("Failed to load icon, error code: %ld.\n", GetLastError());
+}
+
+u64 platform_get_time(time_type time_type, time_precision precision)
+{
+	LARGE_INTEGER counter;
+	QueryPerformanceCounter(&counter);
+	
+	double sec = counter.QuadPart / (double)(perf_frequency.QuadPart);
+	
+	//printf("%I64d %I64d %f\n", counter.QuadPart, perf_frequency.QuadPart, sec);
+	
+	double val = sec;
+	
+	if (precision == TIME_NS)
+	{
+		return val*1000000000;
+	}
+	if (precision == TIME_US)
+	{
+		return val*1000000;
+	}
+	if (precision == TIME_MILI_S)
+	{
+		return val*1000;
+	}
+	if (precision == TIME_S)
+	{
+		return val;
+	}
+	return val;
+}
+
+s32 platform_get_memory_size()
+{
+	u64 result;
+	GetPhysicallyInstalledSystemMemory(&result);
+	return result;
+}
+
+s32 platform_get_cpu_count()
+{
+	SYSTEM_INFO info;
+	GetSystemInfo(&info);
+	
+	return info.dwNumberOfProcessors;
+}
+
+u64 string_to_u64(char *str)
+{
+	return (u64)strtoull(str, 0, 10);
+}
+
+u32 string_to_u32(char *str)
+{
+	return (u32)strtoul(str, 0, 10);
+}
+
+u16 string_to_u16(char *str)
+{
+	return (u16)strtoul(str, 0, 10);
+}
+
+u8 string_to_u8(char *str)
+{
+	return (u8)strtoul(str, 0, 10);
+}
+
+s64 string_to_s64(char *str)
+{
+	return (s64)strtoull(str, 0, 10);
+}
+
+s32 string_to_s32(char *str)
+{
+	return (s32)strtoul(str, 0, 10);
+}
+
+s16 string_to_s16(char *str)
+{
+	return (s16)strtoul(str, 0, 10);
+}
+
+s8 string_to_s8(char *str)
+{
+	return (s8)strtoul(str, 0, 10);
+}
\ No newline at end of file