You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
686 lines
22 KiB
686 lines
22 KiB
//======================================================================== |
|
// GLFW 3.1 Mir - www.glfw.org |
|
//------------------------------------------------------------------------ |
|
// Copyright (c) 2014 Brandon Schaefer <brandon.schaefer@canonical.com> |
|
// |
|
// 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. |
|
// |
|
//======================================================================== |
|
|
|
#include "internal.h" |
|
|
|
#include <linux/input.h> |
|
#include <stdlib.h> |
|
#include <string.h> |
|
|
|
|
|
typedef struct EventNode |
|
{ |
|
TAILQ_ENTRY(EventNode) entries; |
|
MirEvent* event; |
|
_GLFWwindow* window; |
|
} EventNode; |
|
|
|
static void deleteNode(EventQueue* queue, EventNode* node) |
|
{ |
|
free(node->event); |
|
free(node); |
|
} |
|
|
|
static int emptyEventQueue(EventQueue* queue) |
|
{ |
|
return queue->head.tqh_first == NULL ? GL_TRUE : GL_FALSE; |
|
} |
|
|
|
static EventNode* newEventNode(MirEvent const* event, _GLFWwindow* context) |
|
{ |
|
EventNode* new_node = calloc(1, sizeof(EventNode)); |
|
new_node->event = calloc(1, sizeof(MirEvent)); |
|
new_node->window = context; |
|
|
|
memcpy(new_node->event, event, sizeof(MirEvent)); |
|
return new_node; |
|
} |
|
|
|
static void enqueueEvent(MirEvent const* event, _GLFWwindow* context) |
|
{ |
|
pthread_mutex_lock(&_glfw.mir.event_mutex); |
|
|
|
EventNode* new_node = newEventNode(event, context); |
|
TAILQ_INSERT_TAIL(&_glfw.mir.event_queue->head, new_node, entries); |
|
|
|
pthread_cond_signal(&_glfw.mir.event_cond); |
|
|
|
pthread_mutex_unlock(&_glfw.mir.event_mutex); |
|
} |
|
|
|
static EventNode* dequeueEvent(EventQueue* queue) |
|
{ |
|
EventNode* node = NULL; |
|
|
|
pthread_mutex_lock(&_glfw.mir.event_mutex); |
|
|
|
node = queue->head.tqh_first; |
|
|
|
if (node) |
|
TAILQ_REMOVE(&queue->head, node, entries); |
|
|
|
pthread_mutex_unlock(&_glfw.mir.event_mutex); |
|
|
|
return node; |
|
} |
|
|
|
static MirPixelFormat findValidPixelFormat(void) |
|
{ |
|
unsigned int i, validFormats, mirPixelFormats = 32; |
|
MirPixelFormat formats[mir_pixel_formats]; |
|
|
|
mir_connection_get_available_surface_formats(_glfw.mir.connection, formats, |
|
mirPixelFormats, &validFormats); |
|
|
|
for (i = 0; i < validFormats; i++) |
|
{ |
|
if (formats[i] == mir_pixel_format_abgr_8888 || |
|
formats[i] == mir_pixel_format_xbgr_8888 || |
|
formats[i] == mir_pixel_format_argb_8888 || |
|
formats[i] == mir_pixel_format_xrgb_8888) |
|
{ |
|
return formats[i]; |
|
} |
|
} |
|
|
|
return mir_pixel_format_invalid; |
|
} |
|
|
|
static int mirModToGLFWMod(uint32_t mods) |
|
{ |
|
int publicMods = 0x0; |
|
|
|
if (mods & mir_key_modifier_alt) |
|
publicMods |= GLFW_MOD_ALT; |
|
else if (mods & mir_key_modifier_shift) |
|
publicMods |= GLFW_MOD_SHIFT; |
|
else if (mods & mir_key_modifier_ctrl) |
|
publicMods |= GLFW_MOD_CONTROL; |
|
else if (mods & mir_key_modifier_meta) |
|
publicMods |= GLFW_MOD_SUPER; |
|
|
|
return publicMods; |
|
} |
|
|
|
// Taken from wl_init.c |
|
static int toGLFWKeyCode(uint32_t key) |
|
{ |
|
switch (key) |
|
{ |
|
case KEY_GRAVE: return GLFW_KEY_GRAVE_ACCENT; |
|
case KEY_1: return GLFW_KEY_1; |
|
case KEY_2: return GLFW_KEY_2; |
|
case KEY_3: return GLFW_KEY_3; |
|
case KEY_4: return GLFW_KEY_4; |
|
case KEY_5: return GLFW_KEY_5; |
|
case KEY_6: return GLFW_KEY_6; |
|
case KEY_7: return GLFW_KEY_7; |
|
case KEY_8: return GLFW_KEY_8; |
|
case KEY_9: return GLFW_KEY_9; |
|
case KEY_0: return GLFW_KEY_0; |
|
case KEY_MINUS: return GLFW_KEY_MINUS; |
|
case KEY_EQUAL: return GLFW_KEY_EQUAL; |
|
case KEY_Q: return GLFW_KEY_Q; |
|
case KEY_W: return GLFW_KEY_W; |
|
case KEY_E: return GLFW_KEY_E; |
|
case KEY_R: return GLFW_KEY_R; |
|
case KEY_T: return GLFW_KEY_T; |
|
case KEY_Y: return GLFW_KEY_Y; |
|
case KEY_U: return GLFW_KEY_U; |
|
case KEY_I: return GLFW_KEY_I; |
|
case KEY_O: return GLFW_KEY_O; |
|
case KEY_P: return GLFW_KEY_P; |
|
case KEY_LEFTBRACE: return GLFW_KEY_LEFT_BRACKET; |
|
case KEY_RIGHTBRACE: return GLFW_KEY_RIGHT_BRACKET; |
|
case KEY_A: return GLFW_KEY_A; |
|
case KEY_S: return GLFW_KEY_S; |
|
case KEY_D: return GLFW_KEY_D; |
|
case KEY_F: return GLFW_KEY_F; |
|
case KEY_G: return GLFW_KEY_G; |
|
case KEY_H: return GLFW_KEY_H; |
|
case KEY_J: return GLFW_KEY_J; |
|
case KEY_K: return GLFW_KEY_K; |
|
case KEY_L: return GLFW_KEY_L; |
|
case KEY_SEMICOLON: return GLFW_KEY_SEMICOLON; |
|
case KEY_APOSTROPHE: return GLFW_KEY_APOSTROPHE; |
|
case KEY_Z: return GLFW_KEY_Z; |
|
case KEY_X: return GLFW_KEY_X; |
|
case KEY_C: return GLFW_KEY_C; |
|
case KEY_V: return GLFW_KEY_V; |
|
case KEY_B: return GLFW_KEY_B; |
|
case KEY_N: return GLFW_KEY_N; |
|
case KEY_M: return GLFW_KEY_M; |
|
case KEY_COMMA: return GLFW_KEY_COMMA; |
|
case KEY_DOT: return GLFW_KEY_PERIOD; |
|
case KEY_SLASH: return GLFW_KEY_SLASH; |
|
case KEY_BACKSLASH: return GLFW_KEY_BACKSLASH; |
|
case KEY_ESC: return GLFW_KEY_ESCAPE; |
|
case KEY_TAB: return GLFW_KEY_TAB; |
|
case KEY_LEFTSHIFT: return GLFW_KEY_LEFT_SHIFT; |
|
case KEY_RIGHTSHIFT: return GLFW_KEY_RIGHT_SHIFT; |
|
case KEY_LEFTCTRL: return GLFW_KEY_LEFT_CONTROL; |
|
case KEY_RIGHTCTRL: return GLFW_KEY_RIGHT_CONTROL; |
|
case KEY_LEFTALT: return GLFW_KEY_LEFT_ALT; |
|
case KEY_RIGHTALT: return GLFW_KEY_RIGHT_ALT; |
|
case KEY_LEFTMETA: return GLFW_KEY_LEFT_SUPER; |
|
case KEY_RIGHTMETA: return GLFW_KEY_RIGHT_SUPER; |
|
case KEY_MENU: return GLFW_KEY_MENU; |
|
case KEY_NUMLOCK: return GLFW_KEY_NUM_LOCK; |
|
case KEY_CAPSLOCK: return GLFW_KEY_CAPS_LOCK; |
|
case KEY_PRINT: return GLFW_KEY_PRINT_SCREEN; |
|
case KEY_SCROLLLOCK: return GLFW_KEY_SCROLL_LOCK; |
|
case KEY_PAUSE: return GLFW_KEY_PAUSE; |
|
case KEY_DELETE: return GLFW_KEY_DELETE; |
|
case KEY_BACKSPACE: return GLFW_KEY_BACKSPACE; |
|
case KEY_ENTER: return GLFW_KEY_ENTER; |
|
case KEY_HOME: return GLFW_KEY_HOME; |
|
case KEY_END: return GLFW_KEY_END; |
|
case KEY_PAGEUP: return GLFW_KEY_PAGE_UP; |
|
case KEY_PAGEDOWN: return GLFW_KEY_PAGE_DOWN; |
|
case KEY_INSERT: return GLFW_KEY_INSERT; |
|
case KEY_LEFT: return GLFW_KEY_LEFT; |
|
case KEY_RIGHT: return GLFW_KEY_RIGHT; |
|
case KEY_DOWN: return GLFW_KEY_DOWN; |
|
case KEY_UP: return GLFW_KEY_UP; |
|
case KEY_F1: return GLFW_KEY_F1; |
|
case KEY_F2: return GLFW_KEY_F2; |
|
case KEY_F3: return GLFW_KEY_F3; |
|
case KEY_F4: return GLFW_KEY_F4; |
|
case KEY_F5: return GLFW_KEY_F5; |
|
case KEY_F6: return GLFW_KEY_F6; |
|
case KEY_F7: return GLFW_KEY_F7; |
|
case KEY_F8: return GLFW_KEY_F8; |
|
case KEY_F9: return GLFW_KEY_F9; |
|
case KEY_F10: return GLFW_KEY_F10; |
|
case KEY_F11: return GLFW_KEY_F11; |
|
case KEY_F12: return GLFW_KEY_F12; |
|
case KEY_F13: return GLFW_KEY_F13; |
|
case KEY_F14: return GLFW_KEY_F14; |
|
case KEY_F15: return GLFW_KEY_F15; |
|
case KEY_F16: return GLFW_KEY_F16; |
|
case KEY_F17: return GLFW_KEY_F17; |
|
case KEY_F18: return GLFW_KEY_F18; |
|
case KEY_F19: return GLFW_KEY_F19; |
|
case KEY_F20: return GLFW_KEY_F20; |
|
case KEY_F21: return GLFW_KEY_F21; |
|
case KEY_F22: return GLFW_KEY_F22; |
|
case KEY_F23: return GLFW_KEY_F23; |
|
case KEY_F24: return GLFW_KEY_F24; |
|
case KEY_KPSLASH: return GLFW_KEY_KP_DIVIDE; |
|
case KEY_KPDOT: return GLFW_KEY_KP_MULTIPLY; |
|
case KEY_KPMINUS: return GLFW_KEY_KP_SUBTRACT; |
|
case KEY_KPPLUS: return GLFW_KEY_KP_ADD; |
|
case KEY_KP0: return GLFW_KEY_KP_0; |
|
case KEY_KP1: return GLFW_KEY_KP_1; |
|
case KEY_KP2: return GLFW_KEY_KP_2; |
|
case KEY_KP3: return GLFW_KEY_KP_3; |
|
case KEY_KP4: return GLFW_KEY_KP_4; |
|
case KEY_KP5: return GLFW_KEY_KP_5; |
|
case KEY_KP6: return GLFW_KEY_KP_6; |
|
case KEY_KP7: return GLFW_KEY_KP_7; |
|
case KEY_KP8: return GLFW_KEY_KP_8; |
|
case KEY_KP9: return GLFW_KEY_KP_9; |
|
case KEY_KPCOMMA: return GLFW_KEY_KP_DECIMAL; |
|
case KEY_KPEQUAL: return GLFW_KEY_KP_EQUAL; |
|
case KEY_KPENTER: return GLFW_KEY_KP_ENTER; |
|
default: return GLFW_KEY_UNKNOWN; |
|
} |
|
} |
|
|
|
static void handleKeyEvent(const MirKeyEvent key, _GLFWwindow* window) |
|
{ |
|
const int pressed = key.action == mir_key_action_up ? GLFW_RELEASE : GLFW_PRESS; |
|
const int mods = mirModToGLFWMod(key.modifiers); |
|
const long text = _glfwKeySym2Unicode(key.key_code); |
|
const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT)); |
|
|
|
_glfwInputKey(window, toGLFWKeyCode(key.scan_code), key.scan_code, pressed, mods); |
|
|
|
if (text != -1) |
|
_glfwInputChar(window, text, mods, plain); |
|
} |
|
|
|
static void handleMouseButton(_GLFWwindow* window, |
|
int pressed, int mods, MirMotionButton button) |
|
{ |
|
static int lastButton; |
|
int publicButton; |
|
const int publicMods = mirModToGLFWMod(mods); |
|
|
|
switch (button) |
|
{ |
|
case mir_motion_button_primary: |
|
publicButton = GLFW_MOUSE_BUTTON_LEFT; |
|
break; |
|
case mir_motion_button_secondary: |
|
publicButton = GLFW_MOUSE_BUTTON_RIGHT; |
|
break; |
|
case mir_motion_button_tertiary: |
|
publicButton = GLFW_MOUSE_BUTTON_MIDDLE; |
|
break; |
|
case mir_motion_button_forward: |
|
// FIXME What is the forward button? |
|
publicButton = GLFW_MOUSE_BUTTON_4; |
|
break; |
|
case mir_motion_button_back: |
|
// FIXME What is the back button? |
|
publicButton = GLFW_MOUSE_BUTTON_5; |
|
break; |
|
default: |
|
publicButton = lastButton; |
|
break; |
|
} |
|
|
|
lastButton = publicButton; |
|
|
|
_glfwInputMouseClick(window, publicButton, pressed, publicMods); |
|
} |
|
|
|
static void handleMouseMotion(_GLFWwindow* window, int x, int y) |
|
{ |
|
_glfwInputCursorMotion(window, x, y); |
|
} |
|
|
|
static void handleMouseScroll(_GLFWwindow* window, int dx, int dy) |
|
{ |
|
_glfwInputScroll(window, dx, dy); |
|
} |
|
|
|
static void handleMouseEvent(const MirMotionEvent motion, |
|
int cord_index, |
|
_GLFWwindow* window) |
|
{ |
|
switch (motion.action) |
|
{ |
|
case mir_motion_action_down: |
|
case mir_motion_action_pointer_down: |
|
handleMouseButton(window, GLFW_PRESS, |
|
motion.modifiers, motion.button_state); |
|
break; |
|
case mir_motion_action_up: |
|
case mir_motion_action_pointer_up: |
|
handleMouseButton(window, GLFW_RELEASE, |
|
motion.modifiers, motion.button_state); |
|
break; |
|
case mir_motion_action_hover_move: |
|
case mir_motion_action_move: |
|
handleMouseMotion(window, |
|
motion.pointer_coordinates[cord_index].x, |
|
motion.pointer_coordinates[cord_index].y); |
|
break; |
|
case mir_motion_action_outside: |
|
break; |
|
case mir_motion_action_scroll: |
|
handleMouseScroll(window, |
|
motion.pointer_coordinates[cord_index].hscroll, |
|
motion.pointer_coordinates[cord_index].vscroll); |
|
break; |
|
case mir_motion_action_cancel: |
|
case mir_motion_action_hover_enter: |
|
case mir_motion_action_hover_exit: |
|
break; |
|
default: |
|
break; |
|
|
|
} |
|
} |
|
|
|
static void handleMotionEvent(const MirMotionEvent motion, _GLFWwindow* window) |
|
{ |
|
int i; |
|
for (i = 0; i < motion.pointer_count; i++) |
|
handleMouseEvent(motion, i, window); |
|
} |
|
|
|
static void handleInput(MirEvent const* event, _GLFWwindow* window) |
|
{ |
|
switch (event->type) |
|
{ |
|
case mir_event_type_key: |
|
handleKeyEvent(event->key, window); |
|
break; |
|
case mir_event_type_motion: |
|
handleMotionEvent(event->motion, window); |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
|
|
static void addNewEvent(MirSurface* surface, MirEvent const* event, void* context) |
|
{ |
|
enqueueEvent(event, context); |
|
} |
|
|
|
static int createSurface(_GLFWwindow* window) |
|
{ |
|
MirSurfaceParameters params = |
|
{ |
|
.name = "MirSurface", |
|
.width = window->mir.width, |
|
.height = window->mir.height, |
|
.pixel_format = mir_pixel_format_invalid, |
|
.buffer_usage = mir_buffer_usage_hardware, |
|
.output_id = mir_display_output_id_invalid |
|
}; |
|
|
|
MirEventDelegate delegate = |
|
{ |
|
addNewEvent, |
|
window |
|
}; |
|
|
|
params.pixel_format = findValidPixelFormat(); |
|
if (params.pixel_format == mir_pixel_format_invalid) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unable to find a correct pixel format"); |
|
return GL_FALSE; |
|
} |
|
|
|
window->mir.surface = |
|
mir_connection_create_surface_sync(_glfw.mir.connection, ¶ms); |
|
if (!mir_surface_is_valid(window->mir.surface)) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unable to create surface: %s", |
|
mir_surface_get_error_message(window->mir.surface)); |
|
|
|
return GL_FALSE; |
|
} |
|
|
|
mir_surface_set_event_handler(window->mir.surface, &delegate); |
|
|
|
return GL_TRUE; |
|
} |
|
|
|
////////////////////////////////////////////////////////////////////////// |
|
////// GLFW internal API ////// |
|
////////////////////////////////////////////////////////////////////////// |
|
|
|
void _glfwInitEventQueue(EventQueue* queue) |
|
{ |
|
TAILQ_INIT(&queue->head); |
|
} |
|
|
|
void _glfwDeleteEventQueue(EventQueue* queue) |
|
{ |
|
if (queue) |
|
{ |
|
EventNode* node, *node_next; |
|
node = queue->head.tqh_first; |
|
|
|
while (node != NULL) |
|
{ |
|
node_next = node->entries.tqe_next; |
|
|
|
TAILQ_REMOVE(&queue->head, node, entries); |
|
deleteNode(queue, node); |
|
|
|
node = node_next; |
|
} |
|
|
|
free(queue); |
|
} |
|
} |
|
|
|
////////////////////////////////////////////////////////////////////////// |
|
////// GLFW platform API ////// |
|
////////////////////////////////////////////////////////////////////////// |
|
|
|
int _glfwPlatformCreateWindow(_GLFWwindow* window, |
|
const _GLFWwndconfig* wndconfig, |
|
const _GLFWctxconfig* ctxconfig, |
|
const _GLFWfbconfig* fbconfig) |
|
{ |
|
if (!_glfwCreateContext(window, ctxconfig, fbconfig)) |
|
return GL_FALSE; |
|
|
|
if (wndconfig->monitor) |
|
{ |
|
GLFWvidmode mode; |
|
_glfwPlatformGetVideoMode(wndconfig->monitor, &mode); |
|
|
|
mir_surface_set_state(window->mir.surface, mir_surface_state_fullscreen); |
|
|
|
if (wndconfig->width > mode.width || wndconfig->height > mode.height) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Requested surface size too large: %ix%i", |
|
wndconfig->width, wndconfig->height); |
|
|
|
return GL_FALSE; |
|
} |
|
} |
|
|
|
window->mir.width = wndconfig->width; |
|
window->mir.height = wndconfig->height; |
|
|
|
if (!createSurface(window)) |
|
return GL_FALSE; |
|
|
|
window->mir.window = mir_surface_get_egl_native_window(window->mir.surface); |
|
|
|
return GL_TRUE; |
|
} |
|
|
|
void _glfwPlatformDestroyWindow(_GLFWwindow* window) |
|
{ |
|
if (mir_surface_is_valid(window->mir.surface)) |
|
{ |
|
mir_surface_release_sync(window->mir.surface); |
|
window->mir.surface = NULL; |
|
} |
|
|
|
_glfwDestroyContext(window); |
|
} |
|
|
|
void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window, |
|
int* left, int* top, |
|
int* right, int* bottom) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height) |
|
{ |
|
if (width) |
|
*width = window->mir.width; |
|
if (height) |
|
*height = window->mir.height; |
|
} |
|
|
|
void _glfwPlatformIconifyWindow(_GLFWwindow* window) |
|
{ |
|
mir_surface_set_state(window->mir.surface, mir_surface_state_minimized); |
|
} |
|
|
|
void _glfwPlatformRestoreWindow(_GLFWwindow* window) |
|
{ |
|
mir_surface_set_state(window->mir.surface, mir_surface_state_restored); |
|
} |
|
|
|
void _glfwPlatformHideWindow(_GLFWwindow* window) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformShowWindow(_GLFWwindow* window) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformUnhideWindow(_GLFWwindow* window) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
int _glfwPlatformWindowFocused(_GLFWwindow* window) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
return GL_FALSE; |
|
} |
|
|
|
int _glfwPlatformWindowIconified(_GLFWwindow* window) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
return GL_FALSE; |
|
} |
|
|
|
int _glfwPlatformWindowVisible(_GLFWwindow* window) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
return GL_FALSE; |
|
} |
|
|
|
void _glfwPlatformPollEvents(void) |
|
{ |
|
EventNode* node = NULL; |
|
|
|
while ((node = dequeueEvent(_glfw.mir.event_queue))) |
|
{ |
|
handleInput(node->event, node->window); |
|
deleteNode(_glfw.mir.event_queue, node); |
|
} |
|
} |
|
|
|
void _glfwPlatformWaitEvents(void) |
|
{ |
|
pthread_mutex_lock(&_glfw.mir.event_mutex); |
|
|
|
if (emptyEventQueue(_glfw.mir.event_queue)) |
|
pthread_cond_wait(&_glfw.mir.event_cond, &_glfw.mir.event_mutex); |
|
|
|
pthread_mutex_unlock(&_glfw.mir.event_mutex); |
|
|
|
_glfwPlatformPollEvents(); |
|
} |
|
|
|
void _glfwPlatformPostEmptyEvent(void) |
|
{ |
|
} |
|
|
|
void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height) |
|
{ |
|
if (width) |
|
*width = window->mir.width; |
|
if (height) |
|
*height = window->mir.height; |
|
} |
|
|
|
int _glfwPlatformCreateCursor(_GLFWcursor* cursor, |
|
const GLFWimage* image, |
|
int xhot, int yhot) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
|
|
return GL_FALSE; |
|
} |
|
|
|
int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
|
|
return GL_FALSE; |
|
} |
|
|
|
void _glfwPlatformDestroyCursor(_GLFWcursor* cursor) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformApplyCursorMode(_GLFWwindow* window) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
} |
|
|
|
const char* _glfwPlatformGetClipboardString(_GLFWwindow* window) |
|
{ |
|
_glfwInputError(GLFW_PLATFORM_ERROR, |
|
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
|
|
|
return NULL; |
|
} |
|
|
|
|