Window.c

Bug Summary

File:	Window.c
Warning:	line 4563, column 9 Dereference of null pointer (loaded from variable 'visual')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple amd64-unknown-openbsd6.8 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Window.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mthread-model posix -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/local/lib/clang/10.0.1 -I /usr/X11R6/include -I /usr/local/include -fdebug-compilation-dir /home/ben/Projects/ClassiCube/src -ferror-limit 19 -fmessage-length 0 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -fobjc-runtime=gnustep -fdiagnostics-show-option -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/ClassiCube/src/scan/2020-12-10-180422-33404-1 -x c Window.c
1#include "Window.h"
2#include "String.h"
3#include "Platform.h"
4#include "Input.h"
5#include "Event.h"
6#include "Logger.h"
7#include "Funcs.h"
8#include "ExtMath.h"
9#include "Bitmap.h"
10#include "Options.h"
11#include "Errors.h"
12
13struct _DisplayData DisplayInfo;
14struct _WinData WindowInfo;
15
16int Display_ScaleX(int x) { return (int)(x * DisplayInfo.ScaleX); }
17int Display_ScaleY(int y) { return (int)(y * DisplayInfo.ScaleY); }
18#define Display_CentreX(width)(DisplayInfo.X + (DisplayInfo.Width - width) / 2)  (DisplayInfo.X + (DisplayInfo.Width  - width)  / 2)
19#define Display_CentreY(height)(DisplayInfo.Y + (DisplayInfo.Height - height) / 2) (DisplayInfo.Y + (DisplayInfo.Height - height) / 2)
20
21#ifndef CC_BUILD_WEB
22void Clipboard_RequestText(RequestClipboardCallback callback, void* obj) {
23	cc_string text; char textBuffer[2048];
24	String_InitArray(text, textBuffer)text.buffer = textBuffer; text.length = 0; text.capacity = sizeof
(textBuffer);;
25
26	Clipboard_GetText(&text);
27	callback(&text, obj);
28}
29#endif
30
31static int cursorPrevX, cursorPrevY;
32static cc_bool cursorVisible = true1;
33/* Gets the position of the cursor in screen or window coordinates. */
34static void Cursor_GetRawPos(int* x, int* y);
35static void Cursor_DoSetVisible(cc_bool visible);
36
37void Cursor_SetVisible(cc_bool visible) {
38	if (cursorVisible == visible) return;
39	cursorVisible = visible;
40	Cursor_DoSetVisible(visible);
41}
42
43static void CentreMousePosition(void) {
44	Cursor_SetPosition(WindowInfo.Width / 2, WindowInfo.Height / 2);
45	/* Fixes issues with large DPI displays on Windows >= 8.0. */
46	Cursor_GetRawPos(&cursorPrevX, &cursorPrevY);
47}
48
49static void RegrabMouse(void) {
50	if (!WindowInfo.Focused || !WindowInfo.Exists) return;
51	CentreMousePosition();
52}
53
54static void DefaultEnableRawMouse(void) {
55	Input_RawMode = true1;
56	RegrabMouse();
57	Cursor_SetVisible(false0);
58}
59
60static void DefaultUpdateRawMouse(void) {
61	int x, y;
62	Cursor_GetRawPos(&x, &y);
63	Event_RaiseRawMove(&PointerEvents.RawMoved, x - cursorPrevX, y - cursorPrevY);
64	CentreMousePosition();
65}
66
67static void DefaultDisableRawMouse(void) {
68	Input_RawMode = false0;
69	RegrabMouse();
70	Cursor_SetVisible(true1);
71}
72
73/* The actual windowing system specific method to display a message box */
74static void ShowDialogCore(const char* title, const char* msg);
75void Window_ShowDialog(const char* title, const char* msg) {
76	/* Ensure cursor is visible while showing message box */
77	cc_bool visible = cursorVisible;
78
79	if (!visible) Cursor_SetVisible(true1);
80	ShowDialogCore(title, msg);
81	if (!visible) Cursor_SetVisible(false0);
82}
83
84
85struct GraphicsMode { int R, G, B, A, IsIndexed; };
86/* Creates a GraphicsMode compatible with the default display device */
87static void InitGraphicsMode(struct GraphicsMode* m) {
88	int bpp = DisplayInfo.Depth;
89	m->IsIndexed = bpp < 15;
90
91	m->A = 0;
92	switch (bpp) {
93	case 32:
94		m->R = 8; m->G = 8; m->B = 8; m->A = 8; break;
95	case 24:
96		m->R = 8; m->G = 8; m->B = 8; break;
97	case 16:
98		m->R = 5; m->G = 6; m->B = 5; break;
99	case 15:
100		m->R = 5; m->G = 5; m->B = 5; break;
101	case 8:
102		m->R = 3; m->G = 3; m->B = 2; break;
103	case 4:
104		m->R = 2; m->G = 2; m->B = 1; break;
105	default:
106		/* mode->R = 0; mode->G = 0; mode->B = 0; */
107		Logger_Abort2(bpp, "Unsupported bits per pixel"); break;
108	}
109}
110
111
112/*########################################################################################################################*
113*-------------------------------------------------------SDL window--------------------------------------------------------*
114*#########################################################################################################################*/
115#if defined CC_BUILD_SDL
116#include <SDL2/SDL.h>
117#include "Graphics.h"
118static SDL_Window* win_handle;
119
120static void RefreshWindowBounds(void) {
121	SDL_GetWindowSize(win_handle, &WindowInfo.Width, &WindowInfo.Height);
122}
123
124static void Window_SDLFail(const char* place) {
125	char strBuffer[256];
126	cc_string str;
127	String_InitArray_NT(str, strBuffer)str.buffer = strBuffer; str.length = 0; str.capacity = sizeof
(strBuffer) - 1;;
128
129	String_Format2(&str, "Error when %c: %c", place, SDL_GetError());
130	str.buffer[str.length] = '\0';
131	Logger_Abort(str.buffer);
132}
133
134void Window_Init(void) {
135	SDL_DisplayMode mode = { 0 };
136	SDL_Init(SDL_INIT_VIDEO);
137	SDL_GetDesktopDisplayMode(0, &mode);
138
139	DisplayInfo.Width  = mode.w;
140	DisplayInfo.Height = mode.h;
141	DisplayInfo.Depth  = SDL_BITSPERPIXEL(mode.format);
142	DisplayInfo.ScaleX = 1;
143	DisplayInfo.ScaleY = 1;
144}
145
146void Window_Create(int width, int height) {
147	int x = Display_CentreX(width)(DisplayInfo.X + (DisplayInfo.Width - width) / 2);
148	int y = Display_CentreY(height)(DisplayInfo.Y + (DisplayInfo.Height - height) / 2);
149
150	/* TODO: Don't set this flag for launcher window */
151	win_handle = SDL_CreateWindow(NULL((void*)0), x, y, width, height, SDL_WINDOW_OPENGL);
152	if (!win_handle) Window_SDLFail("creating window");
153
154	RefreshWindowBounds();
155	WindowInfo.Exists = true1;
156	WindowInfo.Handle = win_handle;
157}
158
159void Window_SetTitle(const cc_string* title) {
160	char str[NATIVE_STR_LEN600];
161	Platform_EncodeString(str, title);
162	SDL_SetWindowTitle(win_handle, str);
163}
164
165void Clipboard_GetText(cc_string* value) {
166	char* ptr = SDL_GetClipboardText();
167	if (!ptr) return;
168
169	int len = String_Length(ptr);
170	String_AppendUtf8(value, ptr, len);
171	SDL_free(ptr);
172}
173
174void Clipboard_SetText(const cc_string* value) {
175	char str[NATIVE_STR_LEN600];
176	Platform_EncodeString(str, value);
177	SDL_SetClipboardText(str);
178}
179
180void Window_Show(void) { SDL_ShowWindow(win_handle); }
181
182int Window_GetWindowState(void) {
183	Uint32 flags = SDL_GetWindowFlags(win_handle);
184
185	if (flags & SDL_WINDOW_MINIMIZED)          return WINDOW_STATE_MINIMISED;
186	if (flags & SDL_WINDOW_FULLSCREEN_DESKTOP) return WINDOW_STATE_FULLSCREEN;
187	return WINDOW_STATE_NORMAL;
188}
189
190cc_result Window_EnterFullscreen(void) {
191	return SDL_SetWindowFullscreen(win_handle, SDL_WINDOW_FULLSCREEN_DESKTOP);
192}
193cc_result Window_ExitFullscreen(void) { SDL_RestoreWindow(win_handle); return 0; }
194
195void Window_SetSize(int width, int height) {
196	SDL_SetWindowSize(win_handle, width, height);
197}
198
199void Window_Close(void) {
200	SDL_Event e;
201	e.type = SDL_QUIT;
202	SDL_PushEvent(&e);
203}
204
205static int MapNativeKey(SDL_Keycode k) {
206	if (k >= SDLK_0   && k <= SDLK_9)   { return '0'     + (k - SDLK_0); }
207	if (k >= SDLK_a   && k <= SDLK_z)   { return 'A'     + (k - SDLK_a); }
208	if (k >= SDLK_F1  && k <= SDLK_F12) { return KEY_F1  + (k - SDLK_F1); }
209	if (k >= SDLK_F13 && k <= SDLK_F24) { return KEY_F13 + (k - SDLK_F13); }
210	/* SDLK_KP_0 isn't before SDLK_KP_1 */
211	if (k >= SDLK_KP_1 && k <= SDLK_KP_9) { return KEY_KP1 + (k - SDLK_KP_1); }
212
213	switch (k) {
214		case SDLK_RETURN: return KEY_ENTER;
215		case SDLK_ESCAPE: return KEY_ESCAPE;
216		case SDLK_BACKSPACE: return KEY_BACKSPACE;
217		case SDLK_TAB:    return KEY_TAB;
218		case SDLK_SPACE:  return KEY_SPACE;
219		case SDLK_QUOTE:  return KEY_QUOTE;
220		case SDLK_EQUALS: return KEY_EQUALS;
221		case SDLK_COMMA:  return KEY_COMMA;
222		case SDLK_MINUS:  return KEY_MINUS;
223		case SDLK_PERIOD: return KEY_PERIOD;
224		case SDLK_SLASH:  return KEY_SLASH;
225		case SDLK_SEMICOLON:    return KEY_SEMICOLON;
226		case SDLK_LEFTBRACKET:  return KEY_LBRACKET;
227		case SDLK_BACKSLASH:    return KEY_BACKSLASH;
228		case SDLK_RIGHTBRACKET: return KEY_RBRACKET;
229		case SDLK_BACKQUOTE:    return KEY_TILDE;
230		case SDLK_CAPSLOCK:     return KEY_CAPSLOCK;
231		case SDLK_PRINTSCREEN: return KEY_PRINTSCREEN;
232		case SDLK_SCROLLLOCK:  return KEY_SCROLLLOCK;
233		case SDLK_PAUSE:       return KEY_PAUSE;
234		case SDLK_INSERT:   return KEY_INSERT;
235		case SDLK_HOME:     return KEY_HOME;
236		case SDLK_PAGEUP:   return KEY_PAGEUP;
237		case SDLK_DELETE:   return KEY_DELETE;
238		case SDLK_END:      return KEY_END;
239		case SDLK_PAGEDOWN: return KEY_PAGEDOWN;
240		case SDLK_RIGHT: return KEY_RIGHT;
241		case SDLK_LEFT:  return KEY_LEFT;
242		case SDLK_DOWN:  return KEY_DOWN;
243		case SDLK_UP:    return KEY_UP;
244
245		case SDLK_NUMLOCKCLEAR: return KEY_NUMLOCK;
246		case SDLK_KP_DIVIDE: return KEY_KP_DIVIDE;
247		case SDLK_KP_MULTIPLY: return KEY_KP_MULTIPLY;
248		case SDLK_KP_MINUS: return KEY_KP_MINUS;
249		case SDLK_KP_PLUS: return KEY_KP_PLUS;
250		case SDLK_KP_ENTER: return KEY_KP_ENTER;
251		case SDLK_KP_0: return KEY_KP0;
252		case SDLK_KP_PERIOD: return KEY_KP_DECIMAL;
253
254		case SDLK_LCTRL: return KEY_LCTRL;
255		case SDLK_LSHIFT: return KEY_LSHIFT;
256		case SDLK_LALT: return KEY_LALT;
257		case SDLK_LGUI: return KEY_LWIN;
258		case SDLK_RCTRL: return KEY_RCTRL;
259		case SDLK_RSHIFT: return KEY_RSHIFT;
260		case SDLK_RALT: return KEY_RALT;
261		case SDLK_RGUI: return KEY_RWIN;
262	}
263	return KEY_NONE;
264}
265
266static void OnKeyEvent(const SDL_Event* e) {
267	cc_bool pressed = e->key.state == SDL_PRESSED;
268	int key = MapNativeKey(e->key.keysym.sym);
269	if (key) Input_Set(key, pressed);
270}
271
272static void OnMouseEvent(const SDL_Event* e) {
273	cc_bool pressed = e->button.state == SDL_PRESSED;
274	int btn;
275	switch (e->button.button) {
276		case SDL_BUTTON_LEFT:   btn = KEY_LMOUSE; break;
277		case SDL_BUTTON_MIDDLE: btn = KEY_MMOUSE; break;
278		case SDL_BUTTON_RIGHT:  btn = KEY_RMOUSE; break;
279		case SDL_BUTTON_X1:     btn = KEY_XBUTTON1; break;
280		case SDL_BUTTON_X2:     btn = KEY_XBUTTON2; break;
281		default: return;
282	}
283	Input_Set(btn, pressed);
284}
285
286static void OnTextEvent(const SDL_Event* e) {
287	char buffer[SDL_TEXTINPUTEVENT_TEXT_SIZE];
288	cc_string str;
289	int i, len;
290
291	String_InitArray(str, buffer)str.buffer = buffer; str.length = 0; str.capacity = sizeof(buffer
);;
292	len = String_CalcLen(e->text.text, SDL_TEXTINPUTEVENT_TEXT_SIZE);
293	String_AppendUtf8(&str, e->text.text, len);
294
295	for (i = 0; i < str.length; i++) {
296		Event_RaiseInt(&InputEvents.Press, str.buffer[i]);
297	}
298}
299
300static void OnWindowEvent(const SDL_Event* e) {
301	switch (e->window.event) {
302		case SDL_WINDOWEVENT_EXPOSED:
303			Event_RaiseVoid(&WindowEvents.Redraw);
304			break;
305		case SDL_WINDOWEVENT_SIZE_CHANGED:
306			RefreshWindowBounds();
307			Event_RaiseVoid(&WindowEvents.Resized);
308			break;
309		case SDL_WINDOWEVENT_MINIMIZED:
310		case SDL_WINDOWEVENT_MAXIMIZED:
311		case SDL_WINDOWEVENT_RESTORED:
312			Event_RaiseVoid(&WindowEvents.StateChanged);
313			break;
314		case SDL_WINDOWEVENT_FOCUS_GAINED:
315			WindowInfo.Focused = true1;
316			Event_RaiseVoid(&WindowEvents.FocusChanged);
317			break;
318		case SDL_WINDOWEVENT_FOCUS_LOST:
319			WindowInfo.Focused = false0;
320			Event_RaiseVoid(&WindowEvents.FocusChanged);
321			break;
322		case SDL_WINDOWEVENT_CLOSE:
323			Window_Close();
324			break;
325		}
326}
327
328void Window_ProcessEvents(void) {
329	SDL_Event e;
330	while (SDL_PollEvent(&e)) {
331		switch (e.type) {
332
333		case SDL_KEYDOWN:
334		case SDL_KEYUP:
335			OnKeyEvent(&e); break;
336		case SDL_MOUSEBUTTONDOWN:
337		case SDL_MOUSEBUTTONUP:
338			OnMouseEvent(&e); break;
339		case SDL_MOUSEWHEEL:
340			Mouse_ScrollWheel(e.wheel.y);
341			break;
342		case SDL_MOUSEMOTION:
343			Pointer_SetPosition(0, e.motion.x, e.motion.y);
344			if (Input_RawMode) Event_RaiseRawMove(&PointerEvents.RawMoved, e.motion.xrel, e.motion.yrel);
345			break;
346		case SDL_TEXTINPUT:
347			OnTextEvent(&e); break;
348		case SDL_WINDOWEVENT:
349			OnWindowEvent(&e); break;
350
351		case SDL_QUIT:
352			WindowInfo.Exists = false0;
353			Event_RaiseVoid(&WindowEvents.Closing);
354			SDL_DestroyWindow(win_handle);
355			break;
356
357		case SDL_RENDER_DEVICE_RESET:
358			Gfx_LoseContext("SDL device reset event");
359			Gfx_RecreateContext();
360			break;
361		}
362	}
363}
364
365static void Cursor_GetRawPos(int* x, int* y) {
366	SDL_GetMouseState(x, y);
367}
368void Cursor_SetPosition(int x, int y) {
369	SDL_WarpMouseInWindow(win_handle, x, y);
370}
371
372static void Cursor_DoSetVisible(cc_bool visible) {
373	SDL_ShowCursor(visible ? SDL_ENABLE : SDL_DISABLE);
374}
375
376static void ShowDialogCore(const char* title, const char* msg) {
377	SDL_ShowSimpleMessageBox(0, title, msg, win_handle);
378}
379
380static SDL_Surface* surface;
381void Window_AllocFramebuffer(struct Bitmap* bmp) {
382	surface = SDL_GetWindowSurface(win_handle);
383	if (!surface) Window_SDLFail("getting window surface");
384
385	if (SDL_MUSTLOCK(surface)) {
386		int ret = SDL_LockSurface(surface);
387		if (ret < 0) Window_SDLFail("locking window surface");
388	}
389	bmp->scan0 = surface->pixels;
390}
391
392void Window_DrawFramebuffer(Rect2D r) {
393	SDL_Rect rect;
394	rect.x = r.X; rect.w = r.Width;
395	rect.y = r.Y; rect.h = r.Height;
396	SDL_UpdateWindowSurfaceRects(win_handle, &rect, 1);
397}
398
399void Window_FreeFramebuffer(struct Bitmap* bmp) {
400	/* SDL docs explicitly say to NOT free the surface */
401	/* https://wiki.libsdl.org/SDL_GetWindowSurface */
402	/* TODO: Do we still need to unlock it though? */
403}
404
405void Window_OpenKeyboard(const cc_string* text, int type) { SDL_StartTextInput(); }
406void Window_SetKeyboardText(const cc_string* text) { }
407void Window_CloseKeyboard(void) { SDL_StopTextInput(); }
408
409void Window_EnableRawMouse(void) {
410	RegrabMouse();
411	SDL_SetRelativeMouseMode(true1);
412	Input_RawMode = true1;
413}
414void Window_UpdateRawMouse(void) { CentreMousePosition(); }
415
416void Window_DisableRawMouse(void) {
417	RegrabMouse();
418	SDL_SetRelativeMouseMode(false0);
419	Input_RawMode = false0;
420}
421
422
423/*########################################################################################################################*
424*------------------------------------------------------Win32 window-------------------------------------------------------*
425*#########################################################################################################################*/
426#elif defined CC_BUILD_WINGUI
427#define WIN32_LEAN_AND_MEAN
428#define NOSERVICE
429#define NOMCX
430#define NOIME
431#ifndef UNICODE
432#define UNICODE
433#define _UNICODE
434#endif
435
436#ifndef _WIN32_WINNT
437#define _WIN32_WINNT 0x0501 /* Windows XP */
438/* NOTE: Functions that are not present on Windows 2000 are dynamically loaded. */
439/* Hence the actual minimum supported OS is Windows 2000. This just avoids redeclaring structs. */
440#endif
441#include <windows.h>
442
443#define CC_WIN_STYLE WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN
444#define CC_WIN_CLASSNAME TEXT("ClassiCube_Window")
445#define Rect_Width(rect)  (rect.right  - rect.left)
446#define Rect_Height(rect) (rect.bottom - rect.top)
447
448#ifndef WM_XBUTTONDOWN
449/* Missing if _WIN32_WINNT isn't defined */
450#define WM_XBUTTONDOWN 0x020B
451#define WM_XBUTTONUP   0x020C
452#endif
453
454typedef BOOL (WINAPI *FUNC_RegisterRawInput)(PCRAWINPUTDEVICE devices, UINT numDevices, UINT size);
455static FUNC_RegisterRawInput _registerRawInput;
456typedef UINT (WINAPI *FUNC_GetRawInputData)(HRAWINPUT hRawInput, UINT cmd, void* data, UINT* size, UINT headerSize);
457static FUNC_GetRawInputData _getRawInputData;
458
459static HINSTANCE win_instance;
460static HWND win_handle;
461static HDC win_DC;
462static cc_bool suppress_resize;
463static int win_totalWidth, win_totalHeight; /* Size of window including titlebar and borders */
464static int windowX, windowY;
465
466static const cc_uint8 key_map[14 * 16] = {
467	0, 0, 0, 0, 0, 0, 0, 0, KEY_BACKSPACE, KEY_TAB, 0, 0, 0, KEY_ENTER, 0, 0,
468	0, 0, 0, KEY_PAUSE, KEY_CAPSLOCK, 0, 0, 0, 0, 0, 0, KEY_ESCAPE, 0, 0, 0, 0,
469	KEY_SPACE, KEY_PAGEUP, KEY_PAGEDOWN, KEY_END, KEY_HOME, KEY_LEFT, KEY_UP, KEY_RIGHT, KEY_DOWN, 0, KEY_PRINTSCREEN, 0, KEY_PRINTSCREEN, KEY_INSERT, KEY_DELETE, 0,
470	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 0, 0, 0, 0, 0, 0,
471	0, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
472	'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', KEY_LWIN, KEY_RWIN, KEY_MENU, 0, 0,
473	KEY_KP0, KEY_KP1, KEY_KP2, KEY_KP3, KEY_KP4, KEY_KP5, KEY_KP6, KEY_KP7, KEY_KP8, KEY_KP9, KEY_KP_MULTIPLY, KEY_KP_PLUS, 0, KEY_KP_MINUS, KEY_KP_DECIMAL, KEY_KP_DIVIDE,
474	KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F11, KEY_F12, KEY_F13, KEY_F14, KEY_F15, KEY_F16,
475	KEY_F17, KEY_F18, KEY_F19, KEY_F20, KEY_F21, KEY_F22, KEY_F23, KEY_F24, 0, 0, 0, 0, 0, 0, 0, 0,
476	KEY_NUMLOCK, KEY_SCROLLLOCK, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
477	KEY_LSHIFT, KEY_RSHIFT, KEY_LCTRL, KEY_RCTRL, KEY_LALT, KEY_RALT, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
478	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_SEMICOLON, KEY_EQUALS, KEY_COMMA, KEY_MINUS, KEY_PERIOD, KEY_SLASH,
479	KEY_TILDE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
480	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_LBRACKET, KEY_BACKSLASH, KEY_RBRACKET, KEY_QUOTE, 0,
481};
482static int MapNativeKey(WPARAM key, LPARAM meta) {
483	LPARAM ext = meta & (1UL << 24);
484	switch (key)
485	{
486	case VK_CONTROL:
487		return ext ? KEY_RCTRL : KEY_LCTRL;
488	case VK_MENU:
489		return ext ? KEY_RALT  : KEY_LALT;
490	case VK_RETURN:
491		return ext ? KEY_KP_ENTER : KEY_ENTER;
492	default:
493		return key < Array_Elems(key_map)(sizeof(key_map) / sizeof(key_map[0])) ? key_map[key] : 0;
494	}
495}
496
497static void RefreshWindowBounds(void) {
498	RECT rect;
499	POINT topLeft = { 0, 0 };
500
501	GetWindowRect(win_handle, &rect);
502	win_totalWidth  = Rect_Width(rect);
503	win_totalHeight = Rect_Height(rect);
504
505	GetClientRect(win_handle, &rect);
506	WindowInfo.Width  = Rect_Width(rect);
507	WindowInfo.Height = Rect_Height(rect);
508
509	/* GetClientRect always returns 0,0 for left,top (see MSDN) */
510	ClientToScreen(win_handle, &topLeft);
511	windowX = topLeft.x; windowY = topLeft.y;
512}
513
514static LRESULT CALLBACK Window_Procedure(HWND handle, UINT message, WPARAM wParam, LPARAM lParam) {
515	char keyChar;
516	float wheelDelta;
517
518	switch (message) {
519	case WM_ACTIVATE:
520		WindowInfo.Focused = LOWORD(wParam) != 0;
521		Event_RaiseVoid(&WindowEvents.FocusChanged);
522		break;
523
524	case WM_ERASEBKGND:
525		return 1; /* Avoid flickering */
526
527	case WM_PAINT:
528		ValidateRect(win_handle, NULL((void*)0));
529		Event_RaiseVoid(&WindowEvents.Redraw);
530		return 0;
531
532	case WM_WINDOWPOSCHANGED:
533	{
534		WINDOWPOS* pos = (WINDOWPOS*)lParam;
535		if (pos->hwnd != win_handle) break;
536		cc_bool sized = pos->cx != win_totalWidth || pos->cy != win_totalHeight;
537
538		RefreshWindowBounds();
539		if (sized && !suppress_resize) Event_RaiseVoid(&WindowEvents.Resized);
540	} break;
541
542	case WM_SIZE:
543		Event_RaiseVoid(&WindowEvents.StateChanged);
544		break;
545
546	case WM_CHAR:
547		/* TODO: Use WM_UNICHAR instead, as WM_CHAR is just utf16 */
548		if (Convert_TryCodepointToCP437((cc_unichar)wParam, &keyChar)) {
549			Event_RaiseInt(&InputEvents.Press, keyChar);
550		}
551		break;
552
553	case WM_MOUSEMOVE:
554		/* Set before position change, in case mouse buttons changed when outside window */
555		Input_Set(KEY_LMOUSE, wParam & 0x01);
556		Input_Set(KEY_RMOUSE, wParam & 0x02);
557		Input_Set(KEY_MMOUSE, wParam & 0x10);
558		/* TODO: do we need to set XBUTTON1/XBUTTON2 here */
559		Pointer_SetPosition(0, LOWORD(lParam), HIWORD(lParam));
560		break;
561
562	case WM_MOUSEWHEEL:
563		wheelDelta = ((short)HIWORD(wParam)) / (float)WHEEL_DELTA;
564		Mouse_ScrollWheel(wheelDelta);
565		return 0;
566
567	case WM_LBUTTONDOWN:
568		Input_SetPressed(KEY_LMOUSE); break;
569	case WM_MBUTTONDOWN:
570		Input_SetPressed(KEY_MMOUSE); break;
571	case WM_RBUTTONDOWN:
572		Input_SetPressed(KEY_RMOUSE); break;
573	case WM_XBUTTONDOWN:
574		Input_SetPressed(HIWORD(wParam) == 1 ? KEY_XBUTTON1 : KEY_XBUTTON2);
575		break;
576
577	case WM_LBUTTONUP:
578		Input_SetReleased(KEY_LMOUSE); break;
579	case WM_MBUTTONUP:
580		Input_SetReleased(KEY_MMOUSE); break;
581	case WM_RBUTTONUP:
582		Input_SetReleased(KEY_RMOUSE); break;
583	case WM_XBUTTONUP:
584		Input_SetReleased(HIWORD(wParam) == 1 ? KEY_XBUTTON1 : KEY_XBUTTON2);
585		break;
586
587	case WM_INPUT:
588	{
589		RAWINPUT raw;
590		UINT ret, rawSize = sizeof(RAWINPUT);
591		int dx, dy;
592
593		ret = _getRawInputData((HRAWINPUT)lParam, RID_INPUT, &raw, &rawSize, sizeof(RAWINPUTHEADER));
594		if (ret == -1 || raw.header.dwType != RIM_TYPEMOUSE) break;		
595
596		if (raw.data.mouse.usFlags == MOUSE_MOVE_RELATIVE) {
597			dx = raw.data.mouse.lLastX;
598			dy = raw.data.mouse.lLastY;
599		} else if (raw.data.mouse.usFlags == MOUSE_MOVE_ABSOLUTE) {
600			static int prevPosX, prevPosY;
601			dx = raw.data.mouse.lLastX - prevPosX;
602			dy = raw.data.mouse.lLastY - prevPosY;
603
604			prevPosX = raw.data.mouse.lLastX;
605			prevPosY = raw.data.mouse.lLastY;
606		} else { break; }
607
608		if (Input_RawMode) Event_RaiseRawMove(&PointerEvents.RawMoved, (float)dx, (float)dy);
609	} break;
610
611	case WM_KEYDOWN:
612	case WM_KEYUP:
613	case WM_SYSKEYDOWN:
614	case WM_SYSKEYUP:
615	{
616		cc_bool pressed = message == WM_KEYDOWN || message == WM_SYSKEYDOWN;
617		/* Shift/Control/Alt behave strangely when e.g. ShiftRight is held down and ShiftLeft is pressed
618		and released. It looks like neither key is released in this case, or that the wrong key is
619		released in the case of Control and Alt.
620		To combat this, we are going to release both keys when either is released. Hacky, but should work.
621		Win95 does not distinguish left/right key constants (GetAsyncKeyState returns 0).
622		In this case, both keys will be reported as pressed. */
623		cc_bool lShiftDown, rShiftDown;
624		int key;
625
626		if (wParam == VK_SHIFT) {
627			/* The behavior of this key is very strange. Unlike Control and Alt, there is no extended bit
628			to distinguish between left and right keys. Moreover, pressing both keys and releasing one
629			may result in both keys being held down (but not always).*/
630			lShiftDown = ((USHORT)GetKeyState(VK_LSHIFT)) >> 15;
631			rShiftDown = ((USHORT)GetKeyState(VK_RSHIFT)) >> 15;
632
633			if (!pressed || lShiftDown != rShiftDown) {
634				Input_Set(KEY_LSHIFT, lShiftDown);
635				Input_Set(KEY_RSHIFT, rShiftDown);
636			}
637		} else {
638			key = MapNativeKey(wParam, lParam);
639			if (key) Input_Set(key, pressed);
640			else Platform_Log1("Unknown key: %x", &wParam);
641		}
642		return 0;
643	} break;
644
645	case WM_SYSCHAR:
646		return 0;
647
648	case WM_KILLFOCUS:
649		/* TODO: Keep track of keyboard when focus is lost */
650		Input_Clear();
651		break;
652
653	case WM_CLOSE:
654		Event_RaiseVoid(&WindowEvents.Closing);
655		if (WindowInfo.Exists) DestroyWindow(win_handle);
656		WindowInfo.Exists = false0;
657		break;
658
659	case WM_DESTROY:
660		WindowInfo.Exists = false0;
661		UnregisterClass(CC_WIN_CLASSNAME, win_instance);
662
663		if (win_DC) ReleaseDC(win_handle, win_DC);
664		break;
665	}
666	return DefWindowProc(handle, message, wParam, lParam);
667}
668
669
670/*########################################################################################################################*
671*--------------------------------------------------Public implementation--------------------------------------------------*
672*#########################################################################################################################*/
673void Window_Init(void) {
674	HDC hdc = GetDC(NULL((void*)0));
675	DisplayInfo.Width  = GetSystemMetrics(SM_CXSCREEN);
676	DisplayInfo.Height = GetSystemMetrics(SM_CYSCREEN);
677	DisplayInfo.Depth  = GetDeviceCaps(hdc, BITSPIXEL);
678	DisplayInfo.ScaleX = GetDeviceCaps(hdc, LOGPIXELSX) / 96.0f;
679	DisplayInfo.ScaleY = GetDeviceCaps(hdc, LOGPIXELSY) / 96.0f;
680	ReleaseDC(NULL((void*)0), hdc);
681}
682
683void Window_Create(int width, int height) {
684	ATOM atom;
685	RECT r;
686
687	win_instance = GetModuleHandle(NULL((void*)0));
688	/* TODO: UngroupFromTaskbar(); */
689	width  = Display_ScaleX(width);
690	height = Display_ScaleY(height);
691
692	/* Find out the final window rectangle, after the WM has added its chrome (titlebar, sidebars etc). */
693	r.left = Display_CentreX(width)(DisplayInfo.X + (DisplayInfo.Width - width) / 2);  r.right  = r.left + width;
694	r.top  = Display_CentreY(height)(DisplayInfo.Y + (DisplayInfo.Height - height) / 2); r.bottom = r.top  + height;
695	AdjustWindowRect(&r, CC_WIN_STYLE, false0);
696
697	WNDCLASSEX wc = { 0 };
698	wc.cbSize    = sizeof(WNDCLASSEX);
699	wc.style     = CS_OWNDC;
700	wc.hInstance = win_instance;
701	wc.lpfnWndProc   = Window_Procedure;
702	wc.lpszClassName = CC_WIN_CLASSNAME;
703
704	wc.hIcon   = (HICON)LoadImage(win_instance, MAKEINTRESOURCE(1), IMAGE_ICON,
705			GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), 0);
706	wc.hIconSm = (HICON)LoadImage(win_instance, MAKEINTRESOURCE(1), IMAGE_ICON,
707			GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), 0);
708	wc.hCursor = LoadCursor(NULL((void*)0), IDC_ARROW);
709
710	atom = RegisterClassEx(&wc);
711	if (!atom) Logger_Abort2(GetLastError(), "Failed to register window class");
712
713	win_handle = CreateWindowEx(0, MAKEINTATOM(atom), NULL((void*)0), CC_WIN_STYLE,
714		r.left, r.top, Rect_Width(r), Rect_Height(r), NULL((void*)0), NULL((void*)0), win_instance, NULL((void*)0));
715
716	if (!win_handle) Logger_Abort2(GetLastError(), "Failed to create window");
717	RefreshWindowBounds();
718
719	win_DC = GetDC(win_handle);
720	if (!win_DC) Logger_Abort2(GetLastError(), "Failed to get device context");
721	WindowInfo.Exists = true1;
722	WindowInfo.Handle = win_handle;
723}
724
725void Window_SetTitle(const cc_string* title) {
726	TCHAR str[NATIVE_STR_LEN600];
727	Platform_EncodeString(str, title);
728	SetWindowText(win_handle, str);
729}
730
731void Clipboard_GetText(cc_string* value) {
732	cc_bool unicode;
733	HANDLE hGlobal;
734	LPVOID src;
735	SIZE_T size;
736	int i;
737
738	/* retry up to 50 times */
739	for (i = 0; i < 50; i++) {
740		if (!OpenClipboard(win_handle)) {
741			Thread_Sleep(10);
742			continue;
743		}
744
745		unicode = true1;
746		hGlobal = GetClipboardData(CF_UNICODETEXT);
747		if (!hGlobal) {
748			hGlobal = GetClipboardData(CF_TEXT);
749			unicode = false0;
750		}
751
752		if (!hGlobal) { CloseClipboard(); return; }
753		src  = GlobalLock(hGlobal);
754		size = GlobalSize(hGlobal);
755
756		/* ignore trailing NULL at end */
757		/* TODO: Verify it's always there */
758		if (unicode) {
759			String_AppendUtf16(value, (cc_unichar*)src, size - 2);
760		} else {
761			String_DecodeCP1252(value, (cc_uint8*)src,  size - 1);
762		}
763
764		GlobalUnlock(hGlobal);
765		CloseClipboard();
766		return;
767	}
768}
769
770void Clipboard_SetText(const cc_string* value) {
771	cc_unichar* text;
772	HANDLE hGlobal;
773	int i;
774
775	/* retry up to 10 times */
776	for (i = 0; i < 10; i++) {
777		if (!OpenClipboard(win_handle)) {
778			Thread_Sleep(100);
779			continue;
780		}
781
782		hGlobal = GlobalAlloc(GMEM_MOVEABLE, (value->length + 1) * 2);
783		if (!hGlobal) { CloseClipboard(); return; }
784
785		text = (cc_unichar*)GlobalLock(hGlobal);
786		for (i = 0; i < value->length; i++, text++) {
787			*text = Convert_CP437ToUnicode(value->buffer[i]);
788		}
789		*text = '\0';
790
791		GlobalUnlock(hGlobal);
792		EmptyClipboard();
793		SetClipboardData(CF_UNICODETEXT, hGlobal);
794		CloseClipboard();
795		return;
796	}
797}
798
799void Window_Show(void) {
800	ShowWindow(win_handle, SW_SHOW);
801	BringWindowToTop(win_handle);
802	SetForegroundWindow(win_handle);
803}
804
805int Window_GetWindowState(void) {
806	DWORD s = GetWindowLong(win_handle, GWL_STYLE);
807
808	if ((s & WS_MINIMIZE))                   return WINDOW_STATE_MINIMISED;
809	if ((s & WS_MAXIMIZE) && (s & WS_POPUP)) return WINDOW_STATE_FULLSCREEN;
810	return WINDOW_STATE_NORMAL;
811}
812
813static void ToggleFullscreen(cc_bool fullscreen, UINT finalShow) {
814	DWORD style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
815	style |= (fullscreen ? WS_POPUP : WS_OVERLAPPEDWINDOW);
816
817	suppress_resize = true1;
818	{
819		ShowWindow(win_handle, SW_RESTORE); /* reset maximised state */
820		SetWindowLong(win_handle, GWL_STYLE, style);
821		SetWindowPos(win_handle, NULL((void*)0), 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
822		ShowWindow(win_handle, finalShow); 
823		Window_ProcessEvents();
824	}
825	suppress_resize = false0;
826
827	/* call Resized event only once */
828	RefreshWindowBounds();
829	Event_RaiseVoid(&WindowEvents.Resized);
830}
831
832static UINT win_show;
833cc_result Window_EnterFullscreen(void) {
834	WINDOWPLACEMENT w = { 0 };
835	w.length = sizeof(WINDOWPLACEMENT);
836	GetWindowPlacement(win_handle, &w);
837
838	win_show = w.showCmd;
839	ToggleFullscreen(true1, SW_MAXIMIZE);
840	return 0;
841}
842
843cc_result Window_ExitFullscreen(void) {
844	ToggleFullscreen(false0, win_show);
845	return 0;
846}
847
848
849void Window_SetSize(int width, int height) {
850	DWORD style = GetWindowLong(win_handle, GWL_STYLE);
851	RECT rect   = { 0, 0, width, height };
852	AdjustWindowRect(&rect, style, false0);
853
854	SetWindowPos(win_handle, NULL((void*)0), 0, 0, 
855				Rect_Width(rect), Rect_Height(rect), SWP_NOMOVE);
856}
857
858void Window_Close(void) {
859	PostMessage(win_handle, WM_CLOSE, 0, 0);
860}
861
862void Window_ProcessEvents(void) {
863	HWND foreground;
864	MSG msg;
865	while (PeekMessage(&msg, NULL((void*)0), 0, 0, 1)) {
866		TranslateMessage(&msg);
867		DispatchMessage(&msg);
868	}
869
870	foreground = GetForegroundWindow();
871	if (foreground) {
872		WindowInfo.Focused = foreground == win_handle;
873	}
874}
875
876static void Cursor_GetRawPos(int* x, int* y) {
877	POINT point; 
878	GetCursorPos(&point);
879	*x = point.x; *y = point.y;
880}
881
882void Cursor_SetPosition(int x, int y) { 
883	SetCursorPos(x + windowX, y + windowY);
884}
885static void Cursor_DoSetVisible(cc_bool visible) {
886	int i;
887	/* ShowCursor actually is a counter (returns > 0 if visible, <= 0 if not) */
888	/* Try multiple times in case cursor count was changed by something else */
889	if (visible) {
890		for (i = 0; i < 10 && ShowCursor(true1)  <  0; i++) { }
891	} else {
892		for (i = 0; i < 10 && ShowCursor(false0) >= 0; i++) {}
893	}
894}
895
896static void ShowDialogCore(const char* title, const char* msg) {
897	MessageBoxA(win_handle, msg, title, 0);
898}
899
900static HDC draw_DC;
901static HBITMAP draw_DIB;
902void Window_AllocFramebuffer(struct Bitmap* bmp) {
903	BITMAPINFO hdr = { 0 };
904	if (!draw_DC) draw_DC = CreateCompatibleDC(win_DC);
905	
906	hdr.bmiHeader.biSize = sizeof(BITMAPINFO);
907	hdr.bmiHeader.biWidth    =  bmp->width;
908	hdr.bmiHeader.biHeight   = -bmp->height;
909	hdr.bmiHeader.biBitCount = 32;
910	hdr.bmiHeader.biPlanes   = 1; 
911
912	draw_DIB = CreateDIBSection(draw_DC, &hdr, DIB_RGB_COLORS, (void**)&bmp->scan0, NULL((void*)0), 0);
913}
914
915void Window_DrawFramebuffer(Rect2D r) {
916	HGDIOBJ oldSrc = SelectObject(draw_DC, draw_DIB);
917	BitBlt(win_DC, r.X, r.Y, r.Width, r.Height, draw_DC, r.X, r.Y, SRCCOPY);
918	SelectObject(draw_DC, oldSrc);
919}
920
921void Window_FreeFramebuffer(struct Bitmap* bmp) {
922	DeleteObject(draw_DIB);
923}
924
925static cc_bool rawMouseInited, rawMouseSupported;
926static void InitRawMouse(void) {
927	static const cc_string user32 = String_FromConst("USER32.DLL"){ "USER32.DLL", (sizeof("USER32.DLL") - 1), (sizeof("USER32.DLL"
) - 1)};
928	void* lib;
929	RAWINPUTDEVICE rid;
930
931	if ((lib = DynamicLib_Load2(&user32))) {
932		_registerRawInput = (FUNC_RegisterRawInput)DynamicLib_Get2(lib, "RegisterRawInputDevices");
933		_getRawInputData  = (FUNC_GetRawInputData) DynamicLib_Get2(lib, "GetRawInputData");
934		rawMouseSupported = _registerRawInput && _getRawInputData;
935	}
936	if (!rawMouseSupported) { Platform_LogConst("Raw input unsupported!"); return; }
937
938	rid.usUsagePage = 1; /* HID_USAGE_PAGE_GENERIC; */
939	rid.usUsage     = 2; /* HID_USAGE_GENERIC_MOUSE; */
940	rid.dwFlags     = RIDEV_INPUTSINK;
941	rid.hwndTarget  = win_handle;
942
943	if (_registerRawInput(&rid, 1, sizeof(rid))) return;
944	Logger_SysWarn(GetLastError(), "initing raw mouse");
945	rawMouseSupported = false0;
946}
947
948void Window_OpenKeyboard(const cc_string* text, int type) { }
949void Window_SetKeyboardText(const cc_string* text) { }
950void Window_CloseKeyboard(void) { }
951
952void Window_EnableRawMouse(void) {
953	DefaultEnableRawMouse();
954	if (!rawMouseInited) InitRawMouse();
955	rawMouseInited = true1;
956}
957
958void Window_UpdateRawMouse(void) {
959	if (rawMouseSupported) {
960		/* handled in WM_INPUT messages */
961		CentreMousePosition();
962	} else {
963		DefaultUpdateRawMouse();
964	}
965}
966
967void Window_DisableRawMouse(void) { DefaultDisableRawMouse(); }
968
969
970/*########################################################################################################################*
971*-------------------------------------------------------X11 window--------------------------------------------------------*
972*#########################################################################################################################*/
973#elif defined CC_BUILD_X11
974#include <X11/Xlib.h>
975#include <X11/Xutil.h>
976#include <X11/XKBlib.h>
977#include <X11/extensions/XInput2.h>
978
979#ifdef X_HAVE_UTF8_STRING1
980#define CC_BUILD_XIM
981/* XIM support based off details described in */
982/* https://tedyin.com/posts/a-brief-intro-to-linux-input-method-framework/ */
983#endif
984
985#define _NET_WM_STATE_REMOVE0 0
986#define _NET_WM_STATE_ADD1    1
987#define _NET_WM_STATE_TOGGLE2 2
988
989static Display* win_display;
990static int win_screen;
991static Window win_rootWin, win_handle;
992static XVisualInfo win_visual;
993#ifdef CC_BUILD_XIM
994static XIM win_xim;
995static XIC win_xic;
996#endif
997 
998static Atom wm_destroy, net_wm_state, net_wm_ping;
999static Atom net_wm_state_minimized;
1000static Atom net_wm_state_fullscreen;
1001
1002static Atom xa_clipboard, xa_targets, xa_utf8_string, xa_data_sel;
1003static Atom xa_atom = 4;
1004static long win_eventMask;
1005static cc_bool grabCursor;
1006
1007static int MapNativeKey(KeySym key, unsigned int state) {
1008	if (key >= XK_00x0030 && key <= XK_90x0039) { return '0' + (key - XK_00x0030); }
1009	if (key >= XK_A0x0041 && key <= XK_Z0x005a) { return 'A' + (key - XK_A0x0041); }
1010	if (key >= XK_a0x0061 && key <= XK_z0x007a) { return 'A' + (key - XK_a0x0061); }
1011
1012	if (key >= XK_F10xffbe && key <= XK_F240xffd5)    { return KEY_F1  + (key - XK_F10xffbe); }
1013	if (key >= XK_KP_00xffb0 && key <= XK_KP_90xffb9) { return KEY_KP0 + (key - XK_KP_00xffb0); }
1014
1015	/* Same Num Lock behaviour as Windows and text editors */
1016	if (key >= XK_KP_Home0xff95 && key <= XK_KP_Delete0xff9f && !(state & Mod2Mask(1<<4))) {
1017		if (key == XK_KP_Home0xff95) return KEY_HOME;
1018		if (key == XK_KP_Up0xff97)   return KEY_UP;
1019		if (key == XK_KP_Page_Up0xff9a) return KEY_PAGEUP;
1020
1021		if (key == XK_KP_Left0xff96)   return KEY_LEFT;
1022		if (key == XK_KP_Insert0xff9e) return KEY_INSERT;
1023		if (key == XK_KP_Right0xff98)  return KEY_RIGHT;
1024
1025		if (key == XK_KP_End0xff9c)  return KEY_END;
1026		if (key == XK_KP_Down0xff99) return KEY_DOWN;
1027		if (key == XK_KP_Page_Down0xff9b) return KEY_PAGEDOWN;
1028	}
1029
1030	/* A chromebook user reported issues with pressing some keys: */
1031	/*  tilde - "Unknown key press: (8000060, 800007E) */
1032	/*  quote - "Unknown key press: (8000027, 8000022) */
1033	/* Note if 8000 is stripped, you get '0060' (XK_grave) and 0027 (XK_apostrophe) */
1034	/*   ChromeOS seems to also mask to 0xFFFF, so I also do so here */
1035	/* https://chromium.googlesource.com/chromium/src/+/lkgr/ui/events/keycodes/keyboard_code_conversion_x.cc */
1036	key &= 0xFFFF;
1037
1038	switch (key) {
1039		case XK_Escape0xff1b: return KEY_ESCAPE;
1040		case XK_Return0xff0d: return KEY_ENTER;
1041		case XK_space0x0020: return KEY_SPACE;
1042		case XK_BackSpace0xff08: return KEY_BACKSPACE;
1043
1044		case XK_Shift_L0xffe1: return KEY_LSHIFT;
1045		case XK_Shift_R0xffe2: return KEY_RSHIFT;
1046		case XK_Alt_L0xffe9: return KEY_LALT;
1047		case XK_Alt_R0xffea: return KEY_RALT;
1048		case XK_Control_L0xffe3: return KEY_LCTRL;
1049		case XK_Control_R0xffe4: return KEY_RCTRL;
1050		case XK_Super_L0xffeb: return KEY_LWIN;
1051		case XK_Super_R0xffec: return KEY_RWIN;
1052		case XK_Meta_L0xffe7: return KEY_LWIN;
1053		case XK_Meta_R0xffe8: return KEY_RWIN;
1054
1055		case XK_Menu0xff67:  return KEY_MENU;
1056		case XK_Tab0xff09:   return KEY_TAB;
1057		case XK_minus0x002d: return KEY_MINUS;
1058		case XK_plus0x002b:  return KEY_EQUALS;
1059		case XK_equal0x003d: return KEY_EQUALS;
1060
1061		case XK_Caps_Lock0xffe5: return KEY_CAPSLOCK;
1062		case XK_Num_Lock0xff7f:  return KEY_NUMLOCK;
1063
1064		case XK_Pause0xff13: return KEY_PAUSE;
1065		case XK_Break0xff6b: return KEY_PAUSE;
1066		case XK_Scroll_Lock0xff14: return KEY_SCROLLLOCK;
1067		case XK_Insert0xff63:  return KEY_INSERT;
1068		case XK_Print0xff61:   return KEY_PRINTSCREEN;
1069		case XK_Sys_Req0xff15: return KEY_PRINTSCREEN;
1070
1071		case XK_backslash0x005c: return KEY_BACKSLASH;
1072		case XK_bar0x007c:       return KEY_BACKSLASH;
1073		case XK_braceleft0x007b:    return KEY_LBRACKET;
1074		case XK_bracketleft0x005b:  return KEY_LBRACKET;
1075		case XK_braceright0x007d:   return KEY_RBRACKET;
1076		case XK_bracketright0x005d: return KEY_RBRACKET;
1077		case XK_colon0x003a:      return KEY_SEMICOLON;
1078		case XK_semicolon0x003b:  return KEY_SEMICOLON;
1079		case XK_quoteright0x0027: return KEY_QUOTE;
1080		case XK_quotedbl0x0022:   return KEY_QUOTE;
1081		case XK_quoteleft0x0060:  return KEY_TILDE;
1082		case XK_asciitilde0x007e: return KEY_TILDE;
1083
1084		case XK_comma0x002c: return KEY_COMMA;
1085		case XK_less0x003c:  return KEY_COMMA;
1086		case XK_period0x002e:  return KEY_PERIOD;
1087		case XK_greater0x003e: return KEY_PERIOD;
1088		case XK_slash0x002f:    return KEY_SLASH;
1089		case XK_question0x003f: return KEY_SLASH;
1090
1091		case XK_Left0xff51:  return KEY_LEFT;
1092		case XK_Down0xff54:  return KEY_DOWN;
1093		case XK_Right0xff53: return KEY_RIGHT;
1094		case XK_Up0xff52:    return KEY_UP;
1095
1096		case XK_Delete0xffff: return KEY_DELETE;
1097		case XK_Home0xff50:   return KEY_HOME;
1098		case XK_End0xff57:    return KEY_END;
1099		case XK_Page_Up0xff55:   return KEY_PAGEUP;
1100		case XK_Page_Down0xff56: return KEY_PAGEDOWN;
1101
1102		case XK_KP_Add0xffab: return KEY_KP_PLUS;
1103		case XK_KP_Subtract0xffad: return KEY_KP_MINUS;
1104		case XK_KP_Multiply0xffaa: return KEY_KP_MULTIPLY;
1105		case XK_KP_Divide0xffaf:  return KEY_KP_DIVIDE;
1106		case XK_KP_Decimal0xffae: return KEY_KP_DECIMAL;
1107		case XK_KP_Insert0xff9e: return KEY_KP0;
1108		case XK_KP_End0xff9c:  return KEY_KP1;
1109		case XK_KP_Down0xff99: return KEY_KP2;
1110		case XK_KP_Page_Down0xff9b: return KEY_KP3;
1111		case XK_KP_Left0xff96:  return KEY_KP4;
1112		case XK_KP_Begin0xff9d: return KEY_KP5;
1113		case XK_KP_Right0xff98: return KEY_KP6;
1114		case XK_KP_Home0xff95: return KEY_KP7;
1115		case XK_KP_Up0xff97:   return KEY_KP8;
1116		case XK_KP_Page_Up0xff9a: return KEY_KP9;
1117		case XK_KP_Delete0xff9f:  return KEY_KP_DECIMAL;
1118		case XK_KP_Enter0xff8d:   return KEY_KP_ENTER;
1119	}
1120	return KEY_NONE;
1121}
1122
1123/* NOTE: This may not be entirely accurate, because user can configure keycode mappings */
1124static const cc_uint8 keycodeMap[136] = {
1125	0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_ESCAPE, '1', '2', '3', '4', '5', '6',
1126	'7', '8', '9', '0', KEY_MINUS, KEY_EQUALS, KEY_BACKSPACE, KEY_TAB, 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I',
1127	'O',  'P', KEY_LBRACKET, KEY_RBRACKET, KEY_ENTER, KEY_LCTRL, 'A', 'S', 'D', 'F', 'G', 'H',  'J', 'K', 'L', KEY_SEMICOLON,
1128	KEY_QUOTE, KEY_TILDE, KEY_LSHIFT, KEY_BACKSLASH, 'Z', 'X', 'C', 'V', 'B', 'N', 'M', KEY_PERIOD, KEY_COMMA, KEY_SLASH, KEY_RSHIFT, KEY_KP_MULTIPLY,
1129	KEY_LALT, KEY_SPACE, KEY_CAPSLOCK, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_NUMLOCK, KEY_SCROLLLOCK, KEY_KP7,
1130	KEY_KP8, KEY_KP9, KEY_KP_MINUS, KEY_KP4, KEY_KP5, KEY_KP6, KEY_KP_PLUS, KEY_KP1, KEY_KP2, KEY_KP3, KEY_KP0, KEY_KP_DECIMAL, 0, 0, 0, KEY_F11,
1131	KEY_F12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1132	KEY_RALT, KEY_RCTRL, KEY_HOME, KEY_UP, KEY_PAGEUP, KEY_LEFT, KEY_RIGHT, KEY_END, KEY_DOWN, KEY_PAGEDOWN, KEY_INSERT, KEY_DELETE, 0, 0, 0, 0,
1133	0, 0, 0, KEY_PAUSE, 0, 0, 0, 0, 0, KEY_LWIN, 0, KEY_RWIN
1134};
1135
1136static int MapNativeKeycode(unsigned int keycode) {
1137	return keycode < Array_Elems(keycodeMap)(sizeof(keycodeMap) / sizeof(keycodeMap[0])) ? keycodeMap[keycode] : 0;
1138}
1139
1140static void RegisterAtoms(void) {
1141	Display* display = win_display;
1142	wm_destroy = XInternAtom(display, "WM_DELETE_WINDOW", true1);
1143	net_wm_state = XInternAtom(display, "_NET_WM_STATE", false0);
1144	net_wm_ping  = XInternAtom(display, "_NET_WM_PING",  false0);
1145	net_wm_state_minimized  = XInternAtom(display, "_NET_WM_STATE_MINIMIZED",  false0);
1146	net_wm_state_fullscreen = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", false0);
1147
1148	xa_clipboard   = XInternAtom(display, "CLIPBOARD",   false0);
1149	xa_targets     = XInternAtom(display, "TARGETS",     false0);
1150	xa_utf8_string = XInternAtom(display, "UTF8_STRING", false0);
1151	xa_data_sel    = XInternAtom(display, "CC_SEL_DATA", false0);
1152}
1153
1154static void RefreshWindowBounds(int width, int height) {
1155	if (width != WindowInfo.Width || height != WindowInfo.Height) {
1156		WindowInfo.Width  = width;
1157		WindowInfo.Height = height;
1158		Event_RaiseVoid(&WindowEvents.Resized);
1159	}
1160}
1161
1162
1163/*########################################################################################################################*
1164*--------------------------------------------------Public implementation--------------------------------------------------*
1165*#########################################################################################################################*/
1166static XVisualInfo GLContext_SelectVisual(struct GraphicsMode* mode);
1167void Window_Init(void) {
1168	Display* display = XOpenDisplay(NULL((void*)0));
1169	int screen;
1170	if (!display) Logger_Abort("Failed to open display");
1171	screen = DefaultScreen(display)(((_XPrivDisplay)(display))->default_screen);
1172
1173	win_display = display;
1174	win_screen  = screen;
1175	win_rootWin = RootWindow(display, screen)((&((_XPrivDisplay)(display))->screens[screen])->root
);
1176
1177	/* TODO: Use Xinerama and XRandR for querying these */
1178	DisplayInfo.Width  = DisplayWidth(display,  screen)((&((_XPrivDisplay)(display))->screens[screen])->width
);
1179	DisplayInfo.Height = DisplayHeight(display, screen)((&((_XPrivDisplay)(display))->screens[screen])->height
);
1180	DisplayInfo.Depth  = DefaultDepth(display,  screen)((&((_XPrivDisplay)(display))->screens[screen])->root_depth
);
1181	DisplayInfo.ScaleX = 1;
1182	DisplayInfo.ScaleY = 1;
1183}
1184
1185#ifdef CC_BUILD_ICON
1186extern const long CCIcon_Data[];
1187extern const int  CCIcon_Size;
1188
1189static void ApplyIcon(void) {
1190	Atom net_wm_icon = XInternAtom(win_display, "_NET_WM_ICON", false0);
1191	Atom xa_cardinal = XInternAtom(win_display, "CARDINAL", false0);
1192	XChangeProperty(win_display, win_handle, net_wm_icon, xa_cardinal, 32, PropModeReplace0, CCIcon_Data, CCIcon_Size);
1193}
1194#else
1195static void ApplyIcon(void) { }
1196#endif
1197
1198void Window_Create(int width, int height) {
1199	XSetWindowAttributes attributes = { 0 };
1200	XSizeHints hints = { 0 };
1201	Atom protocols[2];
1202	struct GraphicsMode mode;
1203	int supported, x, y;
1204
1205	x = Display_CentreX(width)(DisplayInfo.X + (DisplayInfo.Width - width) / 2);
1206	y = Display_CentreY(height)(DisplayInfo.Y + (DisplayInfo.Height - height) / 2);
1207	InitGraphicsMode(&mode);
1208	RegisterAtoms();
1209
1210	win_eventMask = StructureNotifyMask(1L<<17) /*| SubstructureNotifyMask*/ | ExposureMask(1L<<15) |
1211		KeyReleaseMask(1L<<1)  | KeyPressMask(1L<<0)    | KeymapStateMask(1L<<14)   | PointerMotionMask(1L<<6) |
1212		FocusChangeMask(1L<<21) | ButtonPressMask(1L<<2) | ButtonReleaseMask(1L<<3) | EnterWindowMask(1L<<4) |
1213		LeaveWindowMask(1L<<5) | PropertyChangeMask(1L<<22);
1214	win_visual = GLContext_SelectVisual(&mode);
1
Calling 'GLContext_SelectVisual'→
1215
1216	Platform_LogConst("Opening render window... ");
1217	attributes.colormap   = XCreateColormap(win_display, win_rootWin, win_visual.visual, AllocNone0);
1218	attributes.event_mask = win_eventMask;
1219
1220	win_handle = XCreateWindow(win_display, win_rootWin, x, y, width, height,
1221		0, win_visual.depth /* CopyFromParent*/, InputOutput1, win_visual.visual, 
1222		CWColormap(1L<<13) | CWEventMask(1L<<11) | CWBackPixel(1L<<1) | CWBorderPixel(1L<<3), &attributes);
1223	if (!win_handle) Logger_Abort("XCreateWindow failed");
1224
1225#ifdef CC_BUILD_XIM
1226	win_xim = XOpenIM(win_display, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1227	win_xic = XCreateIC(win_xim, XNInputStyle"inputStyle", XIMPreeditNothing0x0008L | XIMStatusNothing0x0400L,
1228						XNClientWindow"clientWindow", win_handle, NULL((void*)0));
1229#endif
1230
1231	/* Set hints to try to force WM to create window at requested x,y */
1232	/* Without this, some WMs will instead place the window whereever */
1233	hints.base_width  = width;
1234	hints.base_height = height;
1235	hints.flags = PSize(1L << 3) | PPosition(1L << 2);
1236	XSetWMNormalHints(win_display, win_handle, &hints);
1237
1238	/* Register for window destroy notification */
1239	protocols[0] = wm_destroy;
1240	protocols[1] = net_wm_ping;
1241	XSetWMProtocols(win_display, win_handle, protocols, 2);
1242
1243	/* Request that auto-repeat is only set on devices that support it physically.
1244	   This typically means that it's turned off for keyboards (which is what we want).
1245	   We prefer this method over XAutoRepeatOff/On, because the latter needs to
1246	   be reset before the program exits. */
1247	XkbSetDetectableAutoRepeat(win_display, true1, &supported);
1248
1249	RefreshWindowBounds(width, height);
1250	WindowInfo.Exists = true1;
1251	WindowInfo.Handle = (void*)win_handle;
1252	grabCursor = Options_GetBool(OPT_GRAB_CURSOR"win-grab-cursor", false0);
1253	
1254	/* So right name appears in e.g. Ubuntu Unity launchbar */
1255	XClassHint hint = { 0 };
1256	hint.res_name   = GAME_APP_TITLE"ClassiCube 1.2.1";
1257	hint.res_class  = GAME_APP_TITLE"ClassiCube 1.2.1";
1258	XSetClassHint(win_display, win_handle, &hint);
1259	ApplyIcon();
1260}
1261
1262void Window_SetTitle(const cc_string* title) {
1263	char str[NATIVE_STR_LEN600];
1264	Platform_EncodeString(str, title);
1265	XStoreName(win_display, win_handle, str);
1266}
1267
1268static char clipboard_copy_buffer[256];
1269static char clipboard_paste_buffer[256];
1270static cc_string clipboard_copy_text  = String_FromArray(clipboard_copy_buffer){ clipboard_copy_buffer, 0, sizeof(clipboard_copy_buffer)};
1271static cc_string clipboard_paste_text = String_FromArray(clipboard_paste_buffer){ clipboard_paste_buffer, 0, sizeof(clipboard_paste_buffer)};
1272
1273void Clipboard_GetText(cc_string* value) {
1274	Window owner = XGetSelectionOwner(win_display, xa_clipboard);
1275	int i;
1276	if (!owner) return; /* no window owner */
1277
1278	XConvertSelection(win_display, xa_clipboard, xa_utf8_string, xa_data_sel, win_handle, 0);
1279	clipboard_paste_text.length = 0;
1280
1281	/* wait up to 1 second for SelectionNotify event to arrive */
1282	for (i = 0; i < 100; i++) {
1283		Window_ProcessEvents();
1284		if (clipboard_paste_text.length) {
1285			String_AppendString(value, &clipboard_paste_text);
1286			return;
1287		} else {
1288			Thread_Sleep(10);
1289		}
1290	}
1291}
1292
1293void Clipboard_SetText(const cc_string* value) {
1294	String_Copy(&clipboard_copy_text, value);
1295	XSetSelectionOwner(win_display, xa_clipboard, win_handle, 0);
1296}
1297
1298void Window_Show(void) { XMapWindow(win_display, win_handle); }
1299
1300int Window_GetWindowState(void) {
1301	cc_bool fullscreen = false0, minimised = false0;
1302	Atom prop_type;
1303	unsigned long items, after;
1304	int i, prop_format;
1305	Atom* data = NULL((void*)0);
1306
1307	XGetWindowProperty(win_display, win_handle,
1308		net_wm_state, 0, 256, false0, xa_atom, &prop_type,
1309		&prop_format, &items, &after, &data);
1310
1311	if (data) {
1312		for (i = 0; i < items; i++) {
1313			Atom atom = data[i];
1314
1315			if (atom == net_wm_state_minimized) {
1316				minimised  = true1;
1317			} else if (atom == net_wm_state_fullscreen) {
1318				fullscreen = true1;
1319			}
1320		}
1321		XFree(data);
1322	}
1323
1324	if (fullscreen) return WINDOW_STATE_FULLSCREEN;
1325	if (minimised)  return WINDOW_STATE_MINIMISED;
1326	return WINDOW_STATE_NORMAL;
1327}
1328
1329static void ToggleFullscreen(long op) {
1330	XEvent ev = { 0 };
1331	ev.xclient.type   = ClientMessage33;
1332	ev.xclient.window = win_handle;
1333	ev.xclient.message_type = net_wm_state;
1334	ev.xclient.format = 32;
1335	ev.xclient.data.l[0] = op;
1336	ev.xclient.data.l[1] = net_wm_state_fullscreen;
1337
1338	XSendEvent(win_display, win_rootWin, false0,
1339		SubstructureRedirectMask(1L<<20) | SubstructureNotifyMask(1L<<19), &ev);
1340	XSync(win_display, false0);
1341	XRaiseWindow(win_display, win_handle);
1342	Window_ProcessEvents();
1343}
1344
1345cc_result Window_EnterFullscreen(void) {
1346	ToggleFullscreen(_NET_WM_STATE_ADD1); return 0;
1347}
1348cc_result Window_ExitFullscreen(void) {
1349	ToggleFullscreen(_NET_WM_STATE_REMOVE0); return 0;
1350}
1351
1352void Window_SetSize(int width, int height) {
1353	XResizeWindow(win_display, win_handle, width, height);
1354	Window_ProcessEvents();
1355}
1356
1357void Window_Close(void) {
1358	XEvent ev = { 0 };
1359	ev.type = ClientMessage33;
1360	ev.xclient.format  = 32;
1361	ev.xclient.display = win_display;
1362	ev.xclient.window  = win_handle;
1363	ev.xclient.data.l[0] = wm_destroy;
1364
1365	XSendEvent(win_display, win_handle, false0, 0, &ev);
1366	XFlush(win_display);
1367}
1368
1369static int MapNativeMouse(int button) {
1370	if (button == 1) return KEY_LMOUSE;
1371	if (button == 2) return KEY_MMOUSE;
1372	if (button == 3) return KEY_RMOUSE;
1373	if (button == 8) return KEY_XBUTTON1;
1374	if (button == 9) return KEY_XBUTTON2;
1375	return 0;
1376}
1377
1378static int TryGetKey(XKeyEvent* ev) {
1379	KeySym keysym1 = XLookupKeysym(ev, 0);
1380	KeySym keysym2 = XLookupKeysym(ev, 1);
1381
1382	int key = MapNativeKey(keysym1, ev->state);
1383	if (!key) key = MapNativeKey(keysym2, ev->state);
1384	if (key) return key;
1385
1386	Platform_Log3("Unknown key %i (%x, %x)", &ev->keycode, &keysym1, &keysym2);
1387	/* The user may be using a keyboard layout such as cryllic - */
1388	/*   fallback to trying to conver the raw scancodes instead */
1389	return MapNativeKeycode(ev->keycode);
1390}
1391
1392static Atom Window_GetSelectionProperty(XEvent* e) {
1393	Atom prop = e->xselectionrequest.property;
1394	if (prop) return prop;
1395
1396	/* For obsolete clients. See ICCCM spec, selections chapter for reasoning. */
1397	return e->xselectionrequest.target;
1398}
1399
1400static Boolint FilterEvent(Display* d, XEvent* e, XPointer w) { 
1401	return
1402		e->xany.window == (Window)w ||
1403		!e->xany.window || /* KeymapNotify events don't have a window */
1404		e->type == GenericEvent35; /* For XInput events */
1405}
1406
1407static void HandleWMDestroy(void) {
1408	Platform_LogConst("Exit message received.");
1409	Event_RaiseVoid(&WindowEvents.Closing);
1410
1411	/* sync and discard all events queued */
1412	XSync(win_display, true1);
1413	XDestroyWindow(win_display, win_handle);
1414	WindowInfo.Exists = false0;
1415}
1416
1417static void HandleWMPing(XEvent* e) {
1418	e->xany.window = win_rootWin;
1419	XSendEvent(win_display, win_rootWin, false0,
1420		SubstructureRedirectMask(1L<<20) | SubstructureNotifyMask(1L<<19), e);
1421}
1422static void HandleGenericEvent(XEvent* e);
1423
1424void Window_ProcessEvents(void) {
1425	XEvent e;
1426	int i, btn, key, status;
1427
1428	while (WindowInfo.Exists) {
1429		if (!XCheckIfEvent(win_display, &e, FilterEvent, (XPointer)win_handle)) break;
1430		if (XFilterEvent(&e, None0L) == True1) continue;
1431
1432		switch (e.type) {
1433		case GenericEvent35:
1434			HandleGenericEvent(&e); break;
1435		case ClientMessage33:
1436			if (e.xclient.data.l[0] == wm_destroy) {
1437				HandleWMDestroy();
1438			} else if (e.xclient.data.l[0] == net_wm_ping) {
1439				HandleWMPing(&e);
1440			}
1441			break;
1442
1443		case DestroyNotify17:
1444			Platform_LogConst("Window destroyed");
1445			WindowInfo.Exists = false0;
1446			break;
1447
1448		case ConfigureNotify22:
1449			RefreshWindowBounds(e.xconfigure.width, e.xconfigure.height);
1450			break;
1451
1452		case Expose12:
1453			if (e.xexpose.count == 0) Event_RaiseVoid(&WindowEvents.Redraw);
1454			break;
1455
1456		case KeyPress2:
1457		{
1458			char data[64], c;
1459			key = TryGetKey(&e.xkey);
1460			if (key) Input_SetPressed(key);
1461			
1462#ifdef CC_BUILD_XIM
1463			cc_codepoint cp;
1464			char* chars = data;
1465
1466			status = Xutf8LookupString(win_xic, &e.xkey, data, Array_Elems(data)(sizeof(data) / sizeof(data[0])), NULL((void*)0), NULL((void*)0));
1467			for (; status > 0; status -= i) {
1468				i = Convert_Utf8ToCodepoint(&cp, chars, status);
1469				if (!i) break;
1470
1471				if (Convert_TryCodepointToCP437(cp, &c)) Event_RaiseInt(&InputEvents.Press, c);
1472				chars += i;
1473			}
1474#else
1475			/* This only really works for latin keys (e.g. so some finnish keys still work) */
1476			status = XLookupString(&e.xkey, data, Array_Elems(data)(sizeof(data) / sizeof(data[0])), NULL((void*)0), NULL((void*)0));
1477			for (i = 0; i < status; i++) {
1478				if (!Convert_TryCodepointToCP437((cc_uint8)data[i], &c)) continue;
1479				Event_RaiseInt(&InputEvents.Press, c);
1480			}
1481#endif
1482		} break;
1483
1484		case KeyRelease3:
1485			key = TryGetKey(&e.xkey);
1486			if (key) Input_SetReleased(key);
1487			break;
1488
1489		case ButtonPress4:
1490			btn = MapNativeMouse(e.xbutton.button);
1491			if (btn) Input_SetPressed(btn);
1492			else if (e.xbutton.button == 4) Mouse_ScrollWheel(+1);
1493			else if (e.xbutton.button == 5) Mouse_ScrollWheel(-1);
1494			break;
1495
1496		case ButtonRelease5:
1497			btn = MapNativeMouse(e.xbutton.button);
1498			if (btn) Input_SetReleased(btn);
1499			break;
1500
1501		case MotionNotify6:
1502			Pointer_SetPosition(0, e.xmotion.x, e.xmotion.y);
1503			break;
1504
1505		case FocusIn9:
1506		case FocusOut10:
1507			/* Don't lose focus when another app grabs key or mouse */
1508			if (e.xfocus.mode == NotifyGrab1 || e.xfocus.mode == NotifyUngrab2) break;
1509
1510			WindowInfo.Focused = e.type == FocusIn9;
1511			Event_RaiseVoid(&WindowEvents.FocusChanged);
1512			/* TODO: Keep track of keyboard when focus is lost */
1513			if (!WindowInfo.Focused) Input_Clear();
1514			break;
1515
1516		case MappingNotify34:
1517			if (e.xmapping.request == MappingModifier0 || e.xmapping.request == MappingKeyboard1) {
1518				Platform_LogConst("keybard mapping refreshed");
1519				XRefreshKeyboardMapping(&e.xmapping);
1520			}
1521			break;
1522
1523		case PropertyNotify28:
1524			if (e.xproperty.atom == net_wm_state) {
1525				Event_RaiseVoid(&WindowEvents.StateChanged);
1526			}
1527			break;
1528
1529		case SelectionNotify31:
1530			clipboard_paste_text.length = 0;
1531
1532			if (e.xselection.selection == xa_clipboard && e.xselection.target == xa_utf8_string && e.xselection.property == xa_data_sel) {
1533				Atom prop_type;
1534				int prop_format;
1535				unsigned long items, after;
1536				cc_uint8* data = NULL((void*)0);
1537
1538				XGetWindowProperty(win_display, win_handle, xa_data_sel, 0, 1024, false0, 0,
1539					&prop_type, &prop_format, &items, &after, &data);
1540				XDeleteProperty(win_display, win_handle, xa_data_sel);
1541
1542				if (data && items && prop_type == xa_utf8_string) {
1543					clipboard_paste_text.length = 0;
1544					String_AppendUtf8(&clipboard_paste_text, data, items);
1545				}
1546				if (data) XFree(data);
1547			}
1548			break;
1549
1550		case SelectionRequest30:
1551		{
1552			XEvent reply = { 0 };
1553			reply.xselection.type = SelectionNotify31;
1554			reply.xselection.send_event = true1;
1555			reply.xselection.display = win_display;
1556			reply.xselection.requestor = e.xselectionrequest.requestor;
1557			reply.xselection.selection = e.xselectionrequest.selection;
1558			reply.xselection.target = e.xselectionrequest.target;
1559			reply.xselection.property = 0;
1560			reply.xselection.time = e.xselectionrequest.time;
1561
1562			if (e.xselectionrequest.selection == xa_clipboard && e.xselectionrequest.target == xa_utf8_string && clipboard_copy_text.length) {
1563				reply.xselection.property = Window_GetSelectionProperty(&e);
1564				char str[800];
1565				int len = Platform_EncodeString(str, &clipboard_copy_text);
1566
1567				XChangeProperty(win_display, reply.xselection.requestor, reply.xselection.property, xa_utf8_string, 8,
1568					PropModeReplace0, (unsigned char*)str, len);
1569			} else if (e.xselectionrequest.selection == xa_clipboard && e.xselectionrequest.target == xa_targets) {
1570				reply.xselection.property = Window_GetSelectionProperty(&e);
1571
1572				Atom data[2] = { xa_utf8_string, xa_targets };
1573				XChangeProperty(win_display, reply.xselection.requestor, reply.xselection.property, xa_atom, 32,
1574					PropModeReplace0, (unsigned char*)data, 2);
1575			}
1576			XSendEvent(win_display, e.xselectionrequest.requestor, true1, 0, &reply);
1577		} break;
1578		}
1579	}
1580}
1581
1582static void Cursor_GetRawPos(int* x, int* y) {
1583	Window rootW, childW;
1584	int childX, childY;
1585	unsigned int mask;
1586	XQueryPointer(win_display, win_rootWin, &rootW, &childW, x, y, &childX, &childY, &mask);
1587}
1588
1589void Cursor_SetPosition(int x, int y) {
1590	XWarpPointer(win_display, None0L, win_handle, 0, 0, 0, 0, x, y);
1591	XFlush(win_display); /* TODO: not sure if XFlush call is necessary */
1592}
1593
1594static Cursor blankCursor;
1595static void Cursor_DoSetVisible(cc_bool visible) {
1596	if (visible) {
1597		XUndefineCursor(win_display, win_handle);
1598	} else {
1599		if (!blankCursor) {
1600			char data  = 0;
1601			XColor col = { 0 };
1602			Pixmap pixmap = XCreateBitmapFromData(win_display, win_handle, &data, 1, 1);
1603			blankCursor   = XCreatePixmapCursor(win_display, pixmap, pixmap, &col, &col, 0, 0);
1604			XFreePixmap(win_display, pixmap);
1605		}
1606		XDefineCursor(win_display, win_handle, blankCursor);
1607	}
1608}
1609
1610
1611/*########################################################################################################################*
1612*-----------------------------------------------------X11 message box-----------------------------------------------------*
1613*#########################################################################################################################*/
1614struct X11MessageBox {
1615	Window win;
1616	Display* dpy;
1617	GC gc;
1618	unsigned long white, black, background;
1619	unsigned long btnBorder, highlight, shadow;
1620};
1621
1622static unsigned long X11_Col(struct X11MessageBox* m, cc_uint8 r, cc_uint8 g, cc_uint8 b) {
1623	Colormap cmap = XDefaultColormap(m->dpy, DefaultScreen(m->dpy)(((_XPrivDisplay)(m->dpy))->default_screen));
1624	XColor col = { 0 };
1625	col.red   = r << 8;
1626	col.green = g << 8;
1627	col.blue  = b << 8;
1628	col.flags = DoRed(1<<0) | DoGreen(1<<1) | DoBlue(1<<2);
1629
1630	XAllocColor(m->dpy, cmap, &col);
1631	return col.pixel;
1632}
1633
1634static void X11MessageBox_Init(struct X11MessageBox* m) {
1635	m->black = BlackPixel(m->dpy, DefaultScreen(m->dpy))((&((_XPrivDisplay)(m->dpy))->screens[(((_XPrivDisplay
)(m->dpy))->default_screen)])->black_pixel);
1636	m->white = WhitePixel(m->dpy, DefaultScreen(m->dpy))((&((_XPrivDisplay)(m->dpy))->screens[(((_XPrivDisplay
)(m->dpy))->default_screen)])->white_pixel);
1637	m->background = X11_Col(m, 206, 206, 206);
1638
1639	m->btnBorder = X11_Col(m, 60,  60,  60);
1640	m->highlight = X11_Col(m, 144, 144, 144);
1641	m->shadow    = X11_Col(m, 49,  49,  49);
1642
1643	m->win = XCreateSimpleWindow(m->dpy, DefaultRootWindow(m->dpy)((&((_XPrivDisplay)(m->dpy))->screens[(((_XPrivDisplay
)(m->dpy))->default_screen)])->root), 0, 0, 100, 100,
1644								0, m->black, m->background);
1645	XSelectInput(m->dpy, m->win, ExposureMask(1L<<15)   | StructureNotifyMask(1L<<17) |
1646							   KeyReleaseMask(1L<<1)   | PointerMotionMask(1L<<6) |
1647								ButtonPressMask(1L<<2) | ButtonReleaseMask(1L<<3) );
1648
1649	m->gc = XCreateGC(m->dpy, m->win, 0, NULL((void*)0));
1650	XSetForeground(m->dpy, m->gc, m->black);
1651	XSetBackground(m->dpy, m->gc, m->background);
1652}
1653
1654static void X11MessageBox_Free(struct X11MessageBox* m) {
1655	XFreeGC(m->dpy, m->gc);
1656	XDestroyWindow(m->dpy, m->win);
1657}
1658
1659struct X11Textbox {
1660	int x, y, width, height;
1661	int lineHeight, descent;
1662	const char* text;
1663};
1664
1665static void X11Textbox_Measure(struct X11Textbox* t, XFontStruct* font) {
1666	cc_string str = String_FromReadonly(t->text), line;
1667	XCharStruct overall;
1668	int direction, ascent, descent, lines = 0;
1669
1670	for (; str.length; lines++) {
1671		String_UNSAFE_SplitBy(&str, '\n', &line);
1672		XTextExtents(font, line.buffer, line.length, &direction, &ascent, &descent, &overall);
1673		t->width = max(overall.width, t->width)((overall.width) > (t->width) ? (overall.width) : (t->
width));
1674	}
1675
1676	t->lineHeight = ascent + descent;
1677	t->descent    = descent;
1678	t->height     = t->lineHeight * lines;
1679}
1680
1681static void X11Textbox_Draw(struct X11Textbox* t, struct X11MessageBox* m) {
1682	cc_string str = String_FromReadonly(t->text), line;
1683	int y = t->y + t->lineHeight - t->descent; /* TODO: is -descent even right? */
1684
1685	for (; str.length; y += t->lineHeight) {
1686		String_UNSAFE_SplitBy(&str, '\n', &line);
1687		XDrawString(m->dpy, m->win, m->gc, t->x, y, line.buffer, line.length);		
1688	}
1689}
1690
1691struct X11Button {
1692	int x, y, width, height;
1693	cc_bool clicked;
1694	struct X11Textbox text;
1695};
1696
1697static void X11Button_Draw(struct X11Button* b, struct X11MessageBox* m) {
1698	struct X11Textbox* t;
1699	int begX, endX, begY, endY;
1700
1701	XSetForeground(m->dpy, m->gc,  m->btnBorder);
1702	XDrawRectangle(m->dpy, m->win, m->gc, b->x, b->y,
1703					b->width, b->height);
1704
1705	t = &b->text;
1706	begX = b->x + 1; endX = b->x + b->width  - 1;
1707	begY = b->y + 1; endY = b->y + b->height - 1;
1708
1709	if (b->clicked) {
1710		XSetForeground(m->dpy, m->gc,  m->highlight);
1711		XDrawRectangle(m->dpy, m->win, m->gc, begX, begY,
1712						endX - begX, endY - begY);
1713	} else {
1714		XSetForeground(m->dpy, m->gc, m->white);
1715		XDrawLine(m->dpy, m->win, m->gc, begX, begY,
1716					endX - 1, begY);
1717		XDrawLine(m->dpy, m->win, m->gc, begX, begY,
1718					begX, endY - 1);
1719
1720		XSetForeground(m->dpy, m->gc, m->highlight);
1721		XDrawLine(m->dpy, m->win, m->gc, begX + 1, endY - 1,
1722					endX - 1, endY - 1);
1723		XDrawLine(m->dpy, m->win, m->gc, endX - 1, begY + 1,
1724					endX - 1, endY - 1);
1725
1726		XSetForeground(m->dpy, m->gc, m->shadow);
1727		XDrawLine(m->dpy, m->win, m->gc, begX, endY, endX, endY);
1728		XDrawLine(m->dpy, m->win, m->gc, endX, begY, endX, endY);
1729	}
1730
1731	XSetForeground(m->dpy, m->gc, m->black);
1732	t->x = b->x + b->clicked + (b->width  - t->width)  / 2;
1733	t->y = b->y + b->clicked + (b->height - t->height) / 2;
1734	X11Textbox_Draw(t, m);
1735}
1736
1737static int X11Button_Contains(struct X11Button* b, int x, int y) {
1738	return x >= b->x && x < (b->x + b->width) &&
1739		   y >= b->y && y < (b->y + b->height);
1740}
1741
1742static Boolint X11_FilterEvent(Display* d, XEvent* e, XPointer w) { return e->xany.window == (Window)w; }
1743static void X11_MessageBox(const char* title, const char* text, struct X11MessageBox* m) {
1744	struct X11Button ok    = { 0 };
1745	struct X11Textbox body = { 0 };
1746
1747	Atom protocols[2];
1748	XFontStruct* font;
1749	int x, y, width, height;
1750	XSizeHints hints = { 0 };
1751	int mouseX = -1, mouseY = -1, over;
1752	XEvent e;
1753
1754	X11MessageBox_Init(m);
1755	XMapWindow(m->dpy, m->win);
1756	XStoreName(m->dpy, m->win, title);
1757
1758	protocols[0] = XInternAtom(m->dpy, "WM_DELETE_WINDOW", false0);
1759	protocols[1] = XInternAtom(m->dpy, "_NET_WM_PING",     false0);
1760	XSetWMProtocols(m->dpy, m->win, protocols, 2);
1761
1762	font = XQueryFont(m->dpy, XGContextFromGC(m->gc));
1763	if (!font) return;
1764
1765	/* Compute size of widgets */
1766	body.text = text;
1767	X11Textbox_Measure(&body, font);
1768	ok.text.text = "OK";
1769	X11Textbox_Measure(&ok.text, font);
1770	ok.width  = ok.text.width  + 70;
1771	ok.height = ok.text.height + 10;
1772
1773	/* Compute size and position of window */
1774	width  = body.width                   + 20;
1775	height = body.height + 20 + ok.height + 20;
1776	x = DisplayWidth (m->dpy, DefaultScreen(m->dpy))((&((_XPrivDisplay)(m->dpy))->screens[(((_XPrivDisplay
)(m->dpy))->default_screen)])->width)/2 -  width/2;
1777	y = DisplayHeight(m->dpy, DefaultScreen(m->dpy))((&((_XPrivDisplay)(m->dpy))->screens[(((_XPrivDisplay
)(m->dpy))->default_screen)])->height)/2 - height/2;
1778	XMoveResizeWindow(m->dpy, m->win, x, y, width, height);
1779
1780	/* Adjust bounds of widgets */
1781	body.x = 10; body.y = 10;
1782	ok.x = width/2 - ok.width/2;
1783	ok.y = height  - ok.height - 10;
1784
1785	/* This marks the window as popup window of the main window */
1786	/* http://tronche.com/gui/x/icccm/sec-4.html#WM_TRANSIENT_FOR */
1787	/* Depending on WM, removes minimise and doesn't show in taskbar */
1788	if (win_handle) XSetTransientForHint(m->dpy, m->win, win_handle);
1789
1790	XFreeFontInfo(NULL((void*)0), font, 1);
1791	XUnmapWindow(m->dpy, m->win); /* Make window non resizeable */
1792
1793	hints.flags      = PSize(1L << 3) | PMinSize(1L << 4) | PMaxSize(1L << 5);
1794	hints.min_width  = hints.max_width  = hints.base_width  = width;
1795	hints.min_height = hints.max_height = hints.base_height = height;
1796
1797	XSetWMNormalHints(m->dpy, m->win, &hints);
1798	XMapRaised(m->dpy, m->win);
1799	XFlush(m->dpy);
1800
1801    for (;;) {
1802		/* The naive solution is to use XNextEvent(m->dpy, &e) here. */
1803		/* However this causes issues as that removes events that */
1804		/* should have been delivered to the main game window. */
1805		/* (e.g. breaks initial window resize with i3 WM) */
1806		XIfEvent(m->dpy, &e, X11_FilterEvent, (XPointer)m->win);
1807
1808		switch (e.type)
1809		{
1810		case ButtonPress4:
1811		case ButtonRelease5:
1812			if (e.xbutton.button != Button11) break;
1813			over = X11Button_Contains(&ok, mouseX, mouseY);
1814
1815			if (ok.clicked && e.type == ButtonRelease5) {
1816				if (over) return;
1817			}
1818			ok.clicked = e.type == ButtonPress4 && over;
1819			/* fallthrough to redraw window */
1820
1821		case Expose12:
1822		case MapNotify19:
1823			XClearWindow(m->dpy, m->win);
1824			X11Textbox_Draw(&body, m);
1825			X11Button_Draw(&ok, m);
1826			XFlush(m->dpy);
1827			break;
1828
1829		case KeyRelease3:
1830			if (XLookupKeysym(&e.xkey, 0) == XK_Escape0xff1b) return;
1831			break;
1832
1833		case ClientMessage33:
1834			/* { WM_DELETE_WINDOW, _NET_WM_PING } */
1835			if (e.xclient.data.l[0] == protocols[0]) return;
1836			if (e.xclient.data.l[0] == protocols[1]) HandleWMPing(&e);
1837			break;
1838
1839		case MotionNotify6:
1840			mouseX = e.xmotion.x; mouseY = e.xmotion.y;
1841			break;
1842		}
1843	}
1844}
1845
1846static void ShowDialogCore(const char* title, const char* msg) {
1847	struct X11MessageBox m = { 0 };
1848	m.dpy = win_display;
1849	
1850	/* Failing to create a display means can't display a message box. */
1851	/* However the user might have launched the game through terminal, */
1852	/* so fallback to console instead of just dying from a segfault */
1853	if (!m.dpy) {
1854		Platform_LogConst("### MESSAGE ###");
1855		Platform_LogConst(title);
1856		Platform_LogConst(msg);
1857		return;
1858	}
1859	
1860	X11_MessageBox(title, msg, &m);
1861	X11MessageBox_Free(&m);
1862	XFlush(m.dpy); /* flush so window disappears immediately */
1863}
1864
1865static GC fb_gc;
1866static XImage* fb_image;
1867void Window_AllocFramebuffer(struct Bitmap* bmp) {
1868	if (!fb_gc) fb_gc = XCreateGC(win_display, win_handle, 0, NULL((void*)0));
1869
1870	bmp->scan0 = (BitmapCol*)Mem_Alloc(bmp->width * bmp->height, 4, "window pixels");
1871	fb_image   = XCreateImage(win_display, win_visual.visual,
1872		win_visual.depth, ZPixmap2, 0, (char*)bmp->scan0,
1873		bmp->width, bmp->height, 32, 0);
1874}
1875
1876void Window_DrawFramebuffer(Rect2D r) {
1877	XPutImage(win_display, win_handle, fb_gc, fb_image,
1878		r.X, r.Y, r.X, r.Y, r.Width, r.Height);
1879}
1880
1881void Window_FreeFramebuffer(struct Bitmap* bmp) {
1882	XFree(fb_image);
1883	Mem_Free(bmp->scan0);
1884}
1885
1886void Window_OpenKeyboard(const cc_string* text, int type) { }
1887void Window_SetKeyboardText(const cc_string* text) { }
1888void Window_CloseKeyboard(void) { }
1889
1890static cc_bool rawMouseInited, rawMouseSupported;
1891static int xiOpcode;
1892
1893static void HandleGenericEvent(XEvent* e) {
1894	const double* values;
1895	XIRawEvent* ev;
1896	double dx, dy;
1897
1898	if (!rawMouseSupported || e->xcookie.extension != xiOpcode) return;
1899	if (!XGetEventData(win_display, &e->xcookie)) return;
1900
1901	if (e->xcookie.evtype == XI_RawMotion17 && Input_RawMode) {
1902		ev     = (XIRawEvent*)e->xcookie.data;
1903		values = ev->raw_values;
1904
1905		/* Raw motion events may not always have values for both axes */
1906		dx = XIMaskIsSet(ev->valuators.mask, 0)(((unsigned char*)(ev->valuators.mask))[(0)>>3] &
 (1 << ((0) & 7))) ? *values++ : 0;
1907		dy = XIMaskIsSet(ev->valuators.mask, 1)(((unsigned char*)(ev->valuators.mask))[(1)>>3] &
 (1 << ((1) & 7))) ? *values++ : 0;
1908
1909		/* Using 0.5f here makes the sensitivity about same as normal cursor movement */
1910		Event_RaiseRawMove(&PointerEvents.RawMoved, dx * 0.5f, dy * 0.5f);
1911	}
1912	XFreeEventData(win_display, &e->xcookie);
1913}
1914
1915static void InitRawMouse(void) {
1916	XIEventMask evmask;
1917	unsigned char masks[XIMaskLen(XI_LASTEVENT)(((26) >> 3) + 1)] = { 0 };
1918	int ev, err, major, minor;
1919
1920	if (!XQueryExtension(win_display, "XInputExtension", &xiOpcode, &ev, &err)) {
1921		Platform_LogConst("XInput unsupported");
1922		return;
1923	}
1924
1925	/* Only XInput 2.0 is actually required. However, 2.0 has the annoying */
1926	/* behaviour where raw input is NOT delivered while pointer is grabbed. */
1927	/* (i.e. if you press mouse button, no more raw mouse movement events) */
1928	/* http://wine.1045685.n8.nabble.com/PATCH-0-9-Implement-DInput8-mouse-using-RawInput-and-XInput2-RawEvents-only-td6016923.html */
1929	/* Thankfully XInput >= 2.1 corrects this behaviour */
1930	/* http://who-t.blogspot.com/2011/09/whats-new-in-xi-21-raw-events.html */
1931	major = 2; minor = 2;
1932	if (XIQueryVersion(win_display, &major, &minor) != Success0) {
1933		Platform_Log2("Only XInput %i.%i supported", &major, &minor);
1934		return;
1935	}
1936
1937	/* Sometimes XIQueryVersion will report Success, even though the */
1938	/* supported version is only 2.0! So make sure to handle that. */
1939	if (major < 2 || minor < 2) {
1940		Platform_Log2("Only XInput %i.%i supported", &major, &minor);
1941		return;
1942	}
1943
1944	XISetMask(masks, XI_RawMotion)(((unsigned char*)(masks))[(17)>>3] |= (1 << ((17
) & 7)));
1945	evmask.deviceid = XIAllMasterDevices1;
1946	evmask.mask_len = sizeof(masks);
1947	evmask.mask     = masks;
1948
1949	XISelectEvents(win_display, win_rootWin, &evmask, 1);
1950	rawMouseSupported = true1;
1951}
1952
1953void Window_EnableRawMouse(void) {
1954	DefaultEnableRawMouse();
1955	if (!rawMouseInited) InitRawMouse();
1956	rawMouseInited = true1;
1957
1958	if (!grabCursor) return;
1959	XGrabPointer(win_display, win_handle, True1, ButtonPressMask(1L<<2) | ButtonReleaseMask(1L<<3) | PointerMotionMask(1L<<6),
1960		GrabModeAsync1, GrabModeAsync1, win_handle, blankCursor, CurrentTime0L);
1961}
1962
1963void Window_UpdateRawMouse(void) {
1964	if (rawMouseSupported) {
1965		/* Handled by XI_RawMotion generic event */
1966		CentreMousePosition();
1967	} else {
1968		DefaultUpdateRawMouse();
1969	}
1970}
1971
1972void Window_DisableRawMouse(void) {
1973	DefaultDisableRawMouse();
1974	if (!grabCursor) return;
1975	XUngrabPointer(win_display, CurrentTime0L);
1976}
1977
1978
1979/*########################################################################################################################*
1980*---------------------------------------------------Carbon/Cocoa window---------------------------------------------------*
1981*#########################################################################################################################*/
1982#elif defined CC_BUILD_CARBON || defined CC_BUILD_COCOA
1983#include <ApplicationServices/ApplicationServices.h>
1984static int windowX, windowY;
1985
1986static void Window_CommonInit(void) {
1987	CGDirectDisplayID display = CGMainDisplayID();
1988	CGRect bounds = CGDisplayBounds(display);
1989
1990	DisplayInfo.X      = (int)bounds.origin.x;
1991	DisplayInfo.Y      = (int)bounds.origin.y;
1992	DisplayInfo.Width  = (int)bounds.size.width;
1993	DisplayInfo.Height = (int)bounds.size.height;
1994	DisplayInfo.Depth  = CGDisplayBitsPerPixel(display);
1995	DisplayInfo.ScaleX = 1;
1996	DisplayInfo.ScaleY = 1;
1997}
1998
1999static pascal OSErr HandleQuitMessage(const AppleEvent* ev, AppleEvent* reply, long handlerRefcon) {
2000	Window_Close();
2001	return 0;
2002}
2003
2004static void Window_CommonCreate(void) {
2005	WindowInfo.Exists = true1;
2006	/* for quit buttons in dock and menubar */
2007	AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
2008		NewAEEventHandlerUPP(HandleQuitMessage), 0, false0);
2009}
2010
2011/* Sourced from https://www.meandmark.com/keycodes.html */
2012static const cc_uint8 key_map[8 * 16] = {
2013	'A', 'S', 'D', 'F', 'H', 'G', 'Z', 'X', 'C', 'V', 0, 'B', 'Q', 'W', 'E', 'R',
2014	'Y', 'T', '1', '2', '3', '4', '6', '5', KEY_EQUALS, '9', '7', KEY_MINUS, '8', '0', KEY_RBRACKET, 'O',
2015	'U', KEY_LBRACKET, 'I', 'P', KEY_ENTER, 'L', 'J', KEY_QUOTE, 'K', KEY_SEMICOLON, KEY_BACKSLASH, KEY_COMMA, KEY_SLASH, 'N', 'M', KEY_PERIOD,
2016	KEY_TAB, KEY_SPACE, KEY_TILDE, KEY_BACKSPACE, 0, KEY_ESCAPE, 0, 0, 0, KEY_CAPSLOCK, 0, 0, 0, 0, 0, 0,
2017	0, KEY_KP_DECIMAL, 0, KEY_KP_MULTIPLY, 0, KEY_KP_PLUS, 0, KEY_NUMLOCK, 0, 0, 0, KEY_KP_DIVIDE, KEY_KP_ENTER, 0, KEY_KP_MINUS, 0,
2018	0, KEY_KP_ENTER, KEY_KP0, KEY_KP1, KEY_KP2, KEY_KP3, KEY_KP4, KEY_KP5, KEY_KP6, KEY_KP7, 0, KEY_KP8, KEY_KP9, 'N', 'M', KEY_PERIOD,
2019	KEY_F5, KEY_F6, KEY_F7, KEY_F3, KEY_F8, KEY_F9, 0, KEY_F11, 0, KEY_F13, 0, KEY_F14, 0, KEY_F10, 0, KEY_F12,
2020	'U', KEY_F15, KEY_INSERT, KEY_HOME, KEY_PAGEUP, KEY_DELETE, KEY_F4, KEY_END, KEY_F2, KEY_PAGEDOWN, KEY_F1, KEY_LEFT, KEY_RIGHT, KEY_DOWN, KEY_UP, 0,
2021};
2022static int MapNativeKey(UInt32 key) { return key < Array_Elems(key_map)(sizeof(key_map) / sizeof(key_map[0])) ? key_map[key] : 0; }
2023/* TODO: Check these.. */
2024/*   case 0x37: return KEY_LWIN; */
2025/*   case 0x38: return KEY_LSHIFT; */
2026/*   case 0x3A: return KEY_LALT; */
2027/*   case 0x3B: return Key_ControlLeft; */
2028
2029/* TODO: Verify these differences from OpenTK */
2030/*Backspace = 51,  (0x33, KEY_DELETE according to that link)*/
2031/*Return = 52,     (0x34, ??? according to that link)*/
2032/*Menu = 110,      (0x6E, ??? according to that link)*/
2033
2034/* NOTE: All Pasteboard functions are OSX 10.3 or later */
2035static PasteboardRef Window_GetPasteboard(void) {
2036	PasteboardRef pbRef;
2037	OSStatus err = PasteboardCreate(kPasteboardClipboard, &pbRef);
2038
2039	if (err) Logger_Abort2(err, "Creating Pasteboard reference");
2040	PasteboardSynchronize(pbRef);
2041	return pbRef;
2042}
2043
2044#define FMT_UTF8  CFSTR("public.utf8-plain-text")
2045#define FMT_UTF16 CFSTR("public.utf16-plain-text")
2046
2047void Clipboard_GetText(cc_string* value) {
2048	PasteboardRef pbRef;
2049	ItemCount itemCount;
2050	PasteboardItemID itemID;
2051	CFDataRef outData;
2052	const UInt8* ptr;
2053	CFIndex len;
2054	OSStatus err;
2055	
2056	pbRef = Window_GetPasteboard();
2057
2058	err = PasteboardGetItemCount(pbRef, &itemCount);
2059	if (err) Logger_Abort2(err, "Getting item count from Pasteboard");
2060	if (itemCount < 1) return;
2061	
2062	err = PasteboardGetItemIdentifier(pbRef, 1, &itemID);
2063	if (err) Logger_Abort2(err, "Getting item identifier from Pasteboard");
2064	
2065	if (!(err = PasteboardCopyItemFlavorData(pbRef, itemID, FMT_UTF16, &outData))) {	
2066		ptr = CFDataGetBytePtr(outData);
2067		len = CFDataGetLength(outData);
2068		if (ptr) String_AppendUtf16(value, (cc_unichar*)ptr, len);
2069	} else if (!(err = PasteboardCopyItemFlavorData(pbRef, itemID, FMT_UTF8, &outData))) {
2070		ptr = CFDataGetBytePtr(outData);
2071		len = CFDataGetLength(outData);
2072		if (ptr) String_AppendUtf8(value, (cc_uint8*)ptr, len);
2073	}
2074}
2075
2076void Clipboard_SetText(const cc_string* value) {
2077	PasteboardRef pbRef;
2078	CFDataRef cfData;
2079	UInt8 str[800];
2080	int len;
2081	OSStatus err;
2082
2083	pbRef = Window_GetPasteboard();
2084	err   = PasteboardClear(pbRef);
2085	if (err) Logger_Abort2(err, "Clearing Pasteboard");
2086	PasteboardSynchronize(pbRef);
2087
2088	len    = Platform_EncodeString(str, value);
2089	cfData = CFDataCreate(NULL((void*)0), str, len);
2090	if (!cfData) Logger_Abort("CFDataCreate() returned null pointer");
2091
2092	PasteboardPutItemFlavor(pbRef, 1, FMT_UTF8, cfData, 0);
2093}
2094
2095void Cursor_SetPosition(int x, int y) {
2096	CGPoint point;
2097	point.x = x + windowX;
2098	point.y = y + windowY;
2099	CGDisplayMoveCursorToPoint(CGMainDisplayID(), point);
2100}
2101
2102static void Cursor_DoSetVisible(cc_bool visible) {
2103	if (visible) {
2104		CGDisplayShowCursor(CGMainDisplayID());
2105	} else {
2106		CGDisplayHideCursor(CGMainDisplayID());
2107	}
2108}
2109
2110void Window_OpenKeyboard(const cc_string* text, int type) { }
2111void Window_SetKeyboardText(const cc_string* text) { }
2112void Window_CloseKeyboard(void) { }
2113
2114void Window_EnableRawMouse(void) {
2115	DefaultEnableRawMouse();
2116	CGAssociateMouseAndMouseCursorPosition(0);
2117}
2118
2119void Window_UpdateRawMouse(void) { CentreMousePosition(); }
2120void Window_DisableRawMouse(void) {
2121	CGAssociateMouseAndMouseCursorPosition(1);
2122	DefaultDisableRawMouse();
2123}
2124
2125
2126/*########################################################################################################################*
2127*------------------------------------------------------Carbon window------------------------------------------------------*
2128*#########################################################################################################################*/
2129#if defined CC_BUILD_CARBON
2130#include <Carbon/Carbon.h>
2131
2132static WindowRef win_handle;
2133static cc_bool win_fullscreen, showingDialog;
2134
2135/* fullscreen is tied to OpenGL context unfortunately */
2136static cc_result GLContext_UnsetFullscreen(void);
2137static cc_result GLContext_SetFullscreen(void);
2138
2139static void RefreshWindowBounds(void) {
2140	Rect r;
2141	if (win_fullscreen) return;
2142	
2143	/* TODO: kWindowContentRgn ??? */
2144	GetWindowBounds(win_handle, kWindowGlobalPortRgn, &r);
2145	windowX = r.left; WindowInfo.Width  = r.right  - r.left;
2146	windowY = r.top;  WindowInfo.Height = r.bottom - r.top;
2147}
2148
2149static OSStatus Window_ProcessKeyboardEvent(EventRef inEvent) {
2150	UInt32 kind, code;
2151	int key;
2152	OSStatus res;
2153	
2154	kind = GetEventKind(inEvent);
2155	switch (kind) {
2156		case kEventRawKeyDown:
2157		case kEventRawKeyRepeat:
2158		case kEventRawKeyUp:
2159			res = GetEventParameter(inEvent, kEventParamKeyCode, typeUInt32,
2160									NULL((void*)0), sizeof(UInt32), NULL((void*)0), &code);
2161			if (res) Logger_Abort2(res, "Getting key button");
2162
2163			key = MapNativeKey(code);
2164			if (key) {
2165				Input_Set(key, kind != kEventRawKeyUp);
2166			} else {
2167				Platform_Log1("Ignoring unknown key %i", &code);
2168			}
2169			return eventNotHandledErr;
2170			
2171		case kEventRawKeyModifiersChanged:
2172			res = GetEventParameter(inEvent, kEventParamKeyModifiers, typeUInt32, 
2173									NULL((void*)0), sizeof(UInt32), NULL((void*)0), &code);
2174			if (res) Logger_Abort2(res, "Getting key modifiers");
2175			
2176			Input_Set(KEY_LCTRL,    code & 0x1000);
2177			Input_Set(KEY_LALT,     code & 0x0800);
2178			Input_Set(KEY_LSHIFT,   code & 0x0200);
2179			Input_Set(KEY_LWIN,     code & 0x0100);			
2180			Input_Set(KEY_CAPSLOCK, code & 0x0400);
2181			return eventNotHandledErr;
2182	}
2183	return eventNotHandledErr;
2184}
2185
2186static OSStatus Window_ProcessWindowEvent(EventRef inEvent) {
2187	int oldWidth, oldHeight;
2188	
2189	switch (GetEventKind(inEvent)) {
2190		case kEventWindowClose:
2191			WindowInfo.Exists = false0;
2192			Event_RaiseVoid(&WindowEvents.Closing);
2193			return eventNotHandledErr;
2194			
2195		case kEventWindowClosed:
2196			WindowInfo.Exists = false0;
2197			return 0;
2198			
2199		case kEventWindowBoundsChanged:
2200			oldWidth = WindowInfo.Width; oldHeight = WindowInfo.Height;
2201			RefreshWindowBounds();
2202			
2203			if (oldWidth != WindowInfo.Width || oldHeight != WindowInfo.Height) {
2204				Event_RaiseVoid(&WindowEvents.Resized);
2205			}
2206			return eventNotHandledErr;
2207			
2208		case kEventWindowActivated:
2209			WindowInfo.Focused = true1;
2210			Event_RaiseVoid(&WindowEvents.FocusChanged);
2211			return eventNotHandledErr;
2212			
2213		case kEventWindowDeactivated:
2214			WindowInfo.Focused = false0;
2215			Event_RaiseVoid(&WindowEvents.FocusChanged);
2216			return eventNotHandledErr;
2217			
2218		case kEventWindowDrawContent:
2219			Event_RaiseVoid(&WindowEvents.Redraw);
2220			return eventNotHandledErr;
2221	}
2222	return eventNotHandledErr;
2223}
2224
2225static OSStatus Window_ProcessMouseEvent(EventRef inEvent) {
2226	int mouseX, mouseY;
2227	HIPoint pt, raw;
2228	UInt32 kind;
2229	cc_bool down;
2230	EventMouseButton button;
2231	SInt32 delta;
2232	OSStatus res;	
2233	
2234	res = GetEventParameter(inEvent, kEventParamMouseLocation, typeHIPoint,
2235							NULL((void*)0), sizeof(HIPoint), NULL((void*)0), &pt);
2236	/* this error comes up from the application event handler */
2237	if (res && res != eventParameterNotFoundErr) {
2238		Logger_Abort2(res, "Getting mouse position");
2239	}
2240
2241	if (Input_RawMode) {
2242		raw.x = 0; raw.y = 0;
2243		GetEventParameter(inEvent, kEventParamMouseDelta, typeHIPoint, NULL((void*)0), sizeof(HIPoint), NULL((void*)0), &raw);
2244		Event_RaiseRawMove(&PointerEvents.RawMoved, raw.x, raw.y);
2245	}
2246	
2247	if (showingDialog) return eventNotHandledErr;
2248	mouseX = (int)pt.x; mouseY = (int)pt.y;
2249
2250	/* kEventParamMouseLocation is in screen coordinates */
2251	/* So need to make sure mouse click lies inside window */
2252	/* Otherwise this breaks close/minimise/maximise in titlebar and dock */
2253	if (!win_fullscreen) {
2254		mouseX -= windowX; mouseY -= windowY;
2255
2256		if (mouseX < 0 || mouseX >= WindowInfo.Width)  return eventNotHandledErr;
2257		if (mouseY < 0 || mouseY >= WindowInfo.Height) return eventNotHandledErr;
2258	}
2259	
2260	kind = GetEventKind(inEvent);
2261	switch (kind) {
2262		case kEventMouseDown:
2263		case kEventMouseUp:
2264			down = kind == kEventMouseDown;
2265			res  = GetEventParameter(inEvent, kEventParamMouseButton, typeMouseButton, 
2266									 NULL((void*)0), sizeof(EventMouseButton), NULL((void*)0), &button);
2267			if (res) Logger_Abort2(res, "Getting mouse button");
2268			
2269			switch (button) {
2270				case kEventMouseButtonPrimary:
2271					Input_Set(KEY_LMOUSE, down); break;
2272				case kEventMouseButtonSecondary:
2273					Input_Set(KEY_RMOUSE, down); break;
2274				case kEventMouseButtonTertiary:
2275					Input_Set(KEY_MMOUSE, down); break;
2276			}		
2277			return eventNotHandledErr;
2278			
2279		case kEventMouseWheelMoved:
2280			res = GetEventParameter(inEvent, kEventParamMouseWheelDelta, typeSInt32,
2281									NULL((void*)0), sizeof(SInt32), NULL((void*)0), &delta);
2282			if (res) Logger_Abort2(res, "Getting mouse wheel delta");
2283			Mouse_ScrollWheel(delta);
2284			return 0;
2285			
2286		case kEventMouseMoved:
2287		case kEventMouseDragged:
2288			Pointer_SetPosition(0, mouseX, mouseY);
2289			return eventNotHandledErr;
2290	}
2291	return eventNotHandledErr;
2292}
2293
2294static OSStatus Window_ProcessTextEvent(EventRef inEvent) {
2295	UInt32 kind;
2296	EventRef keyEvent = NULL((void*)0);
2297	UniChar chars[17] = { 0 };
2298	char keyChar;
2299	int i;
2300	OSStatus res;
2301	
2302	kind = GetEventKind(inEvent);
2303	if (kind != kEventTextInputUnicodeForKeyEvent) return eventNotHandledErr;
2304
2305	/* When command key is pressed, text input should be ignored */
2306	res = GetEventParameter(inEvent, kEventParamTextInputSendKeyboardEvent,
2307							typeEventRef, NULL((void*)0), sizeof(keyEvent), NULL((void*)0), &keyEvent);
2308	if (!res && keyEvent) {
2309		UInt32 modifiers = 0;
2310		GetEventParameter(keyEvent, kEventParamKeyModifiers,
2311							typeUInt32, NULL((void*)0), sizeof(modifiers), NULL((void*)0), &modifiers);
2312		if (modifiers & 0x0100) return eventNotHandledErr;
2313	}
2314	
2315	/* TODO: is the assumption we only get 1-4 characters always valid */
2316	res = GetEventParameter(inEvent, kEventParamTextInputSendText,
2317							typeUnicodeText, NULL((void*)0), 16 * sizeof(UniChar), NULL((void*)0), chars);
2318	if (res) Logger_Abort2(res, "Getting text chars");
2319
2320	for (i = 0; i < 16 && chars[i]; i++) {
2321		/* TODO: UTF16 to codepoint conversion */
2322		if (Convert_TryCodepointToCP437(chars[i], &keyChar)) {
2323			Event_RaiseInt(&InputEvents.Press, keyChar);
2324		}
2325	}
2326	return eventNotHandledErr;
2327}
2328
2329static OSStatus Window_EventHandler(EventHandlerCallRef inCaller, EventRef inEvent, void* userData) {
2330	EventRecord record;
2331	
2332	switch (GetEventClass(inEvent)) {
2333		case kEventClassAppleEvent:
2334			/* Only event here is the apple event. */
2335			Platform_LogConst("Processing apple event.");
2336			ConvertEventRefToEventRecord(inEvent, &record);
2337			AEProcessAppleEvent(&record);
2338			break;
2339			
2340		case kEventClassKeyboard:
2341			return Window_ProcessKeyboardEvent(inEvent);
2342		case kEventClassMouse:
2343			return Window_ProcessMouseEvent(inEvent);
2344		case kEventClassWindow:
2345			return Window_ProcessWindowEvent(inEvent);
2346		case kEventClassTextInput:
2347			return Window_ProcessTextEvent(inEvent);
2348	}
2349	return eventNotHandledErr;
2350}
2351
2352typedef EventTargetRef (*GetMenuBarEventTarget_Func)(void);
2353
2354static void HookEvents(void) {
2355	static const EventTypeSpec winEventTypes[] = {
2356		{ kEventClassKeyboard, kEventRawKeyDown },
2357		{ kEventClassKeyboard, kEventRawKeyRepeat },
2358		{ kEventClassKeyboard, kEventRawKeyUp },
2359		{ kEventClassKeyboard, kEventRawKeyModifiersChanged },
2360		
2361		{ kEventClassWindow, kEventWindowClose },
2362		{ kEventClassWindow, kEventWindowClosed },
2363		{ kEventClassWindow, kEventWindowBoundsChanged },
2364		{ kEventClassWindow, kEventWindowActivated },
2365		{ kEventClassWindow, kEventWindowDeactivated },
2366		{ kEventClassWindow, kEventWindowDrawContent },
2367
2368		{ kEventClassTextInput,  kEventTextInputUnicodeForKeyEvent },
2369		{ kEventClassAppleEvent, kEventAppleEvent }
2370	};
2371	static const EventTypeSpec appEventTypes[] = {
2372		{ kEventClassMouse, kEventMouseDown },
2373		{ kEventClassMouse, kEventMouseUp },
2374		{ kEventClassMouse, kEventMouseMoved },
2375		{ kEventClassMouse, kEventMouseDragged },
2376		{ kEventClassMouse, kEventMouseWheelMoved }
2377	};
2378	GetMenuBarEventTarget_Func getMenuBarEventTarget;
2379	EventTargetRef target;
2380	
2381	target = GetWindowEventTarget(win_handle);
2382	InstallEventHandler(target, NewEventHandlerUPP(Window_EventHandler),
2383						Array_Elems(winEventTypes)(sizeof(winEventTypes) / sizeof(winEventTypes[0])), winEventTypes, NULL((void*)0), NULL((void*)0));
2384
2385	target = GetApplicationEventTarget();
2386	InstallEventHandler(target, NewEventHandlerUPP(Window_EventHandler),
2387						Array_Elems(appEventTypes)(sizeof(appEventTypes) / sizeof(appEventTypes[0])), appEventTypes, NULL((void*)0), NULL((void*)0));
2388
2389	/* The code below is to get the menubar working. */
2390	/* The documentation for 'RunApplicationEventLoop' states that it installs */
2391	/* the standard application event handler which lets the menubar work. */
2392	/* However, we cannot use that since the event loop is managed by us instead. */
2393	/* Unfortunately, there is no proper API to duplicate that behaviour, so reply */
2394	/* on the undocumented GetMenuBarEventTarget to achieve similar behaviour. */
2395	/* TODO: This is wrong for PowerPC. But at least it doesn't crash or anything. */
2396#define _RTLD_DEFAULT ((void*)-2)
2397	getMenuBarEventTarget = DynamicLib_Get2(_RTLD_DEFAULT, "GetMenuBarEventTarget");
2398	InstallStandardEventHandler(GetApplicationEventTarget());
2399
2400	/* TODO: Why does this not work properly until user activates another window */
2401	/* Followup: Seems to be a bug in OSX http://www.sheepsystems.com/developers_blog/transformprocesstype--bette.html */
2402	if (getMenuBarEventTarget) {
2403		InstallStandardEventHandler(getMenuBarEventTarget());
2404	} else {
2405		Platform_LogConst("MenuBar won't work!");
2406	}
2407	/* MenuRef menu = AcquireRootMenu(); */
2408	/* InstallStandardEventHandler(GetMenuEventTarget(menu)); */
2409}
2410
2411
2412/*########################################################################################################################*
2413 *--------------------------------------------------Public implementation--------------------------------------------------*
2414 *#########################################################################################################################*/
2415void Window_Init(void) { Window_CommonInit(); }
2416
2417/* Private CGS/CGL stuff */
2418typedef int CGSConnectionID;
2419typedef int CGSWindowID;
2420extern CGSConnectionID _CGSDefaultConnection(void);
2421extern CGSWindowID GetNativeWindowFromWindowRef(WindowRef window);
2422extern CGContextRef CGWindowContextCreate(CGSConnectionID conn, CGSWindowID win, void* opts);
2423
2424static CGSConnectionID conn;
2425static CGSWindowID winId;
2426
2427#ifdef CC_BUILD_ICON
2428extern const int CCIcon_Data[];
2429extern const int CCIcon_Width, CCIcon_Height;
2430
2431static void ApplyIcon(void) {
2432	CGColorSpaceRef colSpace;
2433	CGDataProviderRef provider;
2434	CGImageRef image;
2435
2436	colSpace = CGColorSpaceCreateDeviceRGB();
2437	provider = CGDataProviderCreateWithData(NULL((void*)0), CCIcon_Data,
2438					Bitmap_DataSize(CCIcon_Width, CCIcon_Height)((cc_uint32)(CCIcon_Width) * (cc_uint32)(CCIcon_Height) * 4), NULL((void*)0));
2439	image    = CGImageCreate(CCIcon_Width, CCIcon_Height, 8, 32, CCIcon_Width * 4, colSpace,
2440					kCGBitmapByteOrder32Little | kCGImageAlphaLast, provider, NULL((void*)0), 0, 0);
2441
2442	SetApplicationDockTileImage(image);
2443	CGImageRelease(image);
2444	CGDataProviderRelease(provider);
2445	CGColorSpaceRelease(colSpace);
2446}
2447#else
2448static void ApplyIcon(void) { }
2449#endif
2450
2451void Window_Create(int width, int height) {
2452	Rect r;
2453	OSStatus res;
2454	ProcessSerialNumber psn;
2455	
2456	r.left = Display_CentreX(width)(DisplayInfo.X + (DisplayInfo.Width - width) / 2);  r.right  = r.left + width; 
2457	r.top  = Display_CentreY(height)(DisplayInfo.Y + (DisplayInfo.Height - height) / 2); r.bottom = r.top  + height;
2458	res = CreateNewWindow(kDocumentWindowClass,
2459						  kWindowStandardDocumentAttributes | kWindowStandardHandlerAttribute |
2460						  kWindowInWindowMenuAttribute | kWindowLiveResizeAttribute, &r, &win_handle);
2461
2462	if (res) Logger_Abort2(res, "Creating window failed");
2463	RefreshWindowBounds();
2464
2465	AcquireRootMenu();	
2466	GetCurrentProcess(&psn);
2467	SetFrontProcess(&psn);
2468	
2469	/* TODO: Use BringWindowToFront instead.. (look in the file which has RepositionWindow in it) !!!! */
2470	HookEvents();
2471	Window_CommonCreate();
2472	WindowInfo.Handle = win_handle;
2473
2474	conn  = _CGSDefaultConnection();
2475	winId = GetNativeWindowFromWindowRef(win_handle);
2476	ApplyIcon();
2477}
2478
2479void Window_SetTitle(const cc_string* title) {
2480	UInt8 str[NATIVE_STR_LEN600];
2481	CFStringRef titleCF;
2482	int len;
2483	
2484	/* TODO: This leaks memory, old title isn't released */
2485	len     = Platform_EncodeString(str, title);
2486	titleCF = CFStringCreateWithBytes(kCFAllocatorDefault, str, len, kCFStringEncodingUTF8, false0);
2487	SetWindowTitleWithCFString(win_handle, titleCF);
2488}
2489
2490void Window_Show(void) {
2491	ShowWindow(win_handle);
2492	/* TODO: Do we actually need to reposition */
2493	RepositionWindow(win_handle, NULL((void*)0), kWindowCenterOnMainScreen);
2494	SelectWindow(win_handle);
2495}
2496
2497int Window_GetWindowState(void) {
2498	if (win_fullscreen)                return WINDOW_STATE_FULLSCREEN;
2499	if (IsWindowCollapsed(win_handle)) return WINDOW_STATE_MINIMISED;
2500	return WINDOW_STATE_NORMAL;
2501}
2502
2503static void UpdateWindowState(void) {
2504	Event_RaiseVoid(&WindowEvents.StateChanged);
2505	RefreshWindowBounds();
2506	Event_RaiseVoid(&WindowEvents.Resized);
2507}
2508
2509cc_result Window_EnterFullscreen(void) {
2510	cc_result res = GLContext_SetFullscreen();
2511	UpdateWindowState();
2512	return res;
2513}
2514cc_result Window_ExitFullscreen(void) {
2515	cc_result res = GLContext_UnsetFullscreen();
2516	UpdateWindowState();
2517	return res;
2518}
2519
2520void Window_SetSize(int width, int height) {
2521	SizeWindow(win_handle, width, height, true1);
2522}
2523
2524void Window_Close(void) {
2525	/* DisposeWindow only sends a kEventWindowClosed */
2526	Event_RaiseVoid(&WindowEvents.Closing);
2527	if (WindowInfo.Exists) DisposeWindow(win_handle);
2528	WindowInfo.Exists = false0;
2529}
2530
2531void Window_ProcessEvents(void) {
2532	EventRef theEvent;
2533	EventTargetRef target = GetEventDispatcherTarget();
2534	OSStatus res;
2535	
2536	for (;;) {
2537		res = ReceiveNextEvent(0, NULL((void*)0), 0.0, true1, &theEvent);
2538		if (res == eventLoopTimedOutErr) break;
2539		
2540		if (res) {
2541			Platform_Log1("Message Loop status: %i", &res); break;
2542		}
2543		if (!theEvent) break;
2544		
2545		SendEventToEventTarget(theEvent, target);
2546		ReleaseEvent(theEvent);
2547	}
2548}
2549
2550static void Cursor_GetRawPos(int* x, int* y) {
2551	Point point;
2552	GetGlobalMouse(&point);
2553	*x = (int)point.h; *y = (int)point.v;
2554}
2555
2556static void ShowDialogCore(const char* title, const char* msg) {
2557	CFStringRef titleCF = CFStringCreateWithCString(NULL((void*)0), title, kCFStringEncodingASCII);
2558	CFStringRef msgCF   = CFStringCreateWithCString(NULL((void*)0), msg,   kCFStringEncodingASCII);
2559	DialogRef dialog;
2560	DialogItemIndex itemHit;
2561
2562	showingDialog = true1;
2563	CreateStandardAlert(kAlertPlainAlert, titleCF, msgCF, NULL((void*)0), &dialog);
2564	CFRelease(titleCF);
2565	CFRelease(msgCF);
2566
2567	RunStandardAlert(dialog, NULL((void*)0), &itemHit);
2568	showingDialog = false0;
2569}
2570
2571static CGrafPtr fb_port;
2572static struct Bitmap fb_bmp;
2573static CGColorSpaceRef colorSpace;
2574
2575void Window_AllocFramebuffer(struct Bitmap* bmp) {
2576	if (!fb_port) fb_port = GetWindowPort(win_handle);
2577
2578	bmp->scan0 = Mem_Alloc(bmp->width * bmp->height, 4, "window pixels");
2579	colorSpace = CGColorSpaceCreateDeviceRGB();
2580	fb_bmp     = *bmp;
2581}
2582
2583void Window_DrawFramebuffer(Rect2D r) {
2584	CGContextRef context = NULL((void*)0);
2585	CGDataProviderRef provider;
2586	CGImageRef image;
2587	CGRect rect;
2588	OSStatus err;
2589
2590	/* Unfortunately CGImageRef is immutable, so changing the */
2591	/* underlying data doesn't change what shows when drawing. */
2592	/* TODO: Use QuickDraw alternative instead */
2593
2594	/* TODO: Only update changed bit.. */
2595	rect.origin.x = 0; rect.origin.y = 0;
2596	rect.size.width  = WindowInfo.Width;
2597	rect.size.height = WindowInfo.Height;
2598
2599	err = QDBeginCGContext(fb_port, &context);
2600	if (err) Logger_Abort2(err, "Begin draw");
2601	/* TODO: REPLACE THIS AWFUL HACK */
2602
2603	provider = CGDataProviderCreateWithData(NULL((void*)0), fb_bmp.scan0,
2604		Bitmap_DataSize(fb_bmp.width, fb_bmp.height)((cc_uint32)(fb_bmp.width) * (cc_uint32)(fb_bmp.height) * 4), NULL((void*)0));
2605#ifdef CC_BIG_ENDIAN
2606	image    = CGImageCreate(fb_bmp.width, fb_bmp.height, 8, 32, fb_bmp.width * 4, colorSpace,
2607				kCGImageAlphaNoneSkipFirst, provider, NULL((void*)0), 0, 0);
2608#else
2609	image    = CGImageCreate(fb_bmp.width, fb_bmp.height, 8, 32, fb_bmp.width * 4, colorSpace,
2610				kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst, provider, NULL((void*)0), 0, 0);
2611#endif
2612
2613	CGContextDrawImage(context, rect, image);
2614	CGContextSynchronize(context);
2615	err = QDEndCGContext(fb_port, &context);
2616	if (err) Logger_Abort2(err, "End draw");
2617
2618	CGImageRelease(image);
2619	CGDataProviderRelease(provider);
2620}
2621
2622void Window_FreeFramebuffer(struct Bitmap* bmp) {
2623	Mem_Free(bmp->scan0);
2624	CGColorSpaceRelease(colorSpace);
2625}
2626
2627
2628/*########################################################################################################################*
2629*-------------------------------------------------------Cocoa window------------------------------------------------------*
2630*#########################################################################################################################*/
2631#elif defined CC_BUILD_COCOA
2632#include <objc/message.h>
2633#include <objc/runtime.h>
2634static id appHandle, winHandle, viewHandle;
2635extern void* NSDefaultRunLoopMode;
2636
2637static SEL selFrame, selDeltaX, selDeltaY;
2638static SEL selNextEvent, selType, selSendEvent;
2639static SEL selButton, selKeycode, selModifiers;
2640static SEL selCharacters, selUtf8String, selMouseLoc;
2641static SEL selCurrentContext, selGraphicsPort;
2642static SEL selSetNeedsDisplay, selDisplayIfNeeded;
2643static SEL selUpdate, selFlushBuffer;
2644
2645static void RegisterSelectors(void) {
2646	selFrame  = sel_registerName("frame");
2647	selDeltaX = sel_registerName("deltaX");
2648	selDeltaY = sel_registerName("deltaY");
2649
2650	selNextEvent = sel_registerName("nextEventMatchingMask:untilDate:inMode:dequeue:");
2651	selType      = sel_registerName("type");
2652	selSendEvent = sel_registerName("sendEvent:");
2653
2654	selButton    = sel_registerName("buttonNumber");
2655	selKeycode   = sel_registerName("keyCode");
2656	selModifiers = sel_registerName("modifierFlags");
2657
2658	selCharacters = sel_registerName("characters");
2659	selUtf8String = sel_registerName("UTF8String");
2660	selMouseLoc   = sel_registerName("mouseLocation");
2661
2662	selCurrentContext  = sel_registerName("currentContext");
2663	selGraphicsPort    = sel_registerName("graphicsPort");
2664	selSetNeedsDisplay = sel_registerName("setNeedsDisplayInRect:");
2665	selDisplayIfNeeded = sel_registerName("displayIfNeeded");
2666
2667	selUpdate      = sel_registerName("update");
2668	selFlushBuffer = sel_registerName("flushBuffer");
2669}
2670
2671static CC_INLINEinline CGFloat Send_CGFloat(id receiver, SEL sel) {
2672	/* Sometimes we have to use fpret and sometimes we don't. See this for more details: */
2673	/* http://www.sealiesoftware.com/blog/archive/2008/11/16/objc_explain_objc_msgSend_fpret.html */
2674	/* return type is void*, but we cannot cast a void* to a float or double */
2675
2676#ifdef __i386__
2677	return ((CGFloat(*)(id, SEL))(void *)objc_msgSend_fpret)(receiver, sel);
2678#else
2679	return ((CGFloat(*)(id, SEL))(void *)objc_msgSend)(receiver, sel);
2680#endif
2681}
2682
2683static CC_INLINEinline CGPoint Send_CGPoint(id receiver, SEL sel) {
2684	/* on x86 and x86_64 CGPoint fits the requirements for 'struct returned in registers' */
2685	return ((CGPoint(*)(id, SEL))(void *)objc_msgSend)(receiver, sel);
2686}
2687
2688static void RefreshWindowBounds(void) {
2689	CGRect win, view;
2690	int viewY;
2691
2692	win  = ((CGRect(*)(id, SEL))(void *)objc_msgSend_stret)(winHandle,  selFrame);
2693	view = ((CGRect(*)(id, SEL))(void *)objc_msgSend_stret)(viewHandle, selFrame);
2694
2695	/* For cocoa, the 0,0 origin is the bottom left corner of windows/views/screen. */
2696	/* To get window's real Y screen position, first need to find Y of top. (win.y + win.height) */
2697	/* Then just subtract from screen height to make relative to top instead of bottom of the screen. */
2698	/* Of course this is only half the story, since we're really after Y position of the content. */
2699	/* To work out top Y of view relative to window, it's just win.height - (view.y + view.height) */
2700	viewY   = (int)win.size.height  - ((int)view.origin.y + (int)view.size.height);
2701	windowX = (int)win.origin.x     + (int)view.origin.x;
2702	windowY = DisplayInfo.Height - ((int)win.origin.y  + (int)win.size.height) + viewY;
2703
2704	WindowInfo.Width  = (int)view.size.width;
2705	WindowInfo.Height = (int)view.size.height;
2706}
2707
2708static void OnDidResize(id self, SEL cmd, id notification) {
2709	RefreshWindowBounds();
2710	Event_RaiseVoid(&WindowEvents.Resized);
2711}
2712
2713static void OnDidMove(id self, SEL cmd, id notification) {
2714	RefreshWindowBounds();
2715	GLContext_Update();
2716}
2717
2718static void OnDidBecomeKey(id self, SEL cmd, id notification) {
2719	WindowInfo.Focused = true1;
2720	Event_RaiseVoid(&WindowEvents.FocusChanged);
2721}
2722
2723static void OnDidResignKey(id self, SEL cmd, id notification) {
2724	WindowInfo.Focused = false0;
2725	Event_RaiseVoid(&WindowEvents.FocusChanged);
2726}
2727
2728static void OnDidMiniaturize(id self, SEL cmd, id notification) {
2729	Event_RaiseVoid(&WindowEvents.StateChanged);
2730}
2731
2732static void OnDidDeminiaturize(id self, SEL cmd, id notification) {
2733	Event_RaiseVoid(&WindowEvents.StateChanged);
2734}
2735
2736static void OnWillClose(id self, SEL cmd, id notification) {
2737	WindowInfo.Exists = false0;
2738	Event_RaiseVoid(&WindowEvents.Closing);
2739}
2740
2741/* If this isn't overriden, an annoying beep sound plays anytime a key is pressed */
2742static void OnKeyDown(id self, SEL cmd, id ev) { }
2743
2744static Class Window_MakeClass(void) {
2745	Class c = objc_allocateClassPair(objc_getClass("NSWindow"), "ClassiCube_Window", 0);
2746
2747	class_addMethod(c, sel_registerName("windowDidResize:"),        OnDidResize,        "v@:@");
2748	class_addMethod(c, sel_registerName("windowDidMove:"),          OnDidMove,          "v@:@");
2749	class_addMethod(c, sel_registerName("windowDidBecomeKey:"),     OnDidBecomeKey,     "v@:@");
2750	class_addMethod(c, sel_registerName("windowDidResignKey:"),     OnDidResignKey,     "v@:@");
2751	class_addMethod(c, sel_registerName("windowDidMiniaturize:"),   OnDidMiniaturize,   "v@:@");
2752	class_addMethod(c, sel_registerName("windowDidDeminiaturize:"), OnDidDeminiaturize, "v@:@");
2753	class_addMethod(c, sel_registerName("windowWillClose:"),        OnWillClose,        "v@:@");
2754	class_addMethod(c, sel_registerName("keyDown:"),                OnKeyDown,          "v@:@");
2755
2756	objc_registerClassPair(c);
2757	return c;
2758}
2759
2760/* When the user users left mouse to drag reisze window, this enters 'live resize' mode */
2761/*   Although the game receives a left mouse down event, it does NOT receive a left mouse up */
2762/*   This causes the game to get stuck with left mouse down after user finishes resizing */
2763/* So work arond that by always releasing left mouse when a live resize is finished */
2764static void DidEndLiveResize(id self, SEL cmd) {
2765	Input_SetReleased(KEY_LMOUSE);
2766}
2767
2768static void View_DrawRect(id self, SEL cmd, CGRect r);
2769static void MakeContentView(void) {
2770	CGRect rect;
2771	id view;
2772	Class c;
2773
2774	view = objc_msgSend(winHandle, sel_registerName("contentView"));
2775	rect = ((CGRect(*)(id, SEL))(void *)objc_msgSend_stret)(view, selFrame);
2776	
2777	c = objc_allocateClassPair(objc_getClass("NSView"), "ClassiCube_View", 0);
2778	// TODO: test rect is actually correct in View_DrawRect on both 32 and 64 bit
2779#ifdef __i386__
2780	class_addMethod(c, sel_registerName("drawRect:"), View_DrawRect, "v@:{NSRect={NSPoint=ff}{NSSize=ff}}");
2781#else
2782	class_addMethod(c, sel_registerName("drawRect:"), View_DrawRect, "v@:{NSRect={NSPoint=dd}{NSSize=dd}}");
2783#endif
2784	class_addMethod(c, sel_registerName("viewDidEndLiveResize"), DidEndLiveResize, "v@:");
2785	objc_registerClassPair(c);
2786
2787	viewHandle = objc_msgSend(c, sel_registerName("alloc"));
2788	objc_msgSend(viewHandle, sel_registerName("initWithFrame:"),  rect);
2789	objc_msgSend(winHandle,  sel_registerName("setContentView:"), viewHandle);
2790}
2791
2792void Window_Init(void) {
2793	appHandle = objc_msgSend((id)objc_getClass("NSApplication"), sel_registerName("sharedApplication"));
2794	objc_msgSend(appHandle, sel_registerName("activateIgnoringOtherApps:"), true1);
2795	Window_CommonInit();
2796	RegisterSelectors();
2797}
2798
2799#ifdef CC_BUILD_ICON
2800extern const int CCIcon_Data[];
2801extern const int CCIcon_Width, CCIcon_Height;
2802
2803static void ApplyIcon(void) {
2804	CGColorSpaceRef colSpace;
2805	CGDataProviderRef provider;
2806	CGImageRef image;
2807	CGSize size;
2808	void* img;
2809
2810	colSpace = CGColorSpaceCreateDeviceRGB();
2811	provider = CGDataProviderCreateWithData(NULL((void*)0), CCIcon_Data,
2812					Bitmap_DataSize(CCIcon_Width, CCIcon_Height)((cc_uint32)(CCIcon_Width) * (cc_uint32)(CCIcon_Height) * 4), NULL((void*)0));
2813	image    = CGImageCreate(CCIcon_Width, CCIcon_Height, 8, 32, CCIcon_Width * 4, colSpace,
2814					kCGBitmapByteOrder32Little | kCGImageAlphaLast, provider, NULL((void*)0), 0, 0);
2815
2816	size.width = 0; size.height = 0;
2817	img = objc_msgSend((id)objc_getClass("NSImage"), sel_registerName("alloc"));
2818	objc_msgSend(img, sel_registerName("initWithCGImage:size:"), image, size);
2819	objc_msgSend(appHandle, sel_registerName("setApplicationIconImage:"), img);
2820
2821	/* TODO need to release NSImage here */
2822	CGImageRelease(image);
2823	CGDataProviderRelease(provider);
2824	CGColorSpaceRelease(colSpace);
2825}
2826#else
2827static void ApplyIcon(void) { }
2828#endif
2829
2830#define NSTitledWindowMask         (1 << 0)
2831#define NSClosableWindowMask       (1 << 1)
2832#define NSMiniaturizableWindowMask (1 << 2)
2833#define NSResizableWindowMask      (1 << 3)
2834#define NSFullScreenWindowMask     (1 << 14)
2835
2836void Window_Create(int width, int height) {
2837	Class winClass;
2838	CGRect rect;
2839
2840	/* Technically the coordinates for the origin are at bottom left corner */
2841	/* But since the window is in centre of the screen, don't need to care here */
2842	rect.origin.x    = Display_CentreX(width)(DisplayInfo.X + (DisplayInfo.Width - width) / 2);  
2843	rect.origin.y    = Display_CentreY(height)(DisplayInfo.Y + (DisplayInfo.Height - height) / 2);
2844	rect.size.width  = width; 
2845	rect.size.height = height;
2846
2847	winClass  = Window_MakeClass();
2848	winHandle = objc_msgSend(winClass, sel_registerName("alloc"));
2849	objc_msgSend(winHandle, sel_registerName("initWithContentRect:styleMask:backing:defer:"), rect, (NSTitledWindowMask | NSClosableWindowMask | NSResizableWindowMask | NSMiniaturizableWindowMask), 0, false0);
2850	
2851	Window_CommonCreate();
2852	objc_msgSend(winHandle, sel_registerName("setDelegate:"), winHandle);
2853	RefreshWindowBounds();
2854	MakeContentView();
2855	ApplyIcon();
2856}
2857
2858void Window_SetTitle(const cc_string* title) {
2859	UInt8 str[NATIVE_STR_LEN600];
2860	CFStringRef titleCF;
2861	int len;
2862
2863	/* TODO: This leaks memory, old title isn't released */
2864	len = Platform_EncodeString(str, title);
2865	titleCF = CFStringCreateWithBytes(kCFAllocatorDefault, str, len, kCFStringEncodingUTF8, false0);
2866	objc_msgSend(winHandle, sel_registerName("setTitle:"), titleCF);
2867}
2868
2869void Window_Show(void) { 
2870	objc_msgSend(winHandle, sel_registerName("makeKeyAndOrderFront:"), appHandle);
2871	RefreshWindowBounds(); // TODO: even necessary?
2872}
2873
2874int Window_GetWindowState(void) {
2875	int flags;
2876
2877	flags = (int)objc_msgSend(winHandle, sel_registerName("styleMask"));
2878	if (flags & NSFullScreenWindowMask) return WINDOW_STATE_FULLSCREEN;
2879	     
2880	flags = (int)objc_msgSend(winHandle, sel_registerName("isMiniaturized"));
2881	return flags ? WINDOW_STATE_MINIMISED : WINDOW_STATE_NORMAL;
2882}
2883
2884// TODO: Only works on 10.7+
2885cc_result Window_EnterFullscreen(void) {
2886	objc_msgSend(winHandle, sel_registerName("toggleFullScreen:"), appHandle);
2887	return 0;
2888}
2889cc_result Window_ExitFullscreen(void) {
2890	objc_msgSend(winHandle, sel_registerName("toggleFullScreen:"), appHandle);
2891	return 0;
2892}
2893
2894void Window_SetSize(int width, int height) {
2895	/* Can't use setContentSize:, because that resizes from the bottom left corner. */
2896	CGRect rect = ((CGRect(*)(id, SEL))(void *)objc_msgSend_stret)(winHandle, selFrame);
2897
2898	rect.origin.y    += WindowInfo.Height - height;
2899	rect.size.width  += width  - WindowInfo.Width;
2900	rect.size.height += height - WindowInfo.Height;
2901	objc_msgSend(winHandle, sel_registerName("setFrame:display:"), rect, true1);
2902}
2903
2904void Window_Close(void) { 
2905	objc_msgSend(winHandle, sel_registerName("close"));
2906}
2907
2908static int MapNativeMouse(int button) {
2909	if (button == 0) return KEY_LMOUSE;
2910	if (button == 1) return KEY_RMOUSE;
2911	if (button == 2) return KEY_MMOUSE;
2912	return 0;
2913}
2914
2915static void ProcessKeyChars(id ev) {
2916	char buffer[128];
2917	const char* src;
2918	cc_string str;
2919	id chars;
2920	int i, len, flags;
2921
2922	/* Ignore text input while cmd is held down */
2923	/* e.g. so Cmd + V to paste doesn't leave behind 'v' */
2924	flags = (int)objc_msgSend(ev, selModifiers);
2925	if (flags & 0x000008) return;
2926	if (flags & 0x000010) return;
2927
2928	chars = objc_msgSend(ev,    selCharacters);
2929	src   = objc_msgSend(chars, selUtf8String);
2930	len   = String_Length(src);
2931	String_InitArray(str, buffer)str.buffer = buffer; str.length = 0; str.capacity = sizeof(buffer
);;
2932
2933	String_AppendUtf8(&str, src, len);
2934	for (i = 0; i < str.length; i++) {
2935		Event_RaiseInt(&InputEvents.Press, str.buffer[i]);
2936	}
2937}
2938
2939static cc_bool GetMouseCoords(int* x, int* y) {
2940	CGPoint loc = Send_CGPoint((id)objc_getClass("NSEvent"), selMouseLoc);
2941	*x = (int)loc.x                        - windowX;	
2942	*y = (DisplayInfo.Height - (int)loc.y) - windowY;
2943	// TODO: this seems to be off by 1
2944	return *x >= 0 && *y >= 0 && *x < WindowInfo.Width && *y < WindowInfo.Height;
2945}
2946
2947static int TryGetKey(id ev) {
2948	int code = (int)objc_msgSend(ev, selKeycode);
2949	int key  = MapNativeKey(code);
2950	if (key) return key;
2951
2952	Platform_Log1("Unknown key %i", &code);
2953	return 0;
2954}
2955
2956void Window_ProcessEvents(void) {
2957	id ev;
2958	int key, type, steps, x, y;
2959	CGFloat dx, dy;
2960
2961	for (;;) {
2962		ev = objc_msgSend(appHandle, selNextEvent, 0xFFFFFFFFU, NULL((void*)0), NSDefaultRunLoopMode, true1);
2963		if (!ev) break;
2964		type = (int)objc_msgSend(ev, selType);
2965 
2966		switch (type) {
2967		case  1: /* NSLeftMouseDown  */
2968		case  3: /* NSRightMouseDown */
2969		case 25: /* NSOtherMouseDown */
2970			key = MapNativeMouse((int)objc_msgSend(ev, selButton));
2971			if (GetMouseCoords(&x, &y) && key) Input_SetPressed(key);
2972			break;
2973 
2974		case  2: /* NSLeftMouseUp  */
2975		case  4: /* NSRightMouseUp */
2976		case 26: /* NSOtherMouseUp */
2977			key = MapNativeMouse((int)objc_msgSend(ev, selButton));
2978			if (key) Input_SetReleased(key);
2979			break;
2980 
2981		case 10: /* NSKeyDown */
2982			key = TryGetKey(ev);
2983			if (key) Input_SetPressed(key);
2984			// TODO: Test works properly with other languages
2985			ProcessKeyChars(ev);
2986			break;
2987 
2988		case 11: /* NSKeyUp */
2989			key = TryGetKey(ev);
2990			if (key) Input_SetReleased(key);
2991			break;
2992 
2993		case 12: /* NSFlagsChanged */
2994			key = (int)objc_msgSend(ev, selModifiers);
2995			/* TODO: Figure out how to only get modifiers that changed */
2996			Input_Set(KEY_LCTRL,    key & 0x000001);
2997			Input_Set(KEY_LSHIFT,   key & 0x000002);
2998			Input_Set(KEY_RSHIFT,   key & 0x000004);
2999			Input_Set(KEY_LWIN,     key & 0x000008);
3000			Input_Set(KEY_RWIN,     key & 0x000010);
3001			Input_Set(KEY_LALT,     key & 0x000020);
3002			Input_Set(KEY_RALT,     key & 0x000040);
3003			Input_Set(KEY_RCTRL,    key & 0x002000);
3004			Input_Set(KEY_CAPSLOCK, key & 0x010000);
3005			break;
3006 
3007		case 22: /* NSScrollWheel */
3008			dy    = Send_CGFloat(ev, selDeltaY);
3009			/* https://bugs.eclipse.org/bugs/show_bug.cgi?id=220175 */
3010			/* delta is in 'line height' units, but I don't know how to map that to actual units. */
3011			/* All I know is that scrolling by '1 wheel notch' produces a delta of around 0.1, and that */
3012			/* sometimes I'll see it go all the way up to 5-6 with a larger wheel scroll. */
3013			/* So mulitplying by 10 doesn't really seem a good idea, instead I just round outwards. */
3014			/* TODO: Figure out if there's a better way than this. */
3015			steps = dy > 0.0f ? Math_Ceil(dy) : Math_Floor(dy);
3016			Mouse_ScrollWheel(steps);
3017			break;
3018 
3019		case  5: /* NSMouseMoved */
3020		case  6: /* NSLeftMouseDragged */
3021		case  7: /* NSRightMouseDragged */
3022		case 27: /* NSOtherMouseDragged */
3023			if (GetMouseCoords(&x, &y)) Pointer_SetPosition(0, x, y);
3024 
3025			if (Input_RawMode) {
3026				dx = Send_CGFloat(ev, selDeltaX);
3027				dy = Send_CGFloat(ev, selDeltaY);
3028				Event_RaiseRawMove(&PointerEvents.RawMoved, dx, dy);
3029			}
3030			break;
3031		}
3032		objc_msgSend(appHandle, selSendEvent, ev);
3033	}
3034}
3035
3036static void Cursor_GetRawPos(int* x, int* y) { *x = 0; *y = 0; }
3037static void ShowDialogCore(const char* title, const char* msg) {
3038	CFStringRef titleCF, msgCF;
3039	id alert;
3040	
3041	alert   = objc_msgSend((id)objc_getClass("NSAlert"), sel_registerName("alloc"));
3042	alert   = objc_msgSend(alert, sel_registerName("init"));
3043	titleCF = CFStringCreateWithCString(NULL((void*)0), title, kCFStringEncodingASCII);
3044	msgCF   = CFStringCreateWithCString(NULL((void*)0), msg,   kCFStringEncodingASCII);
3045	
3046	objc_msgSend(alert, sel_registerName("setMessageText:"),     titleCF);
3047	objc_msgSend(alert, sel_registerName("setInformativeText:"), msgCF);
3048	objc_msgSend(alert, sel_registerName("addButtonWithTitle:"), CFSTR("OK"));
3049	
3050	objc_msgSend(alert, sel_registerName("runModal"));
3051	CFRelease(titleCF);
3052	CFRelease(msgCF);
3053}
3054
3055static struct Bitmap fb_bmp;
3056void Window_AllocFramebuffer(struct Bitmap* bmp) {
3057	bmp->scan0 = (BitmapCol*)Mem_Alloc(bmp->width * bmp->height, 4, "window pixels");
3058	fb_bmp = *bmp;
3059}
3060
3061static void View_DrawRect(id self, SEL cmd, CGRect r_) {
3062	CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
3063	CGContextRef context = NULL((void*)0);
3064	CGDataProviderRef provider;
3065	CGImageRef image;
3066	CGRect rect;
3067	id nsContext;
3068
3069	/* Unfortunately CGImageRef is immutable, so changing the */
3070	/* underlying data doesn't change what shows when drawing. */
3071	/* TODO: Find a better way of doing this in cocoa.. */
3072	if (!fb_bmp.scan0) return;
3073	nsContext = objc_msgSend((id)objc_getClass("NSGraphicsContext"), selCurrentContext);
3074	context   = objc_msgSend(nsContext, selGraphicsPort);
3075
3076	/* TODO: Only update changed bit.. */
3077	rect.origin.x = 0; rect.origin.y = 0;
3078	rect.size.width  = WindowInfo.Width;
3079	rect.size.height = WindowInfo.Height;
3080
3081	/* TODO: REPLACE THIS AWFUL HACK */
3082	provider = CGDataProviderCreateWithData(NULL((void*)0), fb_bmp.scan0,
3083		Bitmap_DataSize(fb_bmp.width, fb_bmp.height)((cc_uint32)(fb_bmp.width) * (cc_uint32)(fb_bmp.height) * 4), NULL((void*)0));
3084	image = CGImageCreate(fb_bmp.width, fb_bmp.height, 8, 32, fb_bmp.width * 4, colorSpace,
3085		kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst, provider, NULL((void*)0), 0, 0);
3086
3087	CGContextDrawImage(context, rect, image);
3088	CGContextSynchronize(context);
3089
3090	CGImageRelease(image);
3091	CGDataProviderRelease(provider);
3092	CGColorSpaceRelease(colorSpace);
3093}
3094
3095void Window_DrawFramebuffer(Rect2D r) {
3096	CGRect rect;
3097	rect.origin.x    = r.X; 
3098	rect.origin.y    = WindowInfo.Height - r.Y - r.Height;
3099	rect.size.width  = r.Width;
3100	rect.size.height = r.Height;
3101
3102	objc_msgSend(viewHandle, selSetNeedsDisplay, rect);
3103	objc_msgSend(viewHandle, selDisplayIfNeeded);
3104}
3105
3106void Window_FreeFramebuffer(struct Bitmap* bmp) {
3107	Mem_Free(bmp->scan0);
3108}
3109#endif
3110
3111
3112/*########################################################################################################################*
3113*------------------------------------------------Emscripten canvas window-------------------------------------------------*
3114*#########################################################################################################################*/
3115#elif defined CC_BUILD_WEB
3116#include <emscripten/emscripten.h>
3117#include <emscripten/html5.h>
3118#include <emscripten/key_codes.h>
3119static cc_bool keyboardOpen, needResize;
3120
3121static int RawDpiScale(int x)    { return (int)(x * emscripten_get_device_pixel_ratio()); }
3122static int GetCanvasWidth(void)  { return EM_ASM_INT_V({ return Module['canvas'].width  }); }
3123static int GetCanvasHeight(void) { return EM_ASM_INT_V({ return Module['canvas'].height }); }
3124static int GetScreenWidth(void)  { return RawDpiScale(EM_ASM_INT_V({ return screen.width;  })); }
3125static int GetScreenHeight(void) { return RawDpiScale(EM_ASM_INT_V({ return screen.height; })); }
3126
3127static void UpdateWindowBounds(void) {
3128	int width  = GetCanvasWidth();
3129	int height = GetCanvasHeight();
3130	if (width == WindowInfo.Width && height == WindowInfo.Height) return;
3131
3132	WindowInfo.Width  = width;
3133	WindowInfo.Height = height;
3134	Event_RaiseVoid(&WindowEvents.Resized);
3135}
3136
3137static void SetFullscreenBounds(void) {
3138	int width  = GetScreenWidth();
3139	int height = GetScreenHeight();
3140	emscripten_set_canvas_element_size("#canvas", width, height);
3141}
3142
3143/* Browser only allows pointer lock requests in response to user input */
3144static void DeferredEnableRawMouse(void) {
3145	EmscriptenPointerlockChangeEvent status;
3146	if (!Input_RawMode) return;
3147
3148	status.isActive = false0;
3149	emscripten_get_pointerlock_status(&status);
3150	if (!status.isActive) emscripten_request_pointerlock("#canvas", false0);
3151}
3152
3153static EM_BOOL OnMouseWheel(int type, const EmscriptenWheelEvent* ev, void* data) {
3154	/* TODO: The scale factor isn't standardised.. is there a better way though? */
3155	Mouse_ScrollWheel(-Math_Sign(ev->deltaY));
3156	DeferredEnableRawMouse();
3157	return true1;
3158}
3159
3160static EM_BOOL OnMouseButton(int type, const EmscriptenMouseEvent* ev, void* data) {
3161	cc_bool down = type == EMSCRIPTEN_EVENT_MOUSEDOWN;
3162	switch (ev->button) {
3163		case 0: Input_Set(KEY_LMOUSE, down); break;
3164		case 1: Input_Set(KEY_MMOUSE, down); break;
3165		case 2: Input_Set(KEY_RMOUSE, down); break;
3166	}
3167
3168	DeferredEnableRawMouse();
3169	return true1;
3170}
3171
3172/* input coordinates are CSS pixels, remap to internal pixels */
3173static void RescaleXY(int srcX, int srcY, int* dstX, int* dstY) {
3174	double css_width, css_height;
3175	emscripten_get_element_css_size("#canvas", &css_width, &css_height);
3176
3177	if (css_width && css_height) {
3178		*dstX = (int)(srcX * WindowInfo.Width  / css_width );
3179		*dstY = (int)(srcY * WindowInfo.Height / css_height);
3180	} else {
3181		/* If css width or height is 0, something is bogus */
3182		/* It's still better to avoid divsision by 0 anyways */
3183		*dstX = srcX; *dstY = srcY;
3184	}
3185}
3186
3187static EM_BOOL OnMouseMove(int type, const EmscriptenMouseEvent* ev, void* data) {
3188	int x, y, buttons = ev->buttons;
3189	/* Set before position change, in case mouse buttons changed when outside window */
3190	Input_Set(KEY_LMOUSE, buttons & 0x01);
3191	Input_Set(KEY_RMOUSE, buttons & 0x02);
3192	Input_Set(KEY_MMOUSE, buttons & 0x04);
3193
3194	RescaleXY(ev->targetX, ev->targetY, &x, &y);
3195	Pointer_SetPosition(0, x, y);
3196	if (Input_RawMode) Event_RaiseRawMove(&PointerEvents.RawMoved, ev->movementX, ev->movementY);
3197	return true1;
3198}
3199
3200static EM_BOOL OnTouchStart(int type, const EmscriptenTouchEvent* ev, void* data) {
3201	const EmscriptenTouchPoint* t;
3202	int i, x, y;
3203	for (i = 0; i < ev->numTouches; ++i) {
3204		t = &ev->touches[i];
3205		if (!t->isChanged) continue;
3206		
3207		RescaleXY(t->targetX, t->targetY, &x, &y);
3208		Input_AddTouch(t->identifier, x, y);
3209	}
3210	/* Don't intercept touchstart events while keyboard is open, that way */
3211	/* user can still touch to move the caret position in input textbox. */
3212	return !keyboardOpen;
3213}
3214
3215static EM_BOOL OnTouchMove(int type, const EmscriptenTouchEvent* ev, void* data) {
3216	const EmscriptenTouchPoint* t;
3217	int i, x, y;
3218	for (i = 0; i < ev->numTouches; ++i) {
3219		t = &ev->touches[i];
3220		if (!t->isChanged) continue;
3221		
3222		RescaleXY(t->targetX, t->targetY, &x, &y);
3223		Input_UpdateTouch(t->identifier, x, y);
3224	}
3225	/* Don't intercept touchmove events while keyboard is open, that way */
3226	/* user can still touch to move the caret position in input textbox. */
3227	return !keyboardOpen;
3228}
3229
3230static EM_BOOL OnTouchEnd(int type, const EmscriptenTouchEvent* ev, void* data) {
3231	const EmscriptenTouchPoint* t;
3232	int i, x, y;
3233	for (i = 0; i < ev->numTouches; ++i) {
3234		t = &ev->touches[i];
3235		if (!t->isChanged) continue;
3236		
3237		RescaleXY(t->targetX, t->targetY, &x, &y);
3238		Input_RemoveTouch(t->identifier, x, y);
3239	}
3240	/* Don't intercept touchend events while keyboard is open, that way */
3241	/* user can still touch to move the caret position in input textbox. */
3242	return !keyboardOpen;
3243}
3244
3245static EM_BOOL OnFocus(int type, const EmscriptenFocusEvent* ev, void* data) {
3246	WindowInfo.Focused = type == EMSCRIPTEN_EVENT_FOCUS;
3247	Event_RaiseVoid(&WindowEvents.FocusChanged);
3248	return true1;
3249}
3250
3251static EM_BOOL OnResize(int type, const EmscriptenUiEvent* ev, void *data) {
3252	UpdateWindowBounds(); needResize = true1;
3253	return true1;
3254}
3255/* This is only raised when going into fullscreen */
3256static EM_BOOL OnCanvasResize(int type, const void* reserved, void *data) {
3257	UpdateWindowBounds(); needResize = true1;
3258	return false0;
3259}
3260static EM_BOOL OnFullscreenChange(int type, const EmscriptenFullscreenChangeEvent* ev, void *data) {
3261	UpdateWindowBounds(); needResize = true1;
3262	return false0;
3263}
3264
3265static const char* OnBeforeUnload(int type, const void* ev, void *data) {
3266	Window_Close();
3267	return NULL((void*)0);
3268}
3269
3270static int MapNativeKey(int k) {
3271	if (k >= '0' && k <= '9') return k;
3272	if (k >= 'A' && k <= 'Z') return k;
3273	if (k >= DOM_VK_F1      && k <= DOM_VK_F24)     { return KEY_F1  + (k - DOM_VK_F1); }
3274	if (k >= DOM_VK_NUMPAD0 && k <= DOM_VK_NUMPAD9) { return KEY_KP0 + (k - DOM_VK_NUMPAD0); }
3275
3276	switch (k) {
3277	case DOM_VK_BACK_SPACE: return KEY_BACKSPACE;
3278	case DOM_VK_TAB:        return KEY_TAB;
3279	case DOM_VK_RETURN:     return KEY_ENTER;
3280	case DOM_VK_SHIFT:      return KEY_LSHIFT;
3281	case DOM_VK_CONTROL:    return KEY_LCTRL;
3282	case DOM_VK_ALT:        return KEY_LALT;
3283	case DOM_VK_PAUSE:      return KEY_PAUSE;
3284	case DOM_VK_CAPS_LOCK:  return KEY_CAPSLOCK;
3285	case DOM_VK_ESCAPE:     return KEY_ESCAPE;
3286	case DOM_VK_SPACE:      return KEY_SPACE;
3287
3288	case DOM_VK_PAGE_UP:     return KEY_PAGEUP;
3289	case DOM_VK_PAGE_DOWN:   return KEY_PAGEDOWN;
3290	case DOM_VK_END:         return KEY_END;
3291	case DOM_VK_HOME:        return KEY_HOME;
3292	case DOM_VK_LEFT:        return KEY_LEFT;
3293	case DOM_VK_UP:          return KEY_UP;
3294	case DOM_VK_RIGHT:       return KEY_RIGHT;
3295	case DOM_VK_DOWN:        return KEY_DOWN;
3296	case DOM_VK_PRINTSCREEN: return KEY_PRINTSCREEN;
3297	case DOM_VK_INSERT:      return KEY_INSERT;
3298	case DOM_VK_DELETE:      return KEY_DELETE;
3299
3300	case DOM_VK_SEMICOLON:   return KEY_SEMICOLON;
3301	case DOM_VK_EQUALS:      return KEY_EQUALS;
3302	case DOM_VK_WIN:         return KEY_LWIN;
3303	case DOM_VK_MULTIPLY:    return KEY_KP_MULTIPLY;
3304	case DOM_VK_ADD:         return KEY_KP_PLUS;
3305	case DOM_VK_SUBTRACT:    return KEY_KP_MINUS;
3306	case DOM_VK_DECIMAL:     return KEY_KP_DECIMAL;
3307	case DOM_VK_DIVIDE:      return KEY_KP_DIVIDE;
3308	case DOM_VK_NUM_LOCK:    return KEY_NUMLOCK;
3309	case DOM_VK_SCROLL_LOCK: return KEY_SCROLLLOCK;
3310		
3311	case DOM_VK_HYPHEN_MINUS:  return KEY_MINUS;
3312	case DOM_VK_COMMA:         return KEY_COMMA;
3313	case DOM_VK_PERIOD:        return KEY_PERIOD;
3314	case DOM_VK_SLASH:         return KEY_SLASH;
3315	case DOM_VK_BACK_QUOTE:    return KEY_TILDE;
3316	case DOM_VK_OPEN_BRACKET:  return KEY_LBRACKET;
3317	case DOM_VK_BACK_SLASH:    return KEY_BACKSLASH;
3318	case DOM_VK_CLOSE_BRACKET: return KEY_RBRACKET;
3319	case DOM_VK_QUOTE:         return KEY_QUOTE;
3320
3321	/* chrome */
3322	case 186: return KEY_SEMICOLON;
3323	case 187: return KEY_EQUALS;
3324	case 189: return KEY_MINUS;
3325	}
3326	return KEY_NONE;
3327}
3328
3329static EM_BOOL OnKey(int type, const EmscriptenKeyboardEvent* ev, void* data) {
3330	int key = MapNativeKey(ev->keyCode);
3331
3332	if (ev->location == DOM_KEY_LOCATION_RIGHT) {
3333		switch (key) {
3334		case KEY_LALT:   key = KEY_RALT; break;
3335		case KEY_LCTRL:  key = KEY_RCTRL; break;
3336		case KEY_LSHIFT: key = KEY_RSHIFT; break;
3337		case KEY_LWIN:   key = KEY_RWIN; break;
3338		}
3339	}
3340	else if (ev->location == DOM_KEY_LOCATION_NUMPAD) {
3341		switch (key) {
3342		case KEY_ENTER: key = KEY_KP_ENTER; break;
3343		}
3344	}
3345
3346	if (key) Input_Set(key, type == EMSCRIPTEN_EVENT_KEYDOWN);
3347	DeferredEnableRawMouse();
3348
3349	if (!key) return false0;
3350	/* KeyUp always intercepted */
3351	if (type != EMSCRIPTEN_EVENT_KEYDOWN) return true1;
3352
3353	/* If holding down Ctrl or Alt, keys aren't going to generate a KeyPress event anyways. */
3354	/* This intercepts Ctrl+S etc. Ctrl+C and Ctrl+V are not intercepted for clipboard. */
3355	if (Key_IsAltPressed()(Input_Pressed[KEY_LALT] || Input_Pressed[KEY_RALT]) || Key_IsWinPressed()(Input_Pressed[KEY_LWIN] || Input_Pressed[KEY_RWIN])) return true1;
3356	if (Key_IsControlPressed()(Input_Pressed[KEY_LCTRL] || Input_Pressed[KEY_RCTRL]) && key != 'C' && key != 'V') return true1;
3357
3358	/* Space needs special handling, as intercepting this prevents the ' ' key press event */
3359	/* But on Safari, space scrolls the page - so need to intercept when keyboard is NOT open */
3360	if (key == KEY_SPACE) return !keyboardOpen;
3361
3362	/* Must not intercept KeyDown for regular keys, otherwise KeyPress doesn't get raised. */
3363	/* However, do want to prevent browser's behaviour on F11, F5, home etc. */
3364	/* e.g. not preventing F11 means browser makes page fullscreen instead of just canvas */
3365	return (key >= KEY_F1  && key <= KEY_F24)  || (key >= KEY_UP    && key <= KEY_RIGHT) ||
3366		(key >= KEY_INSERT && key <= KEY_MENU) || (key >= KEY_ENTER && key <= KEY_NUMLOCK);
3367}
3368
3369static EM_BOOL OnKeyPress(int type, const EmscriptenKeyboardEvent* ev, void* data) {
3370	char keyChar;
3371	DeferredEnableRawMouse();
3372	/* When on-screen keyboard is open, we don't want to intercept any key presses, */
3373	/* because they should be sent to the HTML text input instead. */
3374	/* (Chrome for android sends keypresses sometimes for '0' to '9' keys) */
3375	/* - If any keys are intercepted, this causes the HTML text input to become */
3376	/*   desynchronised from the chat/menu input widget the user sees in game. */
3377	/* - This causes problems such as attempting to backspace all text later to */
3378	/*   not actually backspace everything. (because the HTML text input does not */
3379	/*   have these intercepted key presses in its text buffer) */
3380	if (Input_TouchMode0 && keyboardOpen) return false0;
3381
3382	if (Convert_TryCodepointToCP437(ev->charCode, &keyChar)) {
3383		Event_RaiseInt(&InputEvents.Press, keyChar);
3384	}
3385	return true1;
3386}
3387
3388/* Really old emscripten versions (e.g. 1.38.21) don't have this defined */
3389/* Can't just use "#window", newer versions switched to const int instead */
3390#ifndef EMSCRIPTEN_EVENT_TARGET_WINDOW
3391#define EMSCRIPTEN_EVENT_TARGET_WINDOW "#window"
3392#endif
3393
3394static void HookEvents(void) {
3395	emscripten_set_wheel_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL((void*)0), 0, OnMouseWheel);
3396	emscripten_set_mousedown_callback("#canvas",                  NULL((void*)0), 0, OnMouseButton);
3397	emscripten_set_mouseup_callback("#canvas",                    NULL((void*)0), 0, OnMouseButton);
3398	emscripten_set_mousemove_callback("#canvas",                  NULL((void*)0), 0, OnMouseMove);
3399	emscripten_set_fullscreenchange_callback("#canvas",           NULL((void*)0), 0, OnFullscreenChange);
3400
3401	emscripten_set_focus_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,  NULL((void*)0), 0, OnFocus);
3402	emscripten_set_blur_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,   NULL((void*)0), 0, OnFocus);
3403	emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL((void*)0), 0, OnResize);
3404	emscripten_set_beforeunload_callback(                          NULL((void*)0),    OnBeforeUnload);
3405
3406	emscripten_set_keydown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,  NULL((void*)0), 0, OnKey);
3407	emscripten_set_keyup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,    NULL((void*)0), 0, OnKey);
3408	emscripten_set_keypress_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL((void*)0), 0, OnKeyPress);
3409
3410	emscripten_set_touchstart_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,  NULL((void*)0), 0, OnTouchStart);
3411	emscripten_set_touchmove_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,   NULL((void*)0), 0, OnTouchMove);
3412	emscripten_set_touchend_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,    NULL((void*)0), 0, OnTouchEnd);
3413	emscripten_set_touchcancel_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL((void*)0), 0, OnTouchEnd);
3414}
3415
3416static void UnhookEvents(void) {
3417	emscripten_set_wheel_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL((void*)0), 0, NULL((void*)0));
3418	emscripten_set_mousedown_callback("#canvas",                  NULL((void*)0), 0, NULL((void*)0));
3419	emscripten_set_mouseup_callback("#canvas",                    NULL((void*)0), 0, NULL((void*)0));
3420	emscripten_set_mousemove_callback("#canvas",                  NULL((void*)0), 0, NULL((void*)0));
3421
3422	emscripten_set_focus_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,  NULL((void*)0), 0, NULL((void*)0));
3423	emscripten_set_blur_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,   NULL((void*)0), 0, NULL((void*)0));
3424	emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL((void*)0), 0, NULL((void*)0));
3425	emscripten_set_beforeunload_callback(                          NULL((void*)0),    NULL((void*)0));
3426
3427	emscripten_set_keydown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,  NULL((void*)0), 0, NULL((void*)0));
3428	emscripten_set_keyup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,    NULL((void*)0), 0, NULL((void*)0));
3429	emscripten_set_keypress_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL((void*)0), 0, NULL((void*)0));
3430
3431	emscripten_set_touchstart_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,  NULL((void*)0), 0, NULL((void*)0));
3432	emscripten_set_touchmove_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,   NULL((void*)0), 0, NULL((void*)0));
3433	emscripten_set_touchend_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW,    NULL((void*)0), 0, NULL((void*)0));
3434	emscripten_set_touchcancel_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL((void*)0), 0, NULL((void*)0));
3435}
3436
3437void Window_Init(void) {
3438	DisplayInfo.Width  = GetScreenWidth();
3439	DisplayInfo.Height = GetScreenHeight();
3440	DisplayInfo.Depth  = 24;
3441
3442	DisplayInfo.ScaleX = emscripten_get_device_pixel_ratio();
3443	DisplayInfo.ScaleY = DisplayInfo.ScaleX;
3444
3445	/* Copy text, but only if user isn't selecting something else on the webpage */
3446	/* (don't check window.clipboardData here, that's handled in Clipboard_SetText instead) */
3447	EM_ASM(window.addEventListener('copy', 
3448		function(e) {
3449			if (window.getSelection && window.getSelection().toString()) return;
3450			if (window.cc_copyText) {
3451				if (e.clipboardData) { e.clipboardData.setData('text/plain', window.cc_copyText); }
3452				e.preventDefault();
3453				window.cc_copyText = null;
3454			}	
3455		});
3456	);
3457
3458	/* Paste text (window.clipboardData is handled in Clipboard_RequestText instead) */
3459	EM_ASM(window.addEventListener('paste',
3460		function(e) {
3461			var contents = e.clipboardData ? e.clipboardData.getData('text/plain') : "";
3462			ccall('Window_GotClipboardText', 'void', ['string'], [contents]);
3463		});
3464	);
3465
3466	Input_TouchMode0 = EM_ASM_INT_V({ return /iPhone|iPad|iPod|Android/i.test(navigator.userAgent); });
3467	Pointers_Count1  = Input_TouchMode0 ? 0 : 1;
3468
3469	/* iOS shifts the whole webpage up when opening chat, which causes problems */
3470	/*  as the chat/send butons are positioned at the top of the canvas - they */
3471	/*  get pushed offscreen and can't be used at all anymore. So handle this */
3472	/*  case specially by positioning them at the bottom instead for iOS. */
3473	WindowInfo.SoftKeyboard = EM_ASM_INT_V({ return /iPhone|iPad|iPod/i.test(navigator.userAgent); }) 
3474								? SOFT_KEYBOARD_SHIFT : SOFT_KEYBOARD_RESIZE;
3475}
3476
3477void Window_Create(int width, int height) {
3478	WindowInfo.Exists  = true1;
3479	WindowInfo.Focused = true1;
3480	HookEvents();
3481	/* Let the webpage decide on initial bounds */
3482	WindowInfo.Width  = GetCanvasWidth();
3483	WindowInfo.Height = GetCanvasHeight();
3484
3485	/* Create wrapper div if necessary */
3486	EM_ASM({
3487		var agent  = navigator.userAgent;	
3488		var canvas = Module['canvas'];
3489		window.cc_container = document.body;
3490
3491		if (/Android/i.test(agent) && /Chrome/i.test(agent)) {
3492			var wrapper = document.createElement("div");
3493			wrapper.id  = 'canvas_wrapper';
3494
3495			canvas.parentNode.insertBefore(wrapper, canvas);
3496			wrapper.appendChild(canvas);
3497			window.cc_container = wrapper;
3498		}
3499	});
3500}
3501
3502void Window_SetTitle(const cc_string* title) {
3503	char str[NATIVE_STR_LEN600];
3504	Platform_EncodeString(str, title);
3505	EM_ASM_({ document.title = UTF8ToString($0); }, str);
3506}
3507
3508static RequestClipboardCallback clipboard_func;
3509static void* clipboard_obj;
3510
3511EMSCRIPTEN_KEEPALIVE void Window_GotClipboardText(char* src) {
3512	cc_string str; char strBuffer[512];
3513	if (!clipboard_func) return;
3514
3515	String_InitArray(str, strBuffer)str.buffer = strBuffer; str.length = 0; str.capacity = sizeof
(strBuffer);;
3516	Platform_DecodeString(&str, src, String_CalcLen(src, 2048));
3517	clipboard_func(&str, clipboard_obj);
3518	clipboard_func = NULL((void*)0);
3519}
3520
3521void Clipboard_GetText(cc_string* value) { }
3522void Clipboard_SetText(const cc_string* value) {
3523	char str[NATIVE_STR_LEN600];
3524	Platform_EncodeString(str, value);
3525
3526	/* For IE11, use window.clipboardData to set the clipboard */
3527	/* For other browsers, instead use the window.copy events */
3528	EM_ASM_({ 
3529		if (window.clipboardData) {
3530			if (window.getSelection && window.getSelection().toString()) return;
3531			window.clipboardData.setData('Text', UTF8ToString($0));
3532		} else {
3533			window.cc_copyText = UTF8ToString($0);
3534		}
3535	}, str);
3536}
3537
3538void Clipboard_RequestText(RequestClipboardCallback callback, void* obj) {
3539	clipboard_func = callback;
3540	clipboard_obj  = obj;
3541
3542	/* For IE11, use window.clipboardData to get the clipboard */
3543	EM_ASM_({
3544		if (!window.clipboardData) return;
3545		var contents = window.clipboardData.getData('Text');
3546		ccall('Window_GotClipboardText', 'void', ['string'], [contents]);
3547	});
3548}
3549
3550void Window_Show(void) { }
3551
3552int Window_GetWindowState(void) {
3553	EmscriptenFullscreenChangeEvent status = { 0 };
3554	emscripten_get_fullscreen_status(&status);
3555	return status.isFullscreen ? WINDOW_STATE_FULLSCREEN : WINDOW_STATE_NORMAL;
3556}
3557
3558cc_result Window_EnterFullscreen(void) {
3559	EmscriptenFullscreenStrategy strategy;
3560	const char* target;
3561	int res;
3562	strategy.scaleMode                 = EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH;
3563	strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_HIDEF;
3564	strategy.filteringMode             = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT;
3565
3566	strategy.canvasResizedCallback         = OnCanvasResize;
3567	strategy.canvasResizedCallbackUserData = NULL((void*)0);
3568
3569	/* For chrome on android, need to make container div fullscreen instead */
3570	res    = EM_ASM_INT_V({ return document.getElementById('canvas_wrapper') ? 1 : 0; });
3571	target = res ? "canvas_wrapper" : "#canvas";
3572
3573	res = emscripten_request_fullscreen_strategy(target, 1, &strategy);
3574	if (res == EMSCRIPTEN_RESULT_NOT_SUPPORTED) res = ERR_NOT_SUPPORTED;
3575	if (res) return res;
3576
3577	/* emscripten sets css size to screen's base width/height, */
3578	/*  except that becomes wrong when device rotates. */
3579	/* Better to just set CSS width/height to always be 100% */
3580	EM_ASM({
3581		var canvas = Module['canvas'];
3582		canvas.style.width  = '100%';
3583		canvas.style.height = '100%';
3584	});
3585
3586	/* By default, pressing Escape will immediately exit fullscreen - which is */
3587	/*   quite annoying given that it is also the Menu key. Some browsers allow */
3588	/*   'locking' the Escape key, so that you have to hold down Escape to exit. */
3589	/* NOTE: This ONLY works when the webpage is a https:// one */
3590	EM_ASM({ try { navigator.keyboard.lock(["Escape"]); } catch { } });
3591	return 0;
3592}
3593
3594cc_result Window_ExitFullscreen(void) {
3595	emscripten_exit_fullscreen();
3596	UpdateWindowBounds();
3597	return 0;
3598}
3599
3600void Window_SetSize(int width, int height) {
3601	emscripten_set_canvas_element_size("#canvas", width, height);
3602	UpdateWindowBounds();
3603}
3604
3605void Window_Close(void) {
3606	WindowInfo.Exists = false0;
3607	Event_RaiseVoid(&WindowEvents.Closing);
3608	/* If the game is closed while in fullscreen, the last rendered frame stays */
3609	/* shown in fullscreen, but the game can't be interacted with anymore */
3610	Window_ExitFullscreen();
3611
3612	/* Don't want cursor stuck on the dead 0,0 canvas */
3613	Window_DisableRawMouse();
3614	Window_SetSize(0, 0);
3615	UnhookEvents();
3616}
3617
3618void Window_ProcessEvents(void) {
3619	if (!needResize) return;
3620	needResize = false0;
3621	if (!WindowInfo.Exists) return;
3622
3623	if (Window_GetWindowState() == WINDOW_STATE_FULLSCREEN) {
3624		SetFullscreenBounds();
3625	} else {
3626		EM_ASM( if (typeof(resizeGameCanvas) === 'function') resizeGameCanvas(); );
3627	}
3628	UpdateWindowBounds();
3629}
3630
3631/* Not needed because browser provides relative mouse and touch events */
3632static void Cursor_GetRawPos(int* x, int* y) { *x = 0; *y = 0; }
3633/* Not allowed to move cursor from javascript */
3634void Cursor_SetPosition(int x, int y) { }
3635
3636static void Cursor_DoSetVisible(cc_bool visible) {
3637	if (visible) {
3638		EM_ASM(Module['canvas'].style['cursor'] = 'default'; );
3639	} else {
3640		EM_ASM(Module['canvas'].style['cursor'] = 'none'; );
3641	}
3642}
3643
3644static void ShowDialogCore(const char* title, const char* msg) {
3645	EM_ASM_({ alert(UTF8ToString($0) + "\n\n" + UTF8ToString($1)); }, title, msg);
3646}
3647
3648static OpenFileDialogCallback uploadCallback;
3649EMSCRIPTEN_KEEPALIVE void Window_OnFileUploaded(const char* src) { 
3650	cc_string file; char buffer[FILENAME_SIZE260];
3651	String_InitArray(file, buffer)file.buffer = buffer; file.length = 0; file.capacity = sizeof
(buffer);;
3652
3653	Platform_DecodeString(&file, src, String_Length(src));
3654	uploadCallback(&file);
3655	uploadCallback = NULL((void*)0);
3656}
3657
3658cc_result Window_OpenFileDialog(const char* filter, OpenFileDialogCallback callback) {
3659	uploadCallback = callback;
3660	EM_ASM_({
3661		var elem = window.cc_uploadElem;
3662		if (!elem) {
3663			elem = document.createElement('input');
3664			elem.setAttribute('type', 'file');
3665			elem.setAttribute('style', 'display: none');
3666			elem.accept = UTF8ToString($0);
3667
3668			elem.addEventListener('change', 
3669				function(ev) {
3670					var files = ev.target.files;
3671					for (var i = 0; i < files.length; i++) {
3672						var reader = new FileReader();
3673						var name   = files[i].name;
3674
3675						reader.onload = function(e) { 
3676							var data = new Uint8Array(e.target.result);
3677							FS.createDataFile('/', name, data, true1, true1, true1);
3678							ccall('Window_OnFileUploaded', 'void', ['string'], ['/' + name]);
3679							FS.unlink('/' + name);
3680						};
3681						reader.readAsArrayBuffer(files[i]);
3682					}
3683					window.cc_container.removeChild(window.cc_uploadElem);
3684					window.cc_uploadElem = null;
3685				}, false0);
3686			window.cc_uploadElem = elem;
3687			window.cc_container.appendChild(elem);
3688		}
3689		elem.click();
3690	}, filter);
3691	return ERR_NOT_SUPPORTED;
3692}
3693
3694void Window_AllocFramebuffer(struct Bitmap* bmp) { }
3695void Window_DrawFramebuffer(Rect2D r)     { }
3696void Window_FreeFramebuffer(struct Bitmap* bmp)  { }
3697
3698EMSCRIPTEN_KEEPALIVE void Window_OnTextChanged(const char* src) { 
3699	cc_string str; char buffer[800];
3700	String_InitArray(str, buffer)str.buffer = buffer; str.length = 0; str.capacity = sizeof(buffer
);;
3701
3702	Platform_DecodeString(&str, src, String_CalcLen(src, 3200));
3703	Event_RaiseString(&InputEvents.TextChanged, &str);
3704}
3705
3706void Window_OpenKeyboard(const cc_string* text, int type) {
3707	char str[NATIVE_STR_LEN600];
3708	keyboardOpen = true1;
3709	if (!Input_TouchMode0) return;
3710	Platform_EncodeString(str, text);
3711	Platform_LogConst("OPEN SESAME");
3712
3713	EM_ASM_({
3714		var elem = window.cc_inputElem;
3715		if (!elem) {
3716			if ($1 == 1) {
3717				elem = document.createElement('input');
3718				elem.setAttribute('inputmode', 'decimal');
3719			} else {
3720				elem = document.createElement('textarea');
3721			}
3722			elem.setAttribute('style', 'position:absolute; left:0; bottom:0; margin: 0px; width: 100%');
3723			elem.value = UTF8ToString($0);
3724
3725			elem.addEventListener('input', 
3726				function(ev) {
3727					ccall('Window_OnTextChanged', 'void', ['string'], [ev.target.value]);
3728				}, false0);
3729			window.cc_inputElem = elem;
3730
3731			window.cc_divElem = document.createElement('div');
3732			window.cc_divElem.setAttribute('style', 'position:absolute; left:0; top:0; width:100%; height:100%; background-color: black; opacity:0.4; resize:none; pointer-events:none;');
3733			
3734			window.cc_container.appendChild(window.cc_divElem);
3735			window.cc_container.appendChild(elem);
3736		}
3737		elem.focus();
3738		elem.click();
3739	}, str, type);
3740}
3741
3742void Window_SetKeyboardText(const cc_string* text) {
3743	char str[NATIVE_STR_LEN600];
3744	if (!Input_TouchMode0) return;
3745	Platform_EncodeString(str, text);
3746
3747	EM_ASM_({
3748		if (!window.cc_inputElem) return;
3749		var str = UTF8ToString($0);
3750
3751		if (str == window.cc_inputElem.value) return;
3752		window.cc_inputElem.value = str;
3753	}, str);
3754}
3755
3756void Window_CloseKeyboard(void) {
3757	keyboardOpen = false0;
3758	if (!Input_TouchMode0) return;
3759
3760	EM_ASM({
3761		if (!window.cc_inputElem) return;
3762		window.cc_container.removeChild(window.cc_divElem);
3763		window.cc_container.removeChild(window.cc_inputElem);
3764		window.cc_divElem   = null;
3765		window.cc_inputElem = null;
3766	});
3767}
3768
3769void Window_EnableRawMouse(void) {
3770	RegrabMouse();
3771	/* defer pointerlock request until next user input */
3772	Input_RawMode = true1;
3773}
3774void Window_UpdateRawMouse(void) { }
3775
3776void Window_DisableRawMouse(void) {
3777	RegrabMouse();
3778	emscripten_exit_pointerlock();
3779	Input_RawMode = false0;
3780}
3781
3782
3783/*########################################################################################################################*
3784*------------------------------------------------Android activity window-------------------------------------------------*
3785*#########################################################################################################################*/
3786#elif defined CC_BUILD_ANDROID
3787#include <android/native_window.h>
3788#include <android/native_window_jni.h>
3789#include <android/keycodes.h>
3790static ANativeWindow* win_handle;
3791
3792static void RefreshWindowBounds(void) {
3793	WindowInfo.Width  = ANativeWindow_getWidth(win_handle);
3794	WindowInfo.Height = ANativeWindow_getHeight(win_handle);
3795	Platform_Log2("SCREEN BOUNDS: %i,%i", &WindowInfo.Width, &WindowInfo.Height);
3796	Event_RaiseVoid(&WindowEvents.Resized);
3797}
3798
3799static int MapNativeKey(int code) {
3800	if (code >= AKEYCODE_0  && code <= AKEYCODE_9)   return (code - AKEYCODE_0)  + '0';
3801	if (code >= AKEYCODE_A  && code <= AKEYCODE_Z)   return (code - AKEYCODE_A)  + 'A';
3802	if (code >= AKEYCODE_F1 && code <= AKEYCODE_F12) return (code - AKEYCODE_F1) + KEY_F1;
3803	if (code >= AKEYCODE_NUMPAD_0 && code <= AKEYCODE_NUMPAD_9) return (code - AKEYCODE_NUMPAD_0) + KEY_KP0;
3804 
3805	switch (code) {
3806		/* TODO: AKEYCODE_STAR */
3807		/* TODO: AKEYCODE_POUND */
3808	case AKEYCODE_BACK:   return KEY_ESCAPE;
3809	case AKEYCODE_COMMA:  return KEY_COMMA;
3810	case AKEYCODE_PERIOD: return KEY_PERIOD;
3811	case AKEYCODE_ALT_LEFT:    return KEY_LALT;
3812	case AKEYCODE_ALT_RIGHT:   return KEY_RALT;
3813	case AKEYCODE_SHIFT_LEFT:  return KEY_LSHIFT;
3814	case AKEYCODE_SHIFT_RIGHT: return KEY_RSHIFT;
3815	case AKEYCODE_TAB:    return KEY_TAB;
3816	case AKEYCODE_SPACE:  return KEY_SPACE;
3817	case AKEYCODE_ENTER:  return KEY_ENTER;
3818	case AKEYCODE_DEL:    return KEY_BACKSPACE;
3819	case AKEYCODE_GRAVE:  return KEY_TILDE;
3820	case AKEYCODE_MINUS:  return KEY_MINUS;
3821	case AKEYCODE_EQUALS: return KEY_EQUALS;
3822	case AKEYCODE_LEFT_BRACKET:  return KEY_LBRACKET;
3823	case AKEYCODE_RIGHT_BRACKET: return KEY_RBRACKET;
3824	case AKEYCODE_BACKSLASH:  return KEY_BACKSLASH;
3825	case AKEYCODE_SEMICOLON:  return KEY_SEMICOLON;
3826	case AKEYCODE_APOSTROPHE: return KEY_QUOTE;
3827	case AKEYCODE_SLASH:      return KEY_SLASH;
3828		/* TODO: AKEYCODE_AT */
3829		/* TODO: AKEYCODE_PLUS */
3830		/* TODO: AKEYCODE_MENU */
3831	case AKEYCODE_PAGE_UP:     return KEY_PAGEUP;
3832	case AKEYCODE_PAGE_DOWN:   return KEY_PAGEDOWN;
3833	case AKEYCODE_ESCAPE:      return KEY_ESCAPE;
3834	case AKEYCODE_FORWARD_DEL: return KEY_DELETE;
3835	case AKEYCODE_CTRL_LEFT:   return KEY_LCTRL;
3836	case AKEYCODE_CTRL_RIGHT:  return KEY_RCTRL;
3837	case AKEYCODE_CAPS_LOCK:   return KEY_CAPSLOCK;
3838	case AKEYCODE_SCROLL_LOCK: return KEY_SCROLLLOCK;
3839	case AKEYCODE_META_LEFT:   return KEY_LWIN;
3840	case AKEYCODE_META_RIGHT:  return KEY_RWIN;
3841	case AKEYCODE_SYSRQ:    return KEY_PRINTSCREEN;
3842	case AKEYCODE_BREAK:    return KEY_PAUSE;
3843	case AKEYCODE_INSERT:   return KEY_INSERT;
3844	case AKEYCODE_NUM_LOCK: return KEY_NUMLOCK;
3845	case AKEYCODE_NUMPAD_DIVIDE:   return KEY_KP_DIVIDE;
3846	case AKEYCODE_NUMPAD_MULTIPLY: return KEY_KP_MULTIPLY;
3847	case AKEYCODE_NUMPAD_SUBTRACT: return KEY_KP_MINUS;
3848	case AKEYCODE_NUMPAD_ADD:      return KEY_KP_PLUS;
3849	case AKEYCODE_NUMPAD_DOT:      return KEY_KP_DECIMAL;
3850	case AKEYCODE_NUMPAD_ENTER:    return KEY_KP_ENTER;
3851	}
3852	return KEY_NONE;
3853}
3854
3855static void JNICALL java_processKeyDown(JNIEnv* env, jobject o, jint code) {
3856	int key = MapNativeKey(code);
3857	Platform_Log2("KEY - DOWN %i,%i", &code, &key);
3858	if (key) Input_SetPressed(key);
3859}
3860
3861static void JNICALL java_processKeyUp(JNIEnv* env, jobject o, jint code) {
3862	int key = MapNativeKey(code);
3863	Platform_Log2("KEY - UP %i,%i", &code, &key);
3864	if (key) Input_SetReleased(key);
3865}
3866
3867static void JNICALL java_processKeyChar(JNIEnv* env, jobject o, jint code) {
3868	char keyChar;
3869	int key = MapNativeKey(code);
3870	Platform_Log2("KEY - PRESS %i,%i", &code, &key);
3871
3872	if (Convert_TryCodepointToCP437(code, &keyChar)) {
3873		Event_RaiseInt(&InputEvents.Press, keyChar);
3874	}
3875}
3876
3877static void JNICALL java_processKeyText(JNIEnv* env, jobject o, jstring str) {
3878	char buffer[NATIVE_STR_LEN600];
3879	cc_string text = JavaGetString(env, str, buffer);
3880	Platform_Log1("KEY - TEXT %s", &text);
3881	Event_RaiseString(&InputEvents.TextChanged, &text);
3882}
3883
3884static void JNICALL java_processMouseDown(JNIEnv* env, jobject o, jint id, jint x, jint y) {
3885	Platform_Log3("MOUSE %i - DOWN %i,%i", &id, &x, &y);
3886	Input_AddTouch(id, x, y);
3887}
3888
3889static void JNICALL java_processMouseUp(JNIEnv* env, jobject o, jint id, jint x, jint y) {
3890	Platform_Log3("MOUSE %i - UP   %i,%i", &id, &x, &y);
3891	Input_RemoveTouch(id, x, y);
3892}
3893
3894static void JNICALL java_processMouseMove(JNIEnv* env, jobject o, jint id, jint x, jint y) {
3895	Platform_Log3("MOUSE %i - MOVE %i,%i", &id, &x, &y);
3896	Input_UpdateTouch(id, x, y);
3897}
3898
3899static void JNICALL java_processSurfaceCreated(JNIEnv* env, jobject o, jobject surface) {
3900	Platform_LogConst("WIN - CREATED");
3901	win_handle        = ANativeWindow_fromSurface(env, surface);
3902	WindowInfo.Handle = win_handle;
3903	RefreshWindowBounds();
3904	/* TODO: Restore context */
3905	Event_RaiseVoid(&WindowEvents.Created);
3906}
3907
3908#include "Graphics.h"
3909static void JNICALL java_processSurfaceDestroyed(JNIEnv* env, jobject o) {
3910	Platform_LogConst("WIN - DESTROYED");
3911	if (win_handle) ANativeWindow_release(win_handle);
3912
3913	win_handle        = NULL((void*)0);
3914	WindowInfo.Handle = NULL((void*)0);
3915	/* eglSwapBuffers might return EGL_BAD_SURFACE, EGL_BAD_ALLOC, or some other error */
3916	/* Instead the context is lost here in a consistent manner */
3917	if (Gfx.Created) Gfx_LoseContext("surface lost");
3918	JavaCallVoid(env, "processedSurfaceDestroyed", "()V", NULL((void*)0));
3919}
3920
3921static void JNICALL java_processSurfaceResized(JNIEnv* env, jobject o, jobject surface) {
3922	Platform_LogConst("WIN - RESIZED");
3923	RefreshWindowBounds();
3924}
3925
3926static void JNICALL java_processSurfaceRedrawNeeded(JNIEnv* env, jobject o) {
3927	Platform_LogConst("WIN - REDRAW");
3928	Event_RaiseVoid(&WindowEvents.Redraw);
3929}
3930
3931static void JNICALL java_onStart(JNIEnv* env, jobject o) {
3932	Platform_LogConst("APP - ON START");
3933}
3934 
3935static void JNICALL java_onStop(JNIEnv* env, jobject o) {
3936	Platform_LogConst("APP - ON STOP");
3937}
3938 
3939static void JNICALL java_onResume(JNIEnv* env, jobject o) {
3940	Platform_LogConst("APP - ON RESUME");
3941	/* TODO: Resume rendering */
3942}
3943 
3944static void JNICALL java_onPause(JNIEnv* env, jobject o) {
3945	Platform_LogConst("APP - ON PAUSE");
3946	/* TODO: Disable rendering */
3947}
3948 
3949static void JNICALL java_onDestroy(JNIEnv* env, jobject o) {
3950	Platform_LogConst("APP - ON DESTROY");
3951 
3952	if (WindowInfo.Exists) Window_Close();
3953	/* TODO: signal to java code we're done */
3954	JavaCallVoid(env, "processedDestroyed", "()V", NULL((void*)0));
3955}
3956 
3957static void JNICALL java_onGotFocus(JNIEnv* env, jobject o) {
3958	Platform_LogConst("APP - GOT FOCUS");
3959	WindowInfo.Focused = true1;
3960	Event_RaiseVoid(&WindowEvents.FocusChanged);
3961}
3962
3963static void JNICALL java_onLostFocus(JNIEnv* env, jobject o) {
3964	Platform_LogConst("APP - LOST FOCUS");
3965	WindowInfo.Focused = false0;
3966	Event_RaiseVoid(&WindowEvents.FocusChanged);
3967	/* TODO: Disable rendering? */
3968}
3969 
3970static void JNICALL java_onLowMemory(JNIEnv* env, jobject o) {
3971	Platform_LogConst("APP - LOW MEM");
3972	/* TODO: Low memory */
3973}
3974
3975static const JNINativeMethod methods[19] = {
3976	{ "processKeyDown",   "(I)V", java_processKeyDown },
3977	{ "processKeyUp",     "(I)V", java_processKeyUp },
3978	{ "processKeyChar",   "(I)V", java_processKeyChar },
3979	{ "processKeyText",   "(Ljava/lang/String;)V", java_processKeyText },
3980
3981	{ "processMouseDown", "(III)V", java_processMouseDown },
3982	{ "processMouseUp",   "(III)V", java_processMouseUp },
3983	{ "processMouseMove", "(III)V", java_processMouseMove },
3984
3985	{ "processSurfaceCreated",      "(Landroid/view/Surface;)V",  java_processSurfaceCreated },
3986	{ "processSurfaceDestroyed",    "()V",                        java_processSurfaceDestroyed },
3987	{ "processSurfaceResized",      "(Landroid/view/Surface;)V",  java_processSurfaceResized },
3988	{ "processSurfaceRedrawNeeded", "()V",                        java_processSurfaceRedrawNeeded },
3989
3990	{ "processOnStart",   "()V", java_onStart },
3991	{ "processOnStop",    "()V", java_onStop },
3992	{ "processOnResume",  "()V", java_onResume },
3993	{ "processOnPause",   "()V", java_onPause },
3994	{ "processOnDestroy", "()V", java_onDestroy },
3995
3996	{ "processOnGotFocus",  "()V", java_onGotFocus },
3997	{ "processOnLostFocus", "()V", java_onLostFocus },
3998	{ "processOnLowMemory", "()V", java_onLowMemory }
3999};
4000
4001void Window_Init(void) {
4002	JNIEnv* env;
4003	/* TODO: ANativeActivity_setWindowFlags(app->activity, AWINDOW_FLAG_FULLSCREEN, 0); */
4004	JavaGetCurrentEnv(env);
4005	JavaRegisterNatives(env, methods);
4006
4007	WindowInfo.SoftKeyboard = SOFT_KEYBOARD_RESIZE;
4008	Input_TouchMode0         = true1;
4009	DisplayInfo.Depth  = 32;
4010	DisplayInfo.ScaleX = JavaCallFloat(env, "getDpiX", "()F", NULL((void*)0));
4011	DisplayInfo.ScaleY = JavaCallFloat(env, "getDpiY", "()F", NULL((void*)0));
4012}
4013
4014void Window_Create(int width, int height) {
4015	WindowInfo.Exists = true1;
4016	/* actual window creation is done when processSurfaceCreated is received */
4017}
4018
4019static cc_bool winCreated;
4020static void OnWindowCreated(void* obj) { winCreated = true1; }
4021cc_bool Window_RemakeSurface(void) {
4022	JNIEnv* env;
4023	JavaGetCurrentEnv(env);
4024	winCreated = false0;
4025
4026	/* Force window to be destroyed and re-created */
4027	/* (see comments in setupForGame for why this has to be done) */
4028	JavaCallVoid(env, "setupForGame", "()V", NULL((void*)0));
4029	Event_Register_(&WindowEvents.Created, NULL, OnWindowCreated)Event_Register((struct Event_Void*)(&WindowEvents.Created
), ((void*)0), (Event_Void_Callback)(OnWindowCreated));
4030	Platform_LogConst("Entering wait for window exist loop..");
4031
4032	/* Loop until window gets created async */
4033	while (WindowInfo.Exists && !winCreated) {
4034		Window_ProcessEvents();
4035		Thread_Sleep(10);
4036	}
4037
4038	Platform_LogConst("OK window created..");
4039	Event_Unregister_(&WindowEvents.Created, NULL, OnWindowCreated)Event_Unregister((struct Event_Void*)(&WindowEvents.Created
), ((void*)0), (Event_Void_Callback)(OnWindowCreated));
4040	return winCreated;
4041}
4042
4043void Window_SetTitle(const cc_string* title) {
4044	/* TODO: Implement this somehow */
4045	/* Maybe https://stackoverflow.com/questions/2198410/how-to-change-title-of-activity-in-android */
4046}
4047
4048void Clipboard_GetText(cc_string* value) {
4049	JavaCall_Void_String("getClipboardText", value);
4050}
4051void Clipboard_SetText(const cc_string* value) {
4052	JavaCall_String_Void("setClipboardText", value);
4053}
4054
4055void Window_Show(void) { } /* Window already visible */
4056int Window_GetWindowState(void) { 
4057	JNIEnv* env;
4058	JavaGetCurrentEnv(env);
4059	return JavaCallInt(env, "getWindowState", "()I", NULL((void*)0));
4060}
4061
4062cc_result Window_EnterFullscreen(void) {
4063	JNIEnv* env;
4064	JavaGetCurrentEnv(env);
4065	JavaCallVoid(env, "enterFullscreen", "()V", NULL((void*)0));
4066	return 0; 
4067}
4068
4069cc_result Window_ExitFullscreen(void) {
4070	JNIEnv* env;
4071	JavaGetCurrentEnv(env);
4072	JavaCallVoid(env, "exitFullscreen", "()V", NULL((void*)0));
4073	return 0; 
4074}
4075
4076void Window_SetSize(int width, int height) { }
4077
4078void Window_Close(void) {
4079	WindowInfo.Exists = false0;
4080	Event_RaiseVoid(&WindowEvents.Closing);
4081	/* TODO: Do we need to call finish here */
4082	/* ANativeActivity_finish(app->activity); */
4083}
4084
4085void Window_ProcessEvents(void) {
4086	JNIEnv* env;
4087	JavaGetCurrentEnv(env);
4088	/* TODO: Cache the java env and cache the method ID!!!!! */
4089	JavaCallVoid(env, "processEvents", "()V", NULL((void*)0));
4090}
4091
4092/* No actual mouse cursor */
4093static void Cursor_GetRawPos(int* x, int* y) { *x = 0; *y = 0; }
4094void Cursor_SetPosition(int x, int y) { }
4095static void Cursor_DoSetVisible(cc_bool visible) { }
4096
4097static void ShowDialogCore(const char* title, const char* msg) {
4098	JNIEnv* env;
4099	jvalue args[2];
4100	JavaGetCurrentEnv(env);
4101
4102	Platform_LogConst(title);
4103	Platform_LogConst(msg);
4104
4105	args[0].l = JavaMakeConst(env, title);
4106	args[1].l = JavaMakeConst(env, msg);
4107	JavaCallVoid(env, "showAlert", "(Ljava/lang/String;Ljava/lang/String;)V", args);
4108	(*env)->DeleteLocalRef(env, args[0].l);
4109	(*env)->DeleteLocalRef(env, args[1].l);
4110}
4111
4112static struct Bitmap fb_bmp;
4113void Window_AllocFramebuffer(struct Bitmap* bmp) {
4114	bmp->scan0 = (BitmapCol*)Mem_Alloc(bmp->width * bmp->height, 4, "window pixels");
4115	fb_bmp     = *bmp;
4116}
4117
4118void Window_DrawFramebuffer(Rect2D r) {
4119	ANativeWindow_Buffer buffer;
4120	cc_uint32* src;
4121	cc_uint32* dst;
4122	ARect b;
4123	int y, res, size;
4124
4125	/* window not created yet */
4126	if (!win_handle) return;
4127	b.left = r.X; b.right  = r.X + r.Width;
4128	b.top  = r.Y; b.bottom = r.Y + r.Height;
4129
4130	/* Platform_Log4("DIRTY: %i,%i - %i,%i", &b.left, &b.top, &b.right, &b.bottom); */
4131	res  = ANativeWindow_lock(win_handle, &buffer, &b);
4132	if (res) Logger_Abort2(res, "Locking window pixels");
4133	/* Platform_Log4("ADJUS: %i,%i - %i,%i", &b.left, &b.top, &b.right, &b.bottom); */
4134
4135	/* In some rare cases, the returned locked region will be entire area of the surface */
4136	/* This can cause a crash if the surface has been resized (i.e. device rotated), */
4137	/* but the framebuffer has not been resized yet. So always constrain bounds. */
4138	b.left = min(b.left, fb_bmp.width)((b.left) < (fb_bmp.width) ? (b.left) : (fb_bmp.width));  b.right  = min(b.right,  fb_bmp.width)((b.right) < (fb_bmp.width) ? (b.right) : (fb_bmp.width));
4139	b.top  = min(b.top,  fb_bmp.height)((b.top) < (fb_bmp.height) ? (b.top) : (fb_bmp.height)); b.bottom = min(b.bottom, fb_bmp.height)((b.bottom) < (fb_bmp.height) ? (b.bottom) : (fb_bmp.height
));
4140
4141	src  = (cc_uint32*)fb_bmp.scan0 + b.left;
4142	dst  = (cc_uint32*)buffer.bits  + b.left;
4143	size = (b.right - b.left) * 4;
4144
4145	for (y = b.top; y < b.bottom; y++) {
4146		Mem_Copy(dst + y * buffer.stride, src + y * fb_bmp.width, size);
4147	}
4148	res = ANativeWindow_unlockAndPost(win_handle);
4149	if (res) Logger_Abort2(res, "Unlocking window pixels");
4150}
4151
4152void Window_FreeFramebuffer(struct Bitmap* bmp) {
4153	Mem_Free(bmp->scan0);
4154}
4155
4156void Window_OpenKeyboard(const cc_string* text, int type) {
4157	JNIEnv* env;
4158	jvalue args[2];
4159	JavaGetCurrentEnv(env);
4160
4161	args[0].l = JavaMakeString(env, text);
4162	args[1].i = type;
4163	JavaCallVoid(env, "openKeyboard", "(Ljava/lang/String;I)V", args);
4164	(*env)->DeleteLocalRef(env, args[0].l);
4165}
4166
4167void Window_SetKeyboardText(const cc_string* text) {
4168	JNIEnv* env;
4169	jvalue args[1];
4170	JavaGetCurrentEnv(env);
4171
4172	args[0].l = JavaMakeString(env, text);
4173	JavaCallVoid(env, "setKeyboardText", "(Ljava/lang/String;)V", args);
4174	(*env)->DeleteLocalRef(env, args[0].l);
4175}
4176
4177void Window_CloseKeyboard(void) {
4178	JNIEnv* env;
4179	JavaGetCurrentEnv(env);
4180	JavaCallVoid(env, "closeKeyboard", "()V", NULL((void*)0));
4181}
4182
4183void Window_EnableRawMouse(void)  { DefaultEnableRawMouse(); }
4184void Window_UpdateRawMouse(void)  { }
4185void Window_DisableRawMouse(void) { DefaultDisableRawMouse(); }
4186#endif
4187
4188
4189
4190#ifdef CC_BUILD_GL
4191/* OpenGL contexts are heavily tied to the window, so for simplicitly are also included here */
4192/* SDL and EGL are platform agnostic, other OpenGL context backends are tied to one windowing system. */
4193#define GLCONTEXT_DEFAULT_DEPTH24 24
4194#define GLContext_IsInvalidAddress(ptr)(ptr == (void*)0 || ptr == (void*)1 || ptr == (void*)-1 || ptr
 == (void*)2) (ptr == (void*)0 || ptr == (void*)1 || ptr == (void*)-1 || ptr == (void*)2)
4195
4196void GLContext_GetAll(const struct DynamicLibSym* syms, int count) {
4197	int i;
4198	for (i = 0; i < count; i++) {
4199		*syms[i].symAddr = GLContext_GetAddress(syms[i].name);
4200	}
4201}
4202
4203/*########################################################################################################################*
4204*-------------------------------------------------------SDL OpenGL--------------------------------------------------------*
4205*#########################################################################################################################*/
4206#if defined CC_BUILD_SDL
4207static SDL_GLContext win_ctx;
4208
4209void GLContext_Create(void) {
4210	struct GraphicsMode mode;
4211	InitGraphicsMode(&mode);
4212	SDL_GL_SetAttribute(SDL_GL_RED_SIZE,   mode.R);
4213	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, mode.G);
4214	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,  mode.B);
4215	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, mode.A);
4216
4217	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,   GLCONTEXT_DEFAULT_DEPTH24);
4218	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
4219	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, true1);
4220
4221	win_ctx = SDL_GL_CreateContext(win_handle);
4222	if (!win_ctx) Window_SDLFail("creating OpenGL context");
4223}
4224
4225void GLContext_Update(void) { }
4226cc_bool GLContext_TryRestore(void) { return true1; }
4227void GLContext_Free(void) {
4228	SDL_GL_DeleteContext(win_ctx);
4229	win_ctx = NULL((void*)0);
4230}
4231
4232void* GLContext_GetAddress(const char* function) {
4233	return SDL_GL_GetProcAddress(function);
4234}
4235
4236cc_bool GLContext_SwapBuffers(void) {
4237	SDL_GL_SwapWindow(win_handle);
4238	return true1;
4239}
4240
4241void GLContext_SetFpsLimit(cc_bool vsync, float minFrameMs) {
4242	SDL_GL_SetSwapInterval(vsync);
4243}
4244void GLContext_GetApiInfo(cc_string* info) { }
4245
4246
4247/*########################################################################################################################*
4248*-------------------------------------------------------EGL OpenGL--------------------------------------------------------*
4249*#########################################################################################################################*/
4250#elif defined CC_BUILD_EGL
4251#include <EGL/egl.h>
4252static EGLDisplay ctx_display;
4253static EGLContext ctx_context;
4254static EGLSurface ctx_surface;
4255static EGLConfig ctx_config;
4256static EGLint ctx_numConfig;
4257
4258#ifdef CC_BUILD_X11
4259static XVisualInfo GLContext_SelectVisual(struct GraphicsMode* mode) {
4260	XVisualInfo info;
4261	cc_result res;
4262
4263	res = XMatchVisualInfo(win_display, win_screen, 24, TrueColor4, &info) ||
4264		  XMatchVisualInfo(win_display, win_screen, 32, TrueColor4, &info);
4265
4266	if (!res) Logger_Abort("Selecting visual");
4267	return info;
4268}
4269#endif
4270
4271static void GLContext_InitSurface(void) {
4272	if (!win_handle) return; /* window not created or lost */
4273	ctx_surface = eglCreateWindowSurface(ctx_display, ctx_config, win_handle, NULL((void*)0));
4274
4275	if (!ctx_surface) return;
4276	eglMakeCurrent(ctx_display, ctx_surface, ctx_surface, ctx_context);
4277}
4278
4279static void GLContext_FreeSurface(void) {
4280	if (!ctx_surface) return;
4281	eglMakeCurrent(ctx_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
4282	eglDestroySurface(ctx_display, ctx_surface);
4283	ctx_surface = NULL((void*)0);
4284}
4285
4286void GLContext_Create(void) {
4287	static EGLint contextAttribs[3] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
4288	static EGLint attribs[19] = {
4289		EGL_RED_SIZE,  0, EGL_GREEN_SIZE,  0,
4290		EGL_BLUE_SIZE, 0, EGL_ALPHA_SIZE,  0,
4291		EGL_DEPTH_SIZE,        GLCONTEXT_DEFAULT_DEPTH24,
4292		EGL_STENCIL_SIZE,      0,
4293		EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER,
4294		EGL_RENDERABLE_TYPE,   EGL_OPENGL_ES2_BIT,
4295		EGL_SURFACE_TYPE,      EGL_WINDOW_BIT,
4296		EGL_NONE
4297	};
4298
4299	struct GraphicsMode mode;
4300	InitGraphicsMode(&mode);
4301	attribs[1] = mode.R; attribs[3] = mode.G;
4302	attribs[5] = mode.B; attribs[7] = mode.A;
4303
4304	ctx_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
4305	eglInitialize(ctx_display, NULL((void*)0), NULL((void*)0));
4306	eglBindAPI(EGL_OPENGL_ES_API);
4307	eglChooseConfig(ctx_display, attribs, &ctx_config, 1, &ctx_numConfig);
4308
4309	ctx_context = eglCreateContext(ctx_display, ctx_config, EGL_NO_CONTEXT, contextAttribs);
4310	GLContext_InitSurface();
4311}
4312
4313void GLContext_Update(void) {
4314	GLContext_FreeSurface();
4315	GLContext_InitSurface();
4316}
4317
4318cc_bool GLContext_TryRestore(void) {
4319	GLContext_FreeSurface();
4320	GLContext_InitSurface();
4321	return ctx_surface != NULL((void*)0);
4322}
4323
4324void GLContext_Free(void) {
4325	GLContext_FreeSurface();
4326	eglDestroyContext(ctx_display, ctx_context);
4327	eglTerminate(ctx_display);
4328}
4329
4330void* GLContext_GetAddress(const char* function) {
4331	return eglGetProcAddress(function);
4332}
4333
4334cc_bool GLContext_SwapBuffers(void) {
4335	EGLint err;
4336	if (!ctx_surface) return false0;
4337	if (eglSwapBuffers(ctx_display, ctx_surface)) return true1;
4338
4339	err = eglGetError();
4340	/* TODO: figure out what errors need to be handled here */
4341	Logger_Abort2(err, "Failed to swap buffers");
4342	return false0;
4343}
4344
4345void GLContext_SetFpsLimit(cc_bool vsync, float minFrameMs) {
4346	eglSwapInterval(ctx_display, vsync);
4347}
4348void GLContext_GetApiInfo(cc_string* info) { }
4349
4350
4351/*########################################################################################################################*
4352*-------------------------------------------------------WGL OpenGL--------------------------------------------------------*
4353*#########################################################################################################################*/
4354#elif defined CC_BUILD_WINGUI
4355static HGLRC ctx_handle;
4356static HDC ctx_DC;
4357typedef BOOL (WINAPI *FN_WGLSWAPINTERVAL)(int interval);
4358static FN_WGLSWAPINTERVAL wglSwapIntervalEXT;
4359static cc_bool ctx_supports_vSync;
4360
4361static void GLContext_SelectGraphicsMode(struct GraphicsMode* mode) {
4362	PIXELFORMATDESCRIPTOR pfd = { 0 };
4363	pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
4364	pfd.nVersion = 1;
4365	pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER;
4366	/* TODO: PFD_SUPPORT_COMPOSITION FLAG? CHECK IF IT WORKS ON XP */
4367	pfd.cColorBits = mode->R + mode->G + mode->B;
4368	pfd.cDepthBits = GLCONTEXT_DEFAULT_DEPTH24;
4369
4370	pfd.iPixelType = mode->IsIndexed ? PFD_TYPE_COLORINDEX : PFD_TYPE_RGBA;
4371	pfd.cRedBits   = mode->R;
4372	pfd.cGreenBits = mode->G;
4373	pfd.cBlueBits  = mode->B;
4374	pfd.cAlphaBits = mode->A;
4375
4376	int modeIndex = ChoosePixelFormat(win_DC, &pfd);
4377	if (modeIndex == 0) { Logger_Abort("Requested graphics mode not available"); }
4378
4379	Mem_Set(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
4380	pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
4381	pfd.nVersion = 1;
4382
4383	DescribePixelFormat(win_DC, modeIndex, pfd.nSize, &pfd);
4384	if (!SetPixelFormat(win_DC, modeIndex, &pfd)) {
4385		Logger_Abort2(GetLastError(), "SetPixelFormat failed");
4386	}
4387}
4388
4389void GLContext_Create(void) {
4390	struct GraphicsMode mode;
4391	InitGraphicsMode(&mode);
4392	GLContext_SelectGraphicsMode(&mode);
4393
4394	ctx_handle = wglCreateContext(win_DC);
4395	if (!ctx_handle) ctx_handle = wglCreateContext(win_DC);
4396
4397	if (!ctx_handle) {
4398		Logger_Abort2(GetLastError(), "Failed to create OpenGL context");
4399	}
4400
4401	if (!wglMakeCurrent(win_DC, ctx_handle)) {
4402		Logger_Abort2(GetLastError(), "Failed to make OpenGL context current");
4403	}
4404
4405	ctx_DC = wglGetCurrentDC();
4406	wglSwapIntervalEXT = (FN_WGLSWAPINTERVAL)GLContext_GetAddress("wglSwapIntervalEXT");
4407	ctx_supports_vSync = wglSwapIntervalEXT != NULL((void*)0);
4408}
4409
4410void GLContext_Update(void) { }
4411cc_bool GLContext_TryRestore(void) { return true1; }
4412void GLContext_Free(void) {
4413	if (!ctx_handle) return;
4414	wglDeleteContext(ctx_handle);
4415	ctx_handle = NULL((void*)0);
4416}
4417
4418void* GLContext_GetAddress(const char* function) {
4419	void* addr = (void*)wglGetProcAddress(function);
4420	return GLContext_IsInvalidAddress(addr)(addr == (void*)0 || addr == (void*)1 || addr == (void*)-1 ||
 addr == (void*)2) ? NULL((void*)0) : addr;
4421}
4422
4423cc_bool GLContext_SwapBuffers(void) {
4424	if (!SwapBuffers(ctx_DC)) Logger_Abort2(GetLastError(), "Failed to swap buffers");
4425	return true1;
4426}
4427
4428void GLContext_SetFpsLimit(cc_bool vsync, float minFrameMs) {
4429	if (ctx_supports_vSync) wglSwapIntervalEXT(vsync);
4430}
4431void GLContext_GetApiInfo(cc_string* info) { }
4432
4433
4434/*########################################################################################################################*
4435*-------------------------------------------------------glX OpenGL--------------------------------------------------------*
4436*#########################################################################################################################*/
4437#elif defined CC_BUILD_X11
4438#include <GL/glx.h>
4439static GLXContext ctx_handle;
4440typedef int (*FN_GLXSWAPINTERVAL)(int interval);
4441static FN_GLXSWAPINTERVAL swapIntervalMESA, swapIntervalSGI;
4442static cc_bool ctx_supports_vSync;
4443
4444void GLContext_Create(void) {
4445	static const cc_string ext_mesa = String_FromConst("GLX_MESA_swap_control"){ "GLX_MESA_swap_control", (sizeof("GLX_MESA_swap_control") -
 1), (sizeof("GLX_MESA_swap_control") - 1)};
4446	static const cc_string ext_sgi  = String_FromConst("GLX_SGI_swap_control"){ "GLX_SGI_swap_control", (sizeof("GLX_SGI_swap_control") - 1
), (sizeof("GLX_SGI_swap_control") - 1)};
4447
4448	const char* raw_exts;
4449	cc_string exts;
4450	ctx_handle = glXCreateContext(win_display, &win_visual, NULL((void*)0), true1);
4451
4452	if (!ctx_handle) {
4453		Platform_LogConst("Context create failed. Trying indirect...");
4454		ctx_handle = glXCreateContext(win_display, &win_visual, NULL((void*)0), false0);
4455	}
4456	if (!ctx_handle) Logger_Abort("Failed to create OpenGL context");
4457
4458	if (!glXIsDirect(win_display, ctx_handle)) {
4459		Platform_LogConst("== WARNING: Context is not direct ==");
4460	}
4461	if (!glXMakeCurrent(win_display, win_handle, ctx_handle)) {
4462		Logger_Abort("Failed to make OpenGL context current.");
4463	}
4464
4465	/* GLX may return non-null function pointers that don't actually work */
4466	/* So we need to manually check the extensions string for support */
4467	raw_exts = glXQueryExtensionsString(win_display, win_screen);
4468	exts = String_FromReadonly(raw_exts);
4469
4470	if (String_CaselessContains(&exts, &ext_mesa)) {
4471		swapIntervalMESA = (FN_GLXSWAPINTERVAL)GLContext_GetAddress("glXSwapIntervalMESA");
4472	}
4473	if (String_CaselessContains(&exts, &ext_sgi)) {
4474		swapIntervalSGI  = (FN_GLXSWAPINTERVAL)GLContext_GetAddress("glXSwapIntervalSGI");
4475	}
4476	ctx_supports_vSync = swapIntervalMESA || swapIntervalSGI;
4477}
4478
4479void GLContext_Update(void) { }
4480cc_bool GLContext_TryRestore(void) { return true1; }
4481void GLContext_Free(void) {
4482	if (!ctx_handle) return;
4483	glXMakeCurrent(win_display, None0L, NULL((void*)0));
4484	glXDestroyContext(win_display, ctx_handle);
4485	ctx_handle = NULL((void*)0);
4486}
4487
4488void* GLContext_GetAddress(const char* function) {
4489	void* addr = (void*)glXGetProcAddress((const GLubyte*)function);
4490	return GLContext_IsInvalidAddress(addr)(addr == (void*)0 || addr == (void*)1 || addr == (void*)-1 ||
 addr == (void*)2) ? NULL((void*)0) : addr;
4491}
4492
4493cc_bool GLContext_SwapBuffers(void) {
4494	glXSwapBuffers(win_display, win_handle);
4495	return true1;
4496}
4497
4498void GLContext_SetFpsLimit(cc_bool vsync, float minFrameMs) {
4499	int res;
4500	if (!ctx_supports_vSync) return;
4501
4502	if (swapIntervalMESA) {
4503		res = swapIntervalMESA(vsync);
4504	} else {
4505		res = swapIntervalSGI(vsync);
4506	}
4507	if (res) Platform_Log1("Set VSync failed, error: %i", &res);
4508}
4509void GLContext_GetApiInfo(cc_string* info) { }
4510
4511static void GetAttribs(struct GraphicsMode* mode, int* attribs, int depth) {
4512	int i = 0;
4513	/* See http://www-01.ibm.com/support/knowledgecenter/ssw_aix_61/com.ibm.aix.opengl/doc/openglrf/glXChooseFBConfig.htm%23glxchoosefbconfig */
4514	/* See http://www-01.ibm.com/support/knowledgecenter/ssw_aix_71/com.ibm.aix.opengl/doc/openglrf/glXChooseVisual.htm%23b5c84be452rree */
4515	/* for the attribute declarations. Note that the attributes are different than those used in glxChooseVisual */
4516
4517	if (!mode->IsIndexed) { attribs[i++] = GLX_RGBA4; }
4518	attribs[i++] = GLX_RED_SIZE8;   attribs[i++] = mode->R;
4519	attribs[i++] = GLX_GREEN_SIZE9; attribs[i++] = mode->G;
4520	attribs[i++] = GLX_BLUE_SIZE10;  attribs[i++] = mode->B;
4521	attribs[i++] = GLX_ALPHA_SIZE11; attribs[i++] = mode->A;
4522	attribs[i++] = GLX_DEPTH_SIZE12; attribs[i++] = depth;
4523
4524	attribs[i++] = GLX_DOUBLEBUFFER5;
4525	attribs[i++] = 0;
4526}
4527
4528static XVisualInfo GLContext_SelectVisual(struct GraphicsMode* mode) {
4529	int attribs[20];
4530	int major, minor;
4531	XVisualInfo* visual = NULL((void*)0);
4532
4533	int fbcount;
4534	GLXFBConfig* fbconfigs;
4535	XVisualInfo info;
4536
4537	GetAttribs(mode, attribs, GLCONTEXT_DEFAULT_DEPTH24);
4538	if (!glXQueryVersion(win_display, &major, &minor)) {
2
←
Assuming the condition is false→
3
←
Taking false branch→
4539		Logger_Abort("glXQueryVersion failed");
4540	}
4541
4542	if (major >= 1 && minor >= 3) {
4
←
Assuming 'major' is < 1→
4543		/* ChooseFBConfig returns an array of GLXFBConfig opaque structures */
4544		fbconfigs = glXChooseFBConfig(win_display, win_screen, attribs, &fbcount);
4545		if (fbconfigs && fbcount) {
4546			/* Use the first GLXFBConfig from the fbconfigs array (best match) */
4547			visual = glXGetVisualFromFBConfig(win_display, *fbconfigs);
4548			XFree(fbconfigs);
4549		}
4550	}
4551
4552	if (!visual4.1
'visual' is null
) {
5
←
Taking true branch→
4553		Platform_LogConst("Falling back to glXChooseVisual.");
4554		visual = glXChooseVisual(win_display, win_screen, attribs);
4555	}
4556	/* Some really old devices will only supply 16 bit depths */
4557	if (!visual) {
6
←
Assuming 'visual' is null→
7
←
Taking true branch→
4558		GetAttribs(mode, attribs, 16);
4559		visual = glXChooseVisual(win_display, win_screen, attribs);
8
←
Value assigned to 'visual'→
4560	}
4561	if (!visual) Logger_Abort("Requested GraphicsMode not available.");
9
←
Assuming 'visual' is null→
10
←
Assuming pointer value is null→
11
←
Taking true branch→
4562
4563	info = *visual;
12
←
Dereference of null pointer (loaded from variable 'visual')
4564	XFree(visual);
4565	return info;
4566}
4567
4568
4569/*########################################################################################################################*
4570*-------------------------------------------------------AGL OpenGL--------------------------------------------------------*
4571*#########################################################################################################################*/
4572#elif defined CC_BUILD_CARBON
4573#include <AGL/agl.h>
4574
4575static AGLContext ctx_handle;
4576static cc_bool ctx_firstFullscreen;
4577static int ctx_windowWidth, ctx_windowHeight;
4578
4579static void GLContext_Check(int code, const char* place) {
4580	cc_result res;
4581	if (code) return;
4582
4583	res = aglGetError();
4584	if (res) Logger_Abort2(res, place);
4585}
4586
4587static void GLContext_MakeCurrent(void) {
4588	int code = aglSetCurrentContext(ctx_handle);
4589	GLContext_Check(code, "Setting GL context");
4590}
4591
4592static void GLContext_SetDrawable(void) {
4593	CGrafPtr windowPort = GetWindowPort(win_handle);
4594	int code = aglSetDrawable(ctx_handle, windowPort);
4595	GLContext_Check(code, "Attaching GL context");
4596}
4597
4598static void GLContext_GetAttribs(struct GraphicsMode* mode, GLint* attribs, cc_bool fullscreen) {
4599	int i = 0;
4600
4601	if (!mode->IsIndexed) { attribs[i++] = AGL_RGBA; }
4602	attribs[i++] = AGL_RED_SIZE;   attribs[i++] = mode->R;
4603	attribs[i++] = AGL_GREEN_SIZE; attribs[i++] = mode->G;
4604	attribs[i++] = AGL_BLUE_SIZE;  attribs[i++] = mode->B;
4605	attribs[i++] = AGL_ALPHA_SIZE; attribs[i++] = mode->A;
4606	attribs[i++] = AGL_DEPTH_SIZE; attribs[i++] = GLCONTEXT_DEFAULT_DEPTH24;
4607
4608	attribs[i++] = AGL_DOUBLEBUFFER;
4609	if (fullscreen) { attribs[i++] = AGL_FULLSCREEN; }
4610	attribs[i++] = 0;
4611}
4612
4613static cc_result GLContext_UnsetFullscreen(void) {
4614	int code;
4615	Platform_LogConst("Unsetting fullscreen.");
4616
4617	code = aglSetDrawable(ctx_handle, NULL((void*)0));
4618	if (!code) return aglGetError();
4619	/* TODO: I don't think this is necessary */
4620	code = aglUpdateContext(ctx_handle);
4621	if (!code) return aglGetError();
4622
4623	CGDisplayRelease(CGMainDisplayID());
4624	GLContext_SetDrawable();
4625
4626	win_fullscreen = false0;
4627	/* TODO: Eliminate this if possible */
4628	Window_SetSize(ctx_windowWidth, ctx_windowHeight);
4629	return 0;
4630}
4631
4632static cc_result GLContext_SetFullscreen(void) {
4633	int width  = DisplayInfo.Width;
4634	int height = DisplayInfo.Height;
4635	int code;
4636
4637	Platform_LogConst("Switching to fullscreen");
4638	/* TODO: Does aglSetFullScreen capture the screen anyways? */
4639	CGDisplayCapture(CGMainDisplayID());
4640
4641	if (!aglSetFullScreen(ctx_handle, width, height, 0, 0)) {
4642		code = aglGetError();
4643		GLContext_UnsetFullscreen();
4644		return code;
4645	}
4646	/* TODO: Do we really need to call this? */
4647	GLContext_MakeCurrent();
4648
4649	/* This is a weird hack to workaround a bug where the first time a context */
4650	/* is made fullscreen, we just end up with a blank screen.  So we undo it as fullscreen */
4651	/* and redo it as fullscreen. */
4652	/* TODO: We really should'd need to do this. Need to debug on real hardware. */
4653	if (!ctx_firstFullscreen) {
4654		ctx_firstFullscreen = true1;
4655		GLContext_UnsetFullscreen();
4656		return GLContext_SetFullscreen();
4657	}
4658
4659	win_fullscreen   = true1;
4660	ctx_windowWidth  = WindowInfo.Width;
4661	ctx_windowHeight = WindowInfo.Height;
4662
4663	windowX = DisplayInfo.X; WindowInfo.Width  = DisplayInfo.Width;
4664	windowY = DisplayInfo.Y; WindowInfo.Height = DisplayInfo.Height;
4665	return 0;
4666}
4667
4668void GLContext_Create(void) {
4669	GLint attribs[20];
4670	AGLPixelFormat fmt;
4671	GDHandle gdevice;
4672	OSStatus res;
4673	struct GraphicsMode mode;
4674	InitGraphicsMode(&mode);
4675
4676	/* Initially try creating fullscreen compatible context */	
4677	res = DMGetGDeviceByDisplayID(CGMainDisplayID(), &gdevice, false0);
4678	if (res) Logger_Abort2(res, "Getting display device failed");
4679
4680	GLContext_GetAttribs(&mode, attribs, true1);
4681	fmt = aglChoosePixelFormat(&gdevice, 1, attribs);
4682	res = aglGetError();
4683
4684	/* Try again with non-compatible context if that fails */
4685	if (!fmt || res == AGL_BAD_PIXELFMT) {
4686		Platform_LogConst("Failed to create full screen pixel format.");
4687		Platform_LogConst("Trying again to create a non-fullscreen pixel format.");
4688
4689		GLContext_GetAttribs(&mode, attribs, false0);
4690		fmt = aglChoosePixelFormat(NULL((void*)0), 0, attribs);
4691		res = aglGetError();
4692	}
4693	if (res) Logger_Abort2(res, "Choosing pixel format");
4694
4695	ctx_handle = aglCreateContext(fmt, NULL((void*)0));
4696	GLContext_Check(0, "Creating GL context");
4697
4698	aglDestroyPixelFormat(fmt);
4699	GLContext_Check(0, "Destroying pixel format");
4700
4701	GLContext_SetDrawable();
4702	GLContext_Update();
4703	GLContext_MakeCurrent();
4704}
4705
4706void GLContext_Update(void) {
4707	if (win_fullscreen) return;
4708	GLContext_SetDrawable();
4709	aglUpdateContext(ctx_handle);
4710}
4711cc_bool GLContext_TryRestore(void) { return true1; }
4712
4713void GLContext_Free(void) {
4714	if (!ctx_handle) return;
4715	aglSetCurrentContext(NULL((void*)0));
4716	aglDestroyContext(ctx_handle);
4717	ctx_handle = NULL((void*)0);
4718}
4719
4720void* GLContext_GetAddress(const char* function) {
4721	static const cc_string glPath = String_FromConst("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"){ "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
, (sizeof("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
) - 1), (sizeof("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
) - 1)};
4722	static void* lib;
4723	void* addr;
4724
4725	if (!lib) lib = DynamicLib_Load2(&glPath);
4726	addr = DynamicLib_Get2(lib, function);
4727	return GLContext_IsInvalidAddress(addr)(addr == (void*)0 || addr == (void*)1 || addr == (void*)-1 ||
 addr == (void*)2) ? NULL((void*)0) : addr;
4728}
4729
4730cc_bool GLContext_SwapBuffers(void) {
4731	aglSwapBuffers(ctx_handle);
4732	GLContext_Check(0, "Swapping buffers");
4733	return true1;
4734}
4735
4736void GLContext_SetFpsLimit(cc_bool vsync, float minFrameMs) {
4737	int value = vsync ? 1 : 0;
4738	aglSetInteger(ctx_handle, AGL_SWAP_INTERVAL, &value);
4739}
4740void GLContext_GetApiInfo(cc_string* info) { }
4741
4742
4743/*########################################################################################################################*
4744*--------------------------------------------------------NSOpenGL---------------------------------------------------------*
4745*#########################################################################################################################*/
4746#elif defined CC_BUILD_COCOA
4747#define NSOpenGLPFADoubleBuffer 5
4748#define NSOpenGLPFAColorSize    8
4749#define NSOpenGLPFADepthSize    12
4750#define NSOpenGLPFAFullScreen   54
4751#define NSOpenGLContextParameterSwapInterval 222
4752
4753static id ctxHandle;
4754static id MakePixelFormat(struct GraphicsMode* mode, cc_bool fullscreen) {
4755	id fmt;
4756	uint32_t attribs[7] = {
4757		NSOpenGLPFAColorSize,    0,
4758		NSOpenGLPFADepthSize,    GLCONTEXT_DEFAULT_DEPTH24,
4759		NSOpenGLPFADoubleBuffer, 0, 0
4760	};
4761
4762	attribs[1] = mode->R + mode->G + mode->B + mode->A;
4763	attribs[5] = fullscreen ? NSOpenGLPFAFullScreen : 0;
4764	fmt = objc_msgSend((id)objc_getClass("NSOpenGLPixelFormat"), sel_registerName("alloc"));
4765	return objc_msgSend(fmt, sel_registerName("initWithAttributes:"), attribs);
4766}
4767
4768void GLContext_Create(void) {
4769	struct GraphicsMode mode;
4770	id view, fmt;
4771
4772	InitGraphicsMode(&mode);
4773	fmt = MakePixelFormat(&mode, true1);
4774	if (!fmt) {
4775		Platform_LogConst("Failed to create full screen pixel format.");
4776		Platform_LogConst("Trying again to create a non-fullscreen pixel format.");
4777		fmt = MakePixelFormat(&mode, false0);
4778	}
4779	if (!fmt) Logger_Abort("Choosing pixel format");
4780
4781	ctxHandle = objc_msgSend((id)objc_getClass("NSOpenGLContext"), sel_registerName("alloc"));
4782	ctxHandle = objc_msgSend(ctxHandle, sel_registerName("initWithFormat:shareContext:"), fmt, NULL((void*)0));
4783	if (!ctxHandle) Logger_Abort("Failed to create OpenGL context");
4784
4785	objc_msgSend(ctxHandle, sel_registerName("setView:"), viewHandle);
4786	objc_msgSend(fmt,       sel_registerName("release"));
4787	objc_msgSend(ctxHandle, sel_registerName("makeCurrentContext"));
4788	objc_msgSend(ctxHandle, selUpdate);
4789}
4790
4791void GLContext_Update(void) {
4792	// TODO: Why does this crash on resizing
4793	objc_msgSend(ctxHandle, selUpdate);
4794}
4795cc_bool GLContext_TryRestore(void) { return true1; }
4796
4797void GLContext_Free(void) { 
4798	objc_msgSend((id)objc_getClass("NSOpenGLContext"), sel_registerName("clearCurrentContext"));
4799	objc_msgSend(ctxHandle, sel_registerName("clearDrawable"));
4800	objc_msgSend(ctxHandle, sel_registerName("release"));
4801}
4802
4803void* GLContext_GetAddress(const char* function) {
4804	static const cc_string glPath = String_FromConst("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"){ "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
, (sizeof("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
) - 1), (sizeof("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
) - 1)};
4805	static void* lib;
4806	void* addr;
4807
4808	if (!lib) lib = DynamicLib_Load2(&glPath);
4809	addr = DynamicLib_Get2(lib, function);
4810	return GLContext_IsInvalidAddress(addr)(addr == (void*)0 || addr == (void*)1 || addr == (void*)-1 ||
 addr == (void*)2) ? NULL((void*)0) : addr;
4811}
4812
4813cc_bool GLContext_SwapBuffers(void) {
4814	objc_msgSend(ctxHandle, selFlushBuffer);
4815	return true1;
4816}
4817
4818void GLContext_SetFpsLimit(cc_bool vsync, float minFrameMs) {
4819	int value = vsync ? 1 : 0;
4820	objc_msgSend(ctxHandle, sel_registerName("setValues:forParameter:"), &value, NSOpenGLContextParameterSwapInterval);
4821}
4822void GLContext_GetApiInfo(cc_string* info) { }
4823
4824
4825/*########################################################################################################################*
4826*------------------------------------------------Emscripten WebGL context-------------------------------------------------*
4827*#########################################################################################################################*/
4828#elif defined CC_BUILD_WEB
4829#include "Graphics.h"
4830static EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx_handle;
4831
4832static EM_BOOL GLContext_OnLost(int eventType, const void *reserved, void *userData) {
4833	Gfx_LoseContext("WebGL context lost");
4834	return 1;
4835}
4836
4837void GLContext_Create(void) {
4838	EmscriptenWebGLContextAttributes attribs;
4839	emscripten_webgl_init_context_attributes(&attribs);
4840	attribs.alpha     = false0;
4841	attribs.depth     = true1;
4842	attribs.stencil   = false0;
4843	attribs.antialias = false0;
4844
4845	ctx_handle = emscripten_webgl_create_context("#canvas", &attribs);
4846	if (!ctx_handle) Window_ShowDialog("WebGL unsupported", "WebGL is required to run ClassiCube");
4847
4848	emscripten_webgl_make_context_current(ctx_handle);
4849	emscripten_set_webglcontextlost_callback("#canvas", NULL((void*)0), 0, GLContext_OnLost);
4850}
4851
4852void GLContext_Update(void) {
4853	/* TODO: do we need to do something here.... ? */
4854}
4855cc_bool GLContext_TryRestore(void) {
4856	return !emscripten_is_webgl_context_lost(0);
4857}
4858
4859void GLContext_Free(void) {
4860	emscripten_webgl_destroy_context(ctx_handle);
4861	emscripten_set_webglcontextlost_callback("#canvas", NULL((void*)0), 0, NULL((void*)0));
4862}
4863
4864void* GLContext_GetAddress(const char* function) { return NULL((void*)0); }
4865cc_bool GLContext_SwapBuffers(void) { return true1; /* Browser implicitly does this */ }
4866
4867void GLContext_SetFpsLimit(cc_bool vsync, float minFrameMs) {
4868	if (vsync) {
4869		emscripten_set_main_loop_timing(EM_TIMING_RAF, 1);
4870	} else {
4871		emscripten_set_main_loop_timing(EM_TIMING_SETTIMEOUT, (int)minFrameMs);
4872	}
4873}
4874
4875void GLContext_GetApiInfo(cc_string* info) { 
4876	char buffer[NATIVE_STR_LEN600];
4877	int len;
4878
4879	EM_ASM_({
4880		var dbg = GLctx.getExtension('WEBGL_debug_renderer_info');
4881		var str = dbg ? GLctx.getParameter(dbg.UNMASKED_RENDERER_WEBGL) : "";
4882		stringToUTF8(str, $0, $1);
4883	}, buffer, NATIVE_STR_LEN600);
4884
4885	len = String_CalcLen(buffer, NATIVE_STR_LEN600);
4886	if (!len) return;
4887	String_AppendConst(info, "GPU: ");
4888	String_AppendUtf8(info, (const cc_uint8*)buffer, len);
4889}
4890#endif
4891#endif