--- /dev/null
+//========================================================================
+// GLFW 3.4 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2016-2019 Camilla Löwy <elmindreda@glfw.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+// claim that you wrote the original software. If you use this software
+// in a product, an acknowledgment in the product documentation would
+// be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+// be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+// distribution.
+//
+//========================================================================
+// It is fine to use C99 in this file because it will not be built with VS
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+
+static void applySizeLimits(_GLFWwindow* window, int* width, int* height)
+{
+ if (window->numer != GLFW_DONT_CARE && window->denom != GLFW_DONT_CARE)
+ {
+ const float ratio = (float) window->numer / (float) window->denom;
+ *height = (int) (*width / ratio);
+ }
+
+ if (window->minwidth != GLFW_DONT_CARE && *width < window->minwidth)
+ *width = window->minwidth;
+ else if (window->maxwidth != GLFW_DONT_CARE && *width > window->maxwidth)
+ *width = window->maxwidth;
+
+ if (window->minheight != GLFW_DONT_CARE && *height < window->minheight)
+ *height = window->minheight;
+ else if (window->maxheight != GLFW_DONT_CARE && *height > window->maxheight)
+ *height = window->maxheight;
+}
+
+static void fitToMonitor(_GLFWwindow* window)
+{
+ GLFWvidmode mode;
+ _glfwPlatformGetVideoMode(window->monitor, &mode);
+ _glfwPlatformGetMonitorPos(window->monitor,
+ &window->null.xpos,
+ &window->null.ypos);
+ window->null.width = mode.width;
+ window->null.height = mode.height;
+}
+
+static void acquireMonitor(_GLFWwindow* window)
+{
+ _glfwInputMonitorWindow(window->monitor, window);
+}
+
+static void releaseMonitor(_GLFWwindow* window)
+{
+ if (window->monitor->window != window)
+ return;
+
+ _glfwInputMonitorWindow(window->monitor, NULL);
+}
+
+static int createNativeWindow(_GLFWwindow* window,
+ const _GLFWwndconfig* wndconfig,
+ const _GLFWfbconfig* fbconfig)
+{
+ if (window->monitor)
+ fitToMonitor(window);
+ else
+ {
+ window->null.xpos = 17;
+ window->null.ypos = 17;
+ window->null.width = wndconfig->width;
+ window->null.height = wndconfig->height;
+ }
+
+ window->null.visible = wndconfig->visible;
+ window->null.decorated = wndconfig->decorated;
+ window->null.maximized = wndconfig->maximized;
+ window->null.floating = wndconfig->floating;
+ window->null.transparent = fbconfig->transparent;
+ window->null.opacity = 1.f;
+
+ return GLFW_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+////// GLFW platform API //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformCreateWindow(_GLFWwindow* window,
+ const _GLFWwndconfig* wndconfig,
+ const _GLFWctxconfig* ctxconfig,
+ const _GLFWfbconfig* fbconfig)
+{
+ if (!createNativeWindow(window, wndconfig, fbconfig))
+ return GLFW_FALSE;
+
+ if (ctxconfig->client != GLFW_NO_API)
+ {
+ if (ctxconfig->source == GLFW_NATIVE_CONTEXT_API ||
+ ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
+ {
+ if (!_glfwInitOSMesa())
+ return GLFW_FALSE;
+ if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
+ return GLFW_FALSE;
+ }
+ else
+ {
+ _glfwInputError(GLFW_API_UNAVAILABLE, "Null: EGL not available");
+ return GLFW_FALSE;
+ }
+ }
+
+ if (window->monitor)
+ {
+ _glfwPlatformShowWindow(window);
+ _glfwPlatformFocusWindow(window);
+ acquireMonitor(window);
+ }
+
+ return GLFW_TRUE;
+}
+
+void _glfwPlatformDestroyWindow(_GLFWwindow* window)
+{
+ if (window->monitor)
+ releaseMonitor(window);
+
+ if (_glfw.null.focusedWindow == window)
+ _glfw.null.focusedWindow = NULL;
+
+ if (window->context.destroy)
+ window->context.destroy(window);
+}
+
+void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
+{
+}
+
+void _glfwPlatformSetWindowIcon(_GLFWwindow* window, int count,
+ const GLFWimage* images)
+{
+}
+
+void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
+ _GLFWmonitor* monitor,
+ int xpos, int ypos,
+ int width, int height,
+ int refreshRate)
+{
+ if (window->monitor == monitor)
+ {
+ if (!monitor)
+ {
+ _glfwPlatformSetWindowPos(window, xpos, ypos);
+ _glfwPlatformSetWindowSize(window, width, height);
+ }
+
+ return;
+ }
+
+ if (window->monitor)
+ releaseMonitor(window);
+
+ _glfwInputWindowMonitor(window, monitor);
+
+ if (window->monitor)
+ {
+ window->null.visible = GLFW_TRUE;
+ acquireMonitor(window);
+ fitToMonitor(window);
+ }
+ else
+ {
+ _glfwPlatformSetWindowPos(window, xpos, ypos);
+ _glfwPlatformSetWindowSize(window, width, height);
+ }
+}
+
+void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos)
+{
+ if (xpos)
+ *xpos = window->null.xpos;
+ if (ypos)
+ *ypos = window->null.ypos;
+}
+
+void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos)
+{
+ if (window->monitor)
+ return;
+
+ if (window->null.xpos != xpos || window->null.ypos != ypos)
+ {
+ window->null.xpos = xpos;
+ window->null.ypos = ypos;
+ _glfwInputWindowPos(window, xpos, ypos);
+ }
+}
+
+void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)
+{
+ if (width)
+ *width = window->null.width;
+ if (height)
+ *height = window->null.height;
+}
+
+void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
+{
+ if (window->monitor)
+ return;
+
+ if (window->null.width != width || window->null.height != height)
+ {
+ window->null.width = width;
+ window->null.height = height;
+ _glfwInputWindowSize(window, width, height);
+ _glfwInputFramebufferSize(window, width, height);
+ }
+}
+
+void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
+ int minwidth, int minheight,
+ int maxwidth, int maxheight)
+{
+ int width = window->null.width;
+ int height = window->null.height;
+ applySizeLimits(window, &width, &height);
+ _glfwPlatformSetWindowSize(window, width, height);
+}
+
+void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int n, int d)
+{
+ int width = window->null.width;
+ int height = window->null.height;
+ applySizeLimits(window, &width, &height);
+ _glfwPlatformSetWindowSize(window, width, height);
+}
+
+void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height)
+{
+ if (width)
+ *width = window->null.width;
+ if (height)
+ *height = window->null.height;
+}
+
+void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
+ int* left, int* top,
+ int* right, int* bottom)
+{
+ if (window->null.decorated && !window->monitor)
+ {
+ if (left)
+ *left = 1;
+ if (top)
+ *top = 10;
+ if (right)
+ *right = 1;
+ if (bottom)
+ *bottom = 1;
+ }
+ else
+ {
+ if (left)
+ *left = 0;
+ if (top)
+ *top = 0;
+ if (right)
+ *right = 0;
+ if (bottom)
+ *bottom = 0;
+ }
+}
+
+void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
+ float* xscale, float* yscale)
+{
+ if (xscale)
+ *xscale = 1.f;
+ if (yscale)
+ *yscale = 1.f;
+}
+
+void _glfwPlatformIconifyWindow(_GLFWwindow* window)
+{
+ if (_glfw.null.focusedWindow == window)
+ {
+ _glfw.null.focusedWindow = NULL;
+ _glfwInputWindowFocus(window, GLFW_FALSE);
+ }
+
+ if (!window->null.iconified)
+ {
+ window->null.iconified = GLFW_TRUE;
+ _glfwInputWindowIconify(window, GLFW_TRUE);
+
+ if (window->monitor)
+ releaseMonitor(window);
+ }
+}
+
+void _glfwPlatformRestoreWindow(_GLFWwindow* window)
+{
+ if (window->null.iconified)
+ {
+ window->null.iconified = GLFW_FALSE;
+ _glfwInputWindowIconify(window, GLFW_FALSE);
+
+ if (window->monitor)
+ acquireMonitor(window);
+ }
+ else if (window->null.maximized)
+ {
+ window->null.maximized = GLFW_FALSE;
+ _glfwInputWindowMaximize(window, GLFW_FALSE);
+ }
+}
+
+void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
+{
+ if (!window->null.maximized)
+ {
+ window->null.maximized = GLFW_TRUE;
+ _glfwInputWindowMaximize(window, GLFW_TRUE);
+ }
+}
+
+int _glfwPlatformWindowMaximized(_GLFWwindow* window)
+{
+ return window->null.maximized;
+}
+
+int _glfwPlatformWindowHovered(_GLFWwindow* window)
+{
+ return _glfw.null.xcursor >= window->null.xpos &&
+ _glfw.null.ycursor >= window->null.ypos &&
+ _glfw.null.xcursor <= window->null.xpos + window->null.width - 1 &&
+ _glfw.null.ycursor <= window->null.ypos + window->null.height - 1;
+}
+
+int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
+{
+ return window->null.transparent;
+}
+
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+ window->null.resizable = enabled;
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+ window->null.decorated = enabled;
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+{
+ window->null.floating = enabled;
+}
+
+void _glfwPlatformSetWindowMousePassthrough(_GLFWwindow* window, GLFWbool enabled)
+{
+}
+
+float _glfwPlatformGetWindowOpacity(_GLFWwindow* window)
+{
+ return window->null.opacity;
+}
+
+void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity)
+{
+ window->null.opacity = opacity;
+}
+
+void _glfwPlatformSetRawMouseMotion(_GLFWwindow *window, GLFWbool enabled)
+{
+}
+
+GLFWbool _glfwPlatformRawMouseMotionSupported(void)
+{
+ return GLFW_TRUE;
+}
+
+void _glfwPlatformShowWindow(_GLFWwindow* window)
+{
+ window->null.visible = GLFW_TRUE;
+}
+
+void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformHideWindow(_GLFWwindow* window)
+{
+ if (_glfw.null.focusedWindow == window)
+ {
+ _glfw.null.focusedWindow = NULL;
+ _glfwInputWindowFocus(window, GLFW_FALSE);
+ }
+
+ window->null.visible = GLFW_FALSE;
+}
+
+void _glfwPlatformFocusWindow(_GLFWwindow* window)
+{
+ if (_glfw.null.focusedWindow == window)
+ return;
+
+ if (!window->null.visible)
+ return;
+
+ _GLFWwindow* previous = _glfw.null.focusedWindow;
+ _glfw.null.focusedWindow = window;
+
+ if (previous)
+ {
+ _glfwInputWindowFocus(previous, GLFW_FALSE);
+ if (previous->monitor && previous->autoIconify)
+ _glfwPlatformIconifyWindow(previous);
+ }
+
+ _glfwInputWindowFocus(window, GLFW_TRUE);
+}
+
+int _glfwPlatformWindowFocused(_GLFWwindow* window)
+{
+ return _glfw.null.focusedWindow == window;
+}
+
+int _glfwPlatformWindowIconified(_GLFWwindow* window)
+{
+ return window->null.iconified;
+}
+
+int _glfwPlatformWindowVisible(_GLFWwindow* window)
+{
+ return window->null.visible;
+}
+
+void _glfwPlatformPollEvents(void)
+{
+}
+
+void _glfwPlatformWaitEvents(void)
+{
+}
+
+void _glfwPlatformWaitEventsTimeout(double timeout)
+{
+}
+
+void _glfwPlatformPostEmptyEvent(void)
+{
+}
+
+void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos)
+{
+ if (xpos)
+ *xpos = _glfw.null.xcursor - window->null.xpos;
+ if (ypos)
+ *ypos = _glfw.null.ycursor - window->null.ypos;
+}
+
+void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
+{
+ _glfw.null.xcursor = window->null.xpos + (int) x;
+ _glfw.null.ycursor = window->null.ypos + (int) y;
+}
+
+void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
+{
+}
+
+int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
+ const GLFWimage* image,
+ int xhot, int yhot)
+{
+ return GLFW_TRUE;
+}
+
+int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
+{
+ return GLFW_TRUE;
+}
+
+void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
+{
+}
+
+void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
+{
+}
+
+void _glfwPlatformSetClipboardString(const char* string)
+{
+ char* copy = _glfw_strdup(string);
+ free(_glfw.null.clipboardString);
+ _glfw.null.clipboardString = copy;
+}
+
+const char* _glfwPlatformGetClipboardString(void)
+{
+ return _glfw.null.clipboardString;
+}
+
+const char* _glfwPlatformGetScancodeName(int scancode)
+{
+ switch (scancode)
+ {
+ case GLFW_KEY_APOSTROPHE:
+ return "'";
+ case GLFW_KEY_COMMA:
+ return ",";
+ case GLFW_KEY_MINUS:
+ case GLFW_KEY_KP_SUBTRACT:
+ return "-";
+ case GLFW_KEY_PERIOD:
+ case GLFW_KEY_KP_DECIMAL:
+ return ".";
+ case GLFW_KEY_SLASH:
+ case GLFW_KEY_KP_DIVIDE:
+ return "/";
+ case GLFW_KEY_SEMICOLON:
+ return ";";
+ case GLFW_KEY_EQUAL:
+ case GLFW_KEY_KP_EQUAL:
+ return "=";
+ case GLFW_KEY_LEFT_BRACKET:
+ return "[";
+ case GLFW_KEY_RIGHT_BRACKET:
+ return "]";
+ case GLFW_KEY_KP_MULTIPLY:
+ return "*";
+ case GLFW_KEY_KP_ADD:
+ return "+";
+ case GLFW_KEY_BACKSLASH:
+ case GLFW_KEY_WORLD_1:
+ case GLFW_KEY_WORLD_2:
+ return "\\";
+ case GLFW_KEY_0:
+ case GLFW_KEY_KP_0:
+ return "0";
+ case GLFW_KEY_1:
+ case GLFW_KEY_KP_1:
+ return "1";
+ case GLFW_KEY_2:
+ case GLFW_KEY_KP_2:
+ return "2";
+ case GLFW_KEY_3:
+ case GLFW_KEY_KP_3:
+ return "3";
+ case GLFW_KEY_4:
+ case GLFW_KEY_KP_4:
+ return "4";
+ case GLFW_KEY_5:
+ case GLFW_KEY_KP_5:
+ return "5";
+ case GLFW_KEY_6:
+ case GLFW_KEY_KP_6:
+ return "6";
+ case GLFW_KEY_7:
+ case GLFW_KEY_KP_7:
+ return "7";
+ case GLFW_KEY_8:
+ case GLFW_KEY_KP_8:
+ return "8";
+ case GLFW_KEY_9:
+ case GLFW_KEY_KP_9:
+ return "9";
+ case GLFW_KEY_A:
+ return "a";
+ case GLFW_KEY_B:
+ return "b";
+ case GLFW_KEY_C:
+ return "c";
+ case GLFW_KEY_D:
+ return "d";
+ case GLFW_KEY_E:
+ return "e";
+ case GLFW_KEY_F:
+ return "f";
+ case GLFW_KEY_G:
+ return "g";
+ case GLFW_KEY_H:
+ return "h";
+ case GLFW_KEY_I:
+ return "i";
+ case GLFW_KEY_J:
+ return "j";
+ case GLFW_KEY_K:
+ return "k";
+ case GLFW_KEY_L:
+ return "l";
+ case GLFW_KEY_M:
+ return "m";
+ case GLFW_KEY_N:
+ return "n";
+ case GLFW_KEY_O:
+ return "o";
+ case GLFW_KEY_P:
+ return "p";
+ case GLFW_KEY_Q:
+ return "q";
+ case GLFW_KEY_R:
+ return "r";
+ case GLFW_KEY_S:
+ return "s";
+ case GLFW_KEY_T:
+ return "t";
+ case GLFW_KEY_U:
+ return "u";
+ case GLFW_KEY_V:
+ return "v";
+ case GLFW_KEY_W:
+ return "w";
+ case GLFW_KEY_X:
+ return "x";
+ case GLFW_KEY_Y:
+ return "y";
+ case GLFW_KEY_Z:
+ return "z";
+ }
+
+ return NULL;
+}
+
+int _glfwPlatformGetKeyScancode(int key)
+{
+ return key;
+}
+
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
+{
+}
+
+int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
+ VkPhysicalDevice device,
+ uint32_t queuefamily)
+{
+ return GLFW_FALSE;
+}
+
+VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
+ _GLFWwindow* window,
+ const VkAllocationCallbacks* allocator,
+ VkSurfaceKHR* surface)
+{
+ // This seems like the most appropriate error to return here
+ return VK_ERROR_EXTENSION_NOT_PRESENT;
+}
+
projects / pistorm / blobdiff