As of the release of Mir 1.0, libmirclient has been deprecated[1] and its developers recommend clients using it to switch to Wayland. This patch removes support for libmirclient and instruct users to use the experimental Wayland backend instead. [1] https://discourse.ubuntu.com/t/mir-news-28th-september-2018/8184master
Emmanuel Gil Peyrot
ago%!(EXTRA string=7 years)
committed by
linkmauve
parent
e75af5f531
commit
cc805c0963
19 changed files with 11 additions and 1704 deletions
@ -1,34 +0,0 @@ |
||||
# FindMir |
||||
# ------- |
||||
# Finds the Mir library |
||||
# |
||||
# This will will define the following variables:: |
||||
# |
||||
# MIR_FOUND - the system has Mir |
||||
# MIR_INCLUDE_DIRS - the Mir include directory |
||||
# MIR_LIBRARIES - the Mir libraries |
||||
# MIR_DEFINITIONS - the Mir definitions |
||||
|
||||
|
||||
find_package (PkgConfig) |
||||
if(PKG_CONFIG_FOUND) |
||||
pkg_check_modules (PC_MIR mirclient>=0.26.2 QUIET) |
||||
|
||||
find_path(MIR_INCLUDE_DIR NAMES mir_toolkit/mir_client_library.h |
||||
PATHS ${PC_MIR_INCLUDE_DIRS}) |
||||
|
||||
find_library(MIR_LIBRARY NAMES mirclient |
||||
PATHS ${PC_MIR_LIBRARIES} ${PC_MIR_LIBRARY_DIRS}) |
||||
|
||||
include (FindPackageHandleStandardArgs) |
||||
find_package_handle_standard_args (MIR |
||||
REQUIRED_VARS MIR_LIBRARY MIR_INCLUDE_DIR) |
||||
|
||||
if (MIR_FOUND) |
||||
set(MIR_LIBRARIES ${MIR_LIBRARY}) |
||||
set(MIR_INCLUDE_DIRS ${PC_MIR_INCLUDE_DIRS}) |
||||
set(MIR_DEFINITIONS -DHAVE_MIR=1) |
||||
endif() |
||||
|
||||
mark_as_advanced (MIR_LIBRARY MIR_INCLUDE_DIR) |
||||
endif() |
||||
@ -1,240 +0,0 @@ |
||||
//========================================================================
|
||||
// GLFW 3.3 Mir - www.glfw.org
|
||||
//------------------------------------------------------------------------
|
||||
// Copyright (c) 2014-2017 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> |
||||
|
||||
|
||||
// Create key code translation tables
|
||||
//
|
||||
static void createKeyTables(void) |
||||
{ |
||||
int scancode; |
||||
|
||||
memset(_glfw.mir.keycodes, -1, sizeof(_glfw.mir.keycodes)); |
||||
memset(_glfw.mir.scancodes, -1, sizeof(_glfw.mir.scancodes)); |
||||
|
||||
_glfw.mir.keycodes[KEY_GRAVE] = GLFW_KEY_GRAVE_ACCENT; |
||||
_glfw.mir.keycodes[KEY_1] = GLFW_KEY_1; |
||||
_glfw.mir.keycodes[KEY_2] = GLFW_KEY_2; |
||||
_glfw.mir.keycodes[KEY_3] = GLFW_KEY_3; |
||||
_glfw.mir.keycodes[KEY_4] = GLFW_KEY_4; |
||||
_glfw.mir.keycodes[KEY_5] = GLFW_KEY_5; |
||||
_glfw.mir.keycodes[KEY_6] = GLFW_KEY_6; |
||||
_glfw.mir.keycodes[KEY_7] = GLFW_KEY_7; |
||||
_glfw.mir.keycodes[KEY_8] = GLFW_KEY_8; |
||||
_glfw.mir.keycodes[KEY_9] = GLFW_KEY_9; |
||||
_glfw.mir.keycodes[KEY_0] = GLFW_KEY_0; |
||||
_glfw.mir.keycodes[KEY_SPACE] = GLFW_KEY_SPACE; |
||||
_glfw.mir.keycodes[KEY_MINUS] = GLFW_KEY_MINUS; |
||||
_glfw.mir.keycodes[KEY_EQUAL] = GLFW_KEY_EQUAL; |
||||
_glfw.mir.keycodes[KEY_Q] = GLFW_KEY_Q; |
||||
_glfw.mir.keycodes[KEY_W] = GLFW_KEY_W; |
||||
_glfw.mir.keycodes[KEY_E] = GLFW_KEY_E; |
||||
_glfw.mir.keycodes[KEY_R] = GLFW_KEY_R; |
||||
_glfw.mir.keycodes[KEY_T] = GLFW_KEY_T; |
||||
_glfw.mir.keycodes[KEY_Y] = GLFW_KEY_Y; |
||||
_glfw.mir.keycodes[KEY_U] = GLFW_KEY_U; |
||||
_glfw.mir.keycodes[KEY_I] = GLFW_KEY_I; |
||||
_glfw.mir.keycodes[KEY_O] = GLFW_KEY_O; |
||||
_glfw.mir.keycodes[KEY_P] = GLFW_KEY_P; |
||||
_glfw.mir.keycodes[KEY_LEFTBRACE] = GLFW_KEY_LEFT_BRACKET; |
||||
_glfw.mir.keycodes[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET; |
||||
_glfw.mir.keycodes[KEY_A] = GLFW_KEY_A; |
||||
_glfw.mir.keycodes[KEY_S] = GLFW_KEY_S; |
||||
_glfw.mir.keycodes[KEY_D] = GLFW_KEY_D; |
||||
_glfw.mir.keycodes[KEY_F] = GLFW_KEY_F; |
||||
_glfw.mir.keycodes[KEY_G] = GLFW_KEY_G; |
||||
_glfw.mir.keycodes[KEY_H] = GLFW_KEY_H; |
||||
_glfw.mir.keycodes[KEY_J] = GLFW_KEY_J; |
||||
_glfw.mir.keycodes[KEY_K] = GLFW_KEY_K; |
||||
_glfw.mir.keycodes[KEY_L] = GLFW_KEY_L; |
||||
_glfw.mir.keycodes[KEY_SEMICOLON] = GLFW_KEY_SEMICOLON; |
||||
_glfw.mir.keycodes[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE; |
||||
_glfw.mir.keycodes[KEY_Z] = GLFW_KEY_Z; |
||||
_glfw.mir.keycodes[KEY_X] = GLFW_KEY_X; |
||||
_glfw.mir.keycodes[KEY_C] = GLFW_KEY_C; |
||||
_glfw.mir.keycodes[KEY_V] = GLFW_KEY_V; |
||||
_glfw.mir.keycodes[KEY_B] = GLFW_KEY_B; |
||||
_glfw.mir.keycodes[KEY_N] = GLFW_KEY_N; |
||||
_glfw.mir.keycodes[KEY_M] = GLFW_KEY_M; |
||||
_glfw.mir.keycodes[KEY_COMMA] = GLFW_KEY_COMMA; |
||||
_glfw.mir.keycodes[KEY_DOT] = GLFW_KEY_PERIOD; |
||||
_glfw.mir.keycodes[KEY_SLASH] = GLFW_KEY_SLASH; |
||||
_glfw.mir.keycodes[KEY_BACKSLASH] = GLFW_KEY_BACKSLASH; |
||||
_glfw.mir.keycodes[KEY_ESC] = GLFW_KEY_ESCAPE; |
||||
_glfw.mir.keycodes[KEY_TAB] = GLFW_KEY_TAB; |
||||
_glfw.mir.keycodes[KEY_LEFTSHIFT] = GLFW_KEY_LEFT_SHIFT; |
||||
_glfw.mir.keycodes[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT; |
||||
_glfw.mir.keycodes[KEY_LEFTCTRL] = GLFW_KEY_LEFT_CONTROL; |
||||
_glfw.mir.keycodes[KEY_RIGHTCTRL] = GLFW_KEY_RIGHT_CONTROL; |
||||
_glfw.mir.keycodes[KEY_LEFTALT] = GLFW_KEY_LEFT_ALT; |
||||
_glfw.mir.keycodes[KEY_RIGHTALT] = GLFW_KEY_RIGHT_ALT; |
||||
_glfw.mir.keycodes[KEY_LEFTMETA] = GLFW_KEY_LEFT_SUPER; |
||||
_glfw.mir.keycodes[KEY_RIGHTMETA] = GLFW_KEY_RIGHT_SUPER; |
||||
_glfw.mir.keycodes[KEY_MENU] = GLFW_KEY_MENU; |
||||
_glfw.mir.keycodes[KEY_NUMLOCK] = GLFW_KEY_NUM_LOCK; |
||||
_glfw.mir.keycodes[KEY_CAPSLOCK] = GLFW_KEY_CAPS_LOCK; |
||||
_glfw.mir.keycodes[KEY_PRINT] = GLFW_KEY_PRINT_SCREEN; |
||||
_glfw.mir.keycodes[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK; |
||||
_glfw.mir.keycodes[KEY_PAUSE] = GLFW_KEY_PAUSE; |
||||
_glfw.mir.keycodes[KEY_DELETE] = GLFW_KEY_DELETE; |
||||
_glfw.mir.keycodes[KEY_BACKSPACE] = GLFW_KEY_BACKSPACE; |
||||
_glfw.mir.keycodes[KEY_ENTER] = GLFW_KEY_ENTER; |
||||
_glfw.mir.keycodes[KEY_HOME] = GLFW_KEY_HOME; |
||||
_glfw.mir.keycodes[KEY_END] = GLFW_KEY_END; |
||||
_glfw.mir.keycodes[KEY_PAGEUP] = GLFW_KEY_PAGE_UP; |
||||
_glfw.mir.keycodes[KEY_PAGEDOWN] = GLFW_KEY_PAGE_DOWN; |
||||
_glfw.mir.keycodes[KEY_INSERT] = GLFW_KEY_INSERT; |
||||
_glfw.mir.keycodes[KEY_LEFT] = GLFW_KEY_LEFT; |
||||
_glfw.mir.keycodes[KEY_RIGHT] = GLFW_KEY_RIGHT; |
||||
_glfw.mir.keycodes[KEY_DOWN] = GLFW_KEY_DOWN; |
||||
_glfw.mir.keycodes[KEY_UP] = GLFW_KEY_UP; |
||||
_glfw.mir.keycodes[KEY_F1] = GLFW_KEY_F1; |
||||
_glfw.mir.keycodes[KEY_F2] = GLFW_KEY_F2; |
||||
_glfw.mir.keycodes[KEY_F3] = GLFW_KEY_F3; |
||||
_glfw.mir.keycodes[KEY_F4] = GLFW_KEY_F4; |
||||
_glfw.mir.keycodes[KEY_F5] = GLFW_KEY_F5; |
||||
_glfw.mir.keycodes[KEY_F6] = GLFW_KEY_F6; |
||||
_glfw.mir.keycodes[KEY_F7] = GLFW_KEY_F7; |
||||
_glfw.mir.keycodes[KEY_F8] = GLFW_KEY_F8; |
||||
_glfw.mir.keycodes[KEY_F9] = GLFW_KEY_F9; |
||||
_glfw.mir.keycodes[KEY_F10] = GLFW_KEY_F10; |
||||
_glfw.mir.keycodes[KEY_F11] = GLFW_KEY_F11; |
||||
_glfw.mir.keycodes[KEY_F12] = GLFW_KEY_F12; |
||||
_glfw.mir.keycodes[KEY_F13] = GLFW_KEY_F13; |
||||
_glfw.mir.keycodes[KEY_F14] = GLFW_KEY_F14; |
||||
_glfw.mir.keycodes[KEY_F15] = GLFW_KEY_F15; |
||||
_glfw.mir.keycodes[KEY_F16] = GLFW_KEY_F16; |
||||
_glfw.mir.keycodes[KEY_F17] = GLFW_KEY_F17; |
||||
_glfw.mir.keycodes[KEY_F18] = GLFW_KEY_F18; |
||||
_glfw.mir.keycodes[KEY_F19] = GLFW_KEY_F19; |
||||
_glfw.mir.keycodes[KEY_F20] = GLFW_KEY_F20; |
||||
_glfw.mir.keycodes[KEY_F21] = GLFW_KEY_F21; |
||||
_glfw.mir.keycodes[KEY_F22] = GLFW_KEY_F22; |
||||
_glfw.mir.keycodes[KEY_F23] = GLFW_KEY_F23; |
||||
_glfw.mir.keycodes[KEY_F24] = GLFW_KEY_F24; |
||||
_glfw.mir.keycodes[KEY_KPSLASH] = GLFW_KEY_KP_DIVIDE; |
||||
_glfw.mir.keycodes[KEY_KPDOT] = GLFW_KEY_KP_MULTIPLY; |
||||
_glfw.mir.keycodes[KEY_KPMINUS] = GLFW_KEY_KP_SUBTRACT; |
||||
_glfw.mir.keycodes[KEY_KPPLUS] = GLFW_KEY_KP_ADD; |
||||
_glfw.mir.keycodes[KEY_KP0] = GLFW_KEY_KP_0; |
||||
_glfw.mir.keycodes[KEY_KP1] = GLFW_KEY_KP_1; |
||||
_glfw.mir.keycodes[KEY_KP2] = GLFW_KEY_KP_2; |
||||
_glfw.mir.keycodes[KEY_KP3] = GLFW_KEY_KP_3; |
||||
_glfw.mir.keycodes[KEY_KP4] = GLFW_KEY_KP_4; |
||||
_glfw.mir.keycodes[KEY_KP5] = GLFW_KEY_KP_5; |
||||
_glfw.mir.keycodes[KEY_KP6] = GLFW_KEY_KP_6; |
||||
_glfw.mir.keycodes[KEY_KP7] = GLFW_KEY_KP_7; |
||||
_glfw.mir.keycodes[KEY_KP8] = GLFW_KEY_KP_8; |
||||
_glfw.mir.keycodes[KEY_KP9] = GLFW_KEY_KP_9; |
||||
_glfw.mir.keycodes[KEY_KPCOMMA] = GLFW_KEY_KP_DECIMAL; |
||||
_glfw.mir.keycodes[KEY_KPEQUAL] = GLFW_KEY_KP_EQUAL; |
||||
_glfw.mir.keycodes[KEY_KPENTER] = GLFW_KEY_KP_ENTER; |
||||
|
||||
for (scancode = 0; scancode < 256; scancode++) |
||||
{ |
||||
if (_glfw.mir.keycodes[scancode] > 0) |
||||
_glfw.mir.scancodes[_glfw.mir.keycodes[scancode]] = scancode; |
||||
} |
||||
} |
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW internal API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
int _glfwPlatformInit(void) |
||||
{ |
||||
int error; |
||||
|
||||
_glfw.mir.connection = mir_connect_sync(NULL, __PRETTY_FUNCTION__); |
||||
|
||||
if (!mir_connection_is_valid(_glfw.mir.connection)) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unable to connect to server: %s", |
||||
mir_connection_get_error_message(_glfw.mir.connection)); |
||||
|
||||
return GLFW_FALSE; |
||||
} |
||||
|
||||
_glfw.mir.display = |
||||
mir_connection_get_egl_native_display(_glfw.mir.connection); |
||||
|
||||
createKeyTables(); |
||||
|
||||
if (!_glfwInitJoysticksLinux()) |
||||
return GLFW_FALSE; |
||||
|
||||
_glfwInitTimerPOSIX(); |
||||
|
||||
_glfw.mir.eventQueue = calloc(1, sizeof(EventQueue)); |
||||
_glfwInitEventQueueMir(_glfw.mir.eventQueue); |
||||
|
||||
error = pthread_mutex_init(&_glfw.mir.eventMutex, NULL); |
||||
if (error) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Failed to create event mutex: %s", |
||||
strerror(error)); |
||||
return GLFW_FALSE; |
||||
} |
||||
|
||||
_glfwPollMonitorsMir(); |
||||
return GLFW_TRUE; |
||||
} |
||||
|
||||
void _glfwPlatformTerminate(void) |
||||
{ |
||||
_glfwTerminateEGL(); |
||||
_glfwTerminateJoysticksLinux(); |
||||
|
||||
_glfwDeleteEventQueueMir(_glfw.mir.eventQueue); |
||||
|
||||
pthread_mutex_destroy(&_glfw.mir.eventMutex); |
||||
|
||||
mir_connection_release(_glfw.mir.connection); |
||||
} |
||||
|
||||
const char* _glfwPlatformGetVersionString(void) |
||||
{ |
||||
return _GLFW_VERSION_NUMBER " Mir EGL" |
||||
#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK) |
||||
" clock_gettime" |
||||
#else |
||||
" gettimeofday" |
||||
#endif |
||||
" evdev" |
||||
#if defined(_GLFW_BUILD_DLL) |
||||
" shared" |
||||
#endif |
||||
; |
||||
} |
||||
|
||||
@ -1,218 +0,0 @@ |
||||
//========================================================================
|
||||
// GLFW 3.3 Mir - www.glfw.org
|
||||
//------------------------------------------------------------------------
|
||||
// Copyright (c) 2014-2017 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 <stdlib.h> |
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW internal API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Poll for changes in the set of connected monitors
|
||||
//
|
||||
void _glfwPollMonitorsMir(void) |
||||
{ |
||||
int i; |
||||
MirDisplayConfig* displayConfig = |
||||
mir_connection_create_display_configuration(_glfw.mir.connection); |
||||
|
||||
int numOutputs = mir_display_config_get_num_outputs(displayConfig); |
||||
|
||||
for (i = 0; i < numOutputs; i++) |
||||
{ |
||||
const MirOutput* output = mir_display_config_get_output(displayConfig, i); |
||||
MirOutputConnectionState state = mir_output_get_connection_state(output); |
||||
bool enabled = mir_output_is_enabled(output); |
||||
|
||||
if (enabled && state == mir_output_connection_state_connected) |
||||
{ |
||||
int widthMM = mir_output_get_physical_width_mm(output); |
||||
int heightMM = mir_output_get_physical_height_mm(output); |
||||
int x = mir_output_get_position_x(output); |
||||
int y = mir_output_get_position_y(output); |
||||
int id = mir_output_get_id(output); |
||||
size_t currentMode = mir_output_get_current_mode_index(output); |
||||
const char* name = mir_output_type_name(mir_output_get_type(output)); |
||||
|
||||
_GLFWmonitor* monitor = _glfwAllocMonitor(name, |
||||
widthMM, |
||||
heightMM); |
||||
monitor->mir.x = x; |
||||
monitor->mir.y = y; |
||||
monitor->mir.outputId = id; |
||||
monitor->mir.curMode = currentMode; |
||||
monitor->modes = _glfwPlatformGetVideoModes(monitor, &monitor->modeCount); |
||||
|
||||
_glfwInputMonitor(monitor, GLFW_CONNECTED, _GLFW_INSERT_LAST); |
||||
} |
||||
} |
||||
|
||||
mir_display_config_release(displayConfig); |
||||
} |
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW platform API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void _glfwPlatformFreeMonitor(_GLFWmonitor* monitor) |
||||
{ |
||||
} |
||||
|
||||
void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos) |
||||
{ |
||||
if (xpos) |
||||
*xpos = monitor->mir.x; |
||||
if (ypos) |
||||
*ypos = monitor->mir.y; |
||||
} |
||||
|
||||
void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor, |
||||
float* xscale, float* yscale) |
||||
{ |
||||
if (xscale) |
||||
*xscale = 1.f; |
||||
if (yscale) |
||||
*yscale = 1.f; |
||||
} |
||||
|
||||
static void FillInRGBBitsFromPixelFormat(GLFWvidmode* mode, const MirPixelFormat pf) |
||||
{ |
||||
switch (pf) |
||||
{ |
||||
case mir_pixel_format_rgb_565: |
||||
mode->redBits = 5; |
||||
mode->greenBits = 6; |
||||
mode->blueBits = 5; |
||||
break; |
||||
case mir_pixel_format_rgba_5551: |
||||
mode->redBits = 5; |
||||
mode->greenBits = 5; |
||||
mode->blueBits = 5; |
||||
break; |
||||
case mir_pixel_format_rgba_4444: |
||||
mode->redBits = 4; |
||||
mode->greenBits = 4; |
||||
mode->blueBits = 4; |
||||
break; |
||||
case mir_pixel_format_abgr_8888: |
||||
case mir_pixel_format_xbgr_8888: |
||||
case mir_pixel_format_argb_8888: |
||||
case mir_pixel_format_xrgb_8888: |
||||
case mir_pixel_format_bgr_888: |
||||
case mir_pixel_format_rgb_888: |
||||
default: |
||||
mode->redBits = 8; |
||||
mode->greenBits = 8; |
||||
mode->blueBits = 8; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found) |
||||
{ |
||||
int i; |
||||
GLFWvidmode* modes = NULL; |
||||
MirDisplayConfig* displayConfig = |
||||
mir_connection_create_display_configuration(_glfw.mir.connection); |
||||
|
||||
int numOutputs = mir_display_config_get_num_outputs(displayConfig); |
||||
|
||||
for (i = 0; i < numOutputs; i++) |
||||
{ |
||||
const MirOutput* output = mir_display_config_get_output(displayConfig, i); |
||||
int id = mir_output_get_id(output); |
||||
|
||||
if (id != monitor->mir.outputId) |
||||
continue; |
||||
|
||||
MirOutputConnectionState state = mir_output_get_connection_state(output); |
||||
bool enabled = mir_output_is_enabled(output); |
||||
|
||||
// We must have been disconnected
|
||||
if (!enabled || state != mir_output_connection_state_connected) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Monitor no longer connected"); |
||||
return NULL; |
||||
} |
||||
|
||||
int numModes = mir_output_get_num_modes(output); |
||||
modes = calloc(numModes, sizeof(GLFWvidmode)); |
||||
|
||||
for (*found = 0; *found < numModes; (*found)++) |
||||
{ |
||||
const MirOutputMode* mode = mir_output_get_mode(output, *found); |
||||
int width = mir_output_mode_get_width(mode); |
||||
int height = mir_output_mode_get_height(mode); |
||||
double refreshRate = mir_output_mode_get_refresh_rate(mode); |
||||
MirPixelFormat currentFormat = mir_output_get_current_pixel_format(output); |
||||
|
||||
modes[*found].width = width; |
||||
modes[*found].height = height; |
||||
modes[*found].refreshRate = refreshRate; |
||||
|
||||
FillInRGBBitsFromPixelFormat(&modes[*found], currentFormat); |
||||
} |
||||
|
||||
break; |
||||
} |
||||
|
||||
mir_display_config_release(displayConfig); |
||||
|
||||
return modes; |
||||
} |
||||
|
||||
void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode) |
||||
{ |
||||
*mode = monitor->modes[monitor->mir.curMode]; |
||||
} |
||||
|
||||
void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
} |
||||
|
||||
void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
} |
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW native API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
GLFWAPI int glfwGetMirMonitor(GLFWmonitor* handle) |
||||
{ |
||||
_GLFWmonitor* monitor = (_GLFWmonitor*) handle; |
||||
_GLFW_REQUIRE_INIT_OR_RETURN(0); |
||||
return monitor->mir.outputId; |
||||
} |
||||
@ -1,133 +0,0 @@ |
||||
//========================================================================
|
||||
// GLFW 3.3 Mir - www.glfw.org
|
||||
//------------------------------------------------------------------------
|
||||
// Copyright (c) 2014-2017 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 <sys/queue.h> |
||||
#include <pthread.h> |
||||
#include <dlfcn.h> |
||||
|
||||
#include <mir_toolkit/mir_client_library.h> |
||||
|
||||
typedef VkFlags VkMirWindowCreateFlagsKHR; |
||||
|
||||
typedef struct VkMirWindowCreateInfoKHR |
||||
{ |
||||
VkStructureType sType; |
||||
const void* pNext; |
||||
VkMirWindowCreateFlagsKHR flags; |
||||
MirConnection* connection; |
||||
MirWindow* mirWindow; |
||||
} VkMirWindowCreateInfoKHR; |
||||
|
||||
typedef VkResult (APIENTRY *PFN_vkCreateMirWindowKHR)(VkInstance,const VkMirWindowCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*); |
||||
typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice,uint32_t,MirConnection*); |
||||
|
||||
#include "posix_thread.h" |
||||
#include "posix_time.h" |
||||
#include "linux_joystick.h" |
||||
#include "xkb_unicode.h" |
||||
#include "egl_context.h" |
||||
#include "osmesa_context.h" |
||||
|
||||
#define _glfw_dlopen(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL) |
||||
#define _glfw_dlclose(handle) dlclose(handle) |
||||
#define _glfw_dlsym(handle, name) dlsym(handle, name) |
||||
|
||||
#define _GLFW_EGL_NATIVE_WINDOW ((EGLNativeWindowType) window->mir.nativeWindow) |
||||
#define _GLFW_EGL_NATIVE_DISPLAY ((EGLNativeDisplayType) _glfw.mir.display) |
||||
|
||||
#define _GLFW_PLATFORM_WINDOW_STATE _GLFWwindowMir mir |
||||
#define _GLFW_PLATFORM_MONITOR_STATE _GLFWmonitorMir mir |
||||
#define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryMir mir |
||||
#define _GLFW_PLATFORM_CURSOR_STATE _GLFWcursorMir mir |
||||
|
||||
#define _GLFW_PLATFORM_CONTEXT_STATE |
||||
#define _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE |
||||
|
||||
|
||||
// Mir-specific Event Queue
|
||||
//
|
||||
typedef struct EventQueue |
||||
{ |
||||
TAILQ_HEAD(, EventNode) head; |
||||
} EventQueue; |
||||
|
||||
// Mir-specific per-window data
|
||||
//
|
||||
typedef struct _GLFWwindowMir |
||||
{ |
||||
MirWindow* window; |
||||
int width; |
||||
int height; |
||||
MirEGLNativeWindowType nativeWindow; |
||||
_GLFWcursor* currentCursor; |
||||
|
||||
} _GLFWwindowMir; |
||||
|
||||
// Mir-specific per-monitor data
|
||||
//
|
||||
typedef struct _GLFWmonitorMir |
||||
{ |
||||
int curMode; |
||||
int outputId; |
||||
int x; |
||||
int y; |
||||
|
||||
} _GLFWmonitorMir; |
||||
|
||||
// Mir-specific global data
|
||||
//
|
||||
typedef struct _GLFWlibraryMir |
||||
{ |
||||
MirConnection* connection; |
||||
MirEGLNativeDisplayType display; |
||||
EventQueue* eventQueue; |
||||
|
||||
short int keycodes[256]; |
||||
short int scancodes[GLFW_KEY_LAST + 1]; |
||||
|
||||
pthread_mutex_t eventMutex; |
||||
pthread_cond_t eventCond; |
||||
|
||||
// The window whose disabled cursor mode is active
|
||||
_GLFWwindow* disabledCursorWindow; |
||||
|
||||
} _GLFWlibraryMir; |
||||
|
||||
// Mir-specific per-cursor data
|
||||
// TODO: Only system cursors are implemented in Mir atm. Need to wait for support.
|
||||
//
|
||||
typedef struct _GLFWcursorMir |
||||
{ |
||||
MirCursorConfiguration* conf; |
||||
MirBufferStream* customCursor; |
||||
char const* cursorName; // only needed for system cursors
|
||||
} _GLFWcursorMir; |
||||
|
||||
|
||||
extern void _glfwPollMonitorsMir(void); |
||||
extern void _glfwInitEventQueueMir(EventQueue* queue); |
||||
extern void _glfwDeleteEventQueueMir(EventQueue* queue); |
||||
|
||||
@ -1,975 +0,0 @@ |
||||
//========================================================================
|
||||
// GLFW 3.3 Mir - www.glfw.org
|
||||
//------------------------------------------------------------------------
|
||||
// Copyright (c) 2014-2017 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; |
||||
const MirEvent* event; |
||||
_GLFWwindow* window; |
||||
} EventNode; |
||||
|
||||
static void deleteNode(EventQueue* queue, EventNode* node) |
||||
{ |
||||
mir_event_unref(node->event); |
||||
free(node); |
||||
} |
||||
|
||||
static GLFWbool emptyEventQueue(EventQueue* queue) |
||||
{ |
||||
return queue->head.tqh_first == NULL; |
||||
} |
||||
|
||||
// TODO The mir_event_ref is not supposed to be used but ... its needed
|
||||
// in this case. Need to wait until we can read from an FD set up by mir
|
||||
// for single threaded event handling.
|
||||
static EventNode* newEventNode(const MirEvent* event, _GLFWwindow* context) |
||||
{ |
||||
EventNode* newNode = calloc(1, sizeof(EventNode)); |
||||
newNode->event = mir_event_ref(event); |
||||
newNode->window = context; |
||||
|
||||
return newNode; |
||||
} |
||||
|
||||
static void enqueueEvent(const MirEvent* event, _GLFWwindow* context) |
||||
{ |
||||
pthread_mutex_lock(&_glfw.mir.eventMutex); |
||||
|
||||
EventNode* newNode = newEventNode(event, context); |
||||
TAILQ_INSERT_TAIL(&_glfw.mir.eventQueue->head, newNode, entries); |
||||
|
||||
pthread_cond_signal(&_glfw.mir.eventCond); |
||||
|
||||
pthread_mutex_unlock(&_glfw.mir.eventMutex); |
||||
} |
||||
|
||||
static EventNode* dequeueEvent(EventQueue* queue) |
||||
{ |
||||
EventNode* node = NULL; |
||||
|
||||
pthread_mutex_lock(&_glfw.mir.eventMutex); |
||||
|
||||
node = queue->head.tqh_first; |
||||
|
||||
if (node) |
||||
TAILQ_REMOVE(&queue->head, node, entries); |
||||
|
||||
pthread_mutex_unlock(&_glfw.mir.eventMutex); |
||||
|
||||
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_input_event_modifier_alt) |
||||
publicMods |= GLFW_MOD_ALT; |
||||
if (mods & mir_input_event_modifier_shift) |
||||
publicMods |= GLFW_MOD_SHIFT; |
||||
if (mods & mir_input_event_modifier_ctrl) |
||||
publicMods |= GLFW_MOD_CONTROL; |
||||
if (mods & mir_input_event_modifier_meta) |
||||
publicMods |= GLFW_MOD_SUPER; |
||||
if (mods & mir_input_event_modifier_caps_lock) |
||||
publicMods |= GLFW_MOD_CAPS_LOCK; |
||||
if (mods & mir_input_event_modifier_num_lock) |
||||
publicMods |= GLFW_MOD_NUM_LOCK; |
||||
|
||||
return publicMods; |
||||
} |
||||
|
||||
static int toGLFWKeyCode(uint32_t key) |
||||
{ |
||||
if (key < sizeof(_glfw.mir.keycodes) / sizeof(_glfw.mir.keycodes[0])) |
||||
return _glfw.mir.keycodes[key]; |
||||
|
||||
return GLFW_KEY_UNKNOWN; |
||||
} |
||||
|
||||
static void handleKeyEvent(const MirKeyboardEvent* key_event, _GLFWwindow* window) |
||||
{ |
||||
const int action = mir_keyboard_event_action (key_event); |
||||
const int scan_code = mir_keyboard_event_scan_code(key_event); |
||||
const int key_code = mir_keyboard_event_key_code (key_event); |
||||
const int modifiers = mir_keyboard_event_modifiers(key_event); |
||||
|
||||
const int pressed = action == mir_keyboard_action_up ? GLFW_RELEASE : GLFW_PRESS; |
||||
const int mods = mirModToGLFWMod(modifiers); |
||||
const long text = _glfwKeySym2Unicode(key_code); |
||||
const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT)); |
||||
|
||||
_glfwInputKey(window, toGLFWKeyCode(scan_code), scan_code, pressed, mods); |
||||
|
||||
if (text != -1) |
||||
_glfwInputChar(window, text, mods, plain); |
||||
} |
||||
|
||||
static void handlePointerButton(_GLFWwindow* window, |
||||
int pressed, |
||||
const MirPointerEvent* pointer_event) |
||||
{ |
||||
int mods = mir_pointer_event_modifiers(pointer_event); |
||||
const int publicMods = mirModToGLFWMod(mods); |
||||
MirPointerButton button = mir_pointer_button_primary; |
||||
static uint32_t oldButtonStates = 0; |
||||
uint32_t newButtonStates = mir_pointer_event_buttons(pointer_event); |
||||
int publicButton = GLFW_MOUSE_BUTTON_LEFT; |
||||
|
||||
// XOR our old button states our new states to figure out what was added or removed
|
||||
button = newButtonStates ^ oldButtonStates; |
||||
|
||||
switch (button) |
||||
{ |
||||
case mir_pointer_button_primary: |
||||
publicButton = GLFW_MOUSE_BUTTON_LEFT; |
||||
break; |
||||
case mir_pointer_button_secondary: |
||||
publicButton = GLFW_MOUSE_BUTTON_RIGHT; |
||||
break; |
||||
case mir_pointer_button_tertiary: |
||||
publicButton = GLFW_MOUSE_BUTTON_MIDDLE; |
||||
break; |
||||
case mir_pointer_button_forward: |
||||
// FIXME What is the forward button?
|
||||
publicButton = GLFW_MOUSE_BUTTON_4; |
||||
break; |
||||
case mir_pointer_button_back: |
||||
// FIXME What is the back button?
|
||||
publicButton = GLFW_MOUSE_BUTTON_5; |
||||
break; |
||||
default: |
||||
break; |
||||
} |
||||
|
||||
oldButtonStates = newButtonStates; |
||||
|
||||
_glfwInputMouseClick(window, publicButton, pressed, publicMods); |
||||
} |
||||
|
||||
static void handlePointerMotion(_GLFWwindow* window, |
||||
const MirPointerEvent* pointer_event) |
||||
{ |
||||
const int hscroll = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_hscroll); |
||||
const int vscroll = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_vscroll); |
||||
|
||||
if (window->cursorMode == GLFW_CURSOR_DISABLED) |
||||
{ |
||||
if (_glfw.mir.disabledCursorWindow != window) |
||||
return; |
||||
|
||||
const int dx = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_relative_x); |
||||
const int dy = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_relative_y); |
||||
const int current_x = window->virtualCursorPosX; |
||||
const int current_y = window->virtualCursorPosY; |
||||
|
||||
_glfwInputCursorPos(window, dx + current_x, dy + current_y); |
||||
} |
||||
else |
||||
{ |
||||
const int x = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_x); |
||||
const int y = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_y); |
||||
|
||||
_glfwInputCursorPos(window, x, y); |
||||
} |
||||
|
||||
if (hscroll != 0 || vscroll != 0) |
||||
_glfwInputScroll(window, hscroll, vscroll); |
||||
} |
||||
|
||||
static void handlePointerEvent(const MirPointerEvent* pointer_event, |
||||
_GLFWwindow* window) |
||||
{ |
||||
int action = mir_pointer_event_action(pointer_event); |
||||
|
||||
switch (action) |
||||
{ |
||||
case mir_pointer_action_button_down: |
||||
handlePointerButton(window, GLFW_PRESS, pointer_event); |
||||
break; |
||||
case mir_pointer_action_button_up: |
||||
handlePointerButton(window, GLFW_RELEASE, pointer_event); |
||||
break; |
||||
case mir_pointer_action_motion: |
||||
handlePointerMotion(window, pointer_event); |
||||
break; |
||||
case mir_pointer_action_enter: |
||||
case mir_pointer_action_leave: |
||||
break; |
||||
default: |
||||
break; |
||||
} |
||||
} |
||||
|
||||
static void handleInput(const MirInputEvent* input_event, _GLFWwindow* window) |
||||
{ |
||||
int type = mir_input_event_get_type(input_event); |
||||
|
||||
switch (type) |
||||
{ |
||||
case mir_input_event_type_key: |
||||
handleKeyEvent(mir_input_event_get_keyboard_event(input_event), window); |
||||
break; |
||||
case mir_input_event_type_pointer: |
||||
handlePointerEvent(mir_input_event_get_pointer_event(input_event), window); |
||||
break; |
||||
default: |
||||
break; |
||||
} |
||||
} |
||||
|
||||
static void handleEvent(const MirEvent* event, _GLFWwindow* window) |
||||
{ |
||||
int type = mir_event_get_type(event); |
||||
|
||||
switch (type) |
||||
{ |
||||
case mir_event_type_input: |
||||
handleInput(mir_event_get_input_event(event), window); |
||||
break; |
||||
default: |
||||
break; |
||||
} |
||||
} |
||||
|
||||
static void addNewEvent(MirWindow* window, const MirEvent* event, void* context) |
||||
{ |
||||
enqueueEvent(event, context); |
||||
} |
||||
|
||||
static GLFWbool createWindow(_GLFWwindow* window) |
||||
{ |
||||
MirWindowSpec* spec; |
||||
MirBufferUsage buffer_usage = mir_buffer_usage_hardware; |
||||
MirPixelFormat pixel_format = findValidPixelFormat(); |
||||
|
||||
if (pixel_format == mir_pixel_format_invalid) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unable to find a correct pixel format"); |
||||
return GLFW_FALSE; |
||||
} |
||||
|
||||
spec = mir_create_normal_window_spec(_glfw.mir.connection, |
||||
window->mir.width, |
||||
window->mir.height); |
||||
|
||||
mir_window_spec_set_pixel_format(spec, pixel_format); |
||||
mir_window_spec_set_buffer_usage(spec, buffer_usage); |
||||
|
||||
window->mir.window = mir_create_window_sync(spec); |
||||
mir_window_spec_release(spec); |
||||
|
||||
if (!mir_window_is_valid(window->mir.window)) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unable to create window: %s", |
||||
mir_window_get_error_message(window->mir.window)); |
||||
|
||||
return GLFW_FALSE; |
||||
} |
||||
|
||||
mir_window_set_event_handler(window->mir.window, addNewEvent, window); |
||||
|
||||
return GLFW_TRUE; |
||||
} |
||||
|
||||
static void setWindowConfinement(_GLFWwindow* window, MirPointerConfinementState state) |
||||
{ |
||||
MirWindowSpec* spec; |
||||
|
||||
spec = mir_create_window_spec(_glfw.mir.connection); |
||||
mir_window_spec_set_pointer_confinement(spec, state); |
||||
|
||||
mir_window_apply_spec(window->mir.window, spec); |
||||
mir_window_spec_release(spec); |
||||
} |
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW internal API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void _glfwInitEventQueueMir(EventQueue* queue) |
||||
{ |
||||
TAILQ_INIT(&queue->head); |
||||
} |
||||
|
||||
void _glfwDeleteEventQueueMir(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 (window->monitor) |
||||
{ |
||||
GLFWvidmode mode; |
||||
_glfwPlatformGetVideoMode(window->monitor, &mode); |
||||
|
||||
mir_window_set_state(window->mir.window, mir_window_state_fullscreen); |
||||
|
||||
if (wndconfig->width > mode.width || wndconfig->height > mode.height) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Requested window size too large: %ix%i", |
||||
wndconfig->width, wndconfig->height); |
||||
|
||||
return GLFW_FALSE; |
||||
} |
||||
} |
||||
|
||||
window->mir.width = wndconfig->width; |
||||
window->mir.height = wndconfig->height; |
||||
window->mir.currentCursor = NULL; |
||||
|
||||
if (!createWindow(window)) |
||||
return GLFW_FALSE; |
||||
|
||||
window->mir.nativeWindow = mir_buffer_stream_get_egl_native_window( |
||||
mir_window_get_buffer_stream(window->mir.window)); |
||||
|
||||
if (ctxconfig->client != GLFW_NO_API) |
||||
{ |
||||
if (ctxconfig->source == GLFW_EGL_CONTEXT_API || |
||||
ctxconfig->source == GLFW_NATIVE_CONTEXT_API) |
||||
{ |
||||
if (!_glfwInitEGL()) |
||||
return GLFW_FALSE; |
||||
if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig)) |
||||
return GLFW_FALSE; |
||||
} |
||||
else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API) |
||||
{ |
||||
if (!_glfwInitOSMesa()) |
||||
return GLFW_FALSE; |
||||
if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig)) |
||||
return GLFW_FALSE; |
||||
} |
||||
} |
||||
|
||||
return GLFW_TRUE; |
||||
} |
||||
|
||||
void _glfwPlatformDestroyWindow(_GLFWwindow* window) |
||||
{ |
||||
if (_glfw.mir.disabledCursorWindow == window) |
||||
_glfw.mir.disabledCursorWindow = NULL; |
||||
|
||||
if (mir_window_is_valid(window->mir.window)) |
||||
{ |
||||
mir_window_release_sync(window->mir.window); |
||||
window->mir.window= NULL; |
||||
} |
||||
|
||||
if (window->context.destroy) |
||||
window->context.destroy(window); |
||||
} |
||||
|
||||
void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title) |
||||
{ |
||||
MirWindowSpec* spec; |
||||
|
||||
spec = mir_create_window_spec(_glfw.mir.connection); |
||||
mir_window_spec_set_name(spec, title); |
||||
mir_window_apply_spec(window->mir.window, spec); |
||||
mir_window_spec_release(spec); |
||||
} |
||||
|
||||
void _glfwPlatformSetWindowIcon(_GLFWwindow* window, |
||||
int count, const GLFWimage* images) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
} |
||||
|
||||
void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height) |
||||
{ |
||||
MirWindowSpec* spec; |
||||
|
||||
spec = mir_create_window_spec(_glfw.mir.connection); |
||||
mir_window_spec_set_width (spec, width); |
||||
mir_window_spec_set_height(spec, height); |
||||
|
||||
mir_window_apply_spec(window->mir.window, spec); |
||||
mir_window_spec_release(spec); |
||||
} |
||||
|
||||
void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window, |
||||
int minwidth, int minheight, |
||||
int maxwidth, int maxheight) |
||||
{ |
||||
MirWindowSpec* spec; |
||||
|
||||
spec = mir_create_window_spec(_glfw.mir.connection); |
||||
mir_window_spec_set_max_width (spec, maxwidth); |
||||
mir_window_spec_set_max_height(spec, maxheight); |
||||
mir_window_spec_set_min_width (spec, minwidth); |
||||
mir_window_spec_set_min_height(spec, minheight); |
||||
|
||||
mir_window_apply_spec(window->mir.window, spec); |
||||
mir_window_spec_release(spec); |
||||
} |
||||
|
||||
void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer, int denom) |
||||
{ |
||||
_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 _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height) |
||||
{ |
||||
if (width) |
||||
*width = window->mir.width; |
||||
if (height) |
||||
*height = window->mir.height; |
||||
} |
||||
|
||||
void _glfwPlatformGetWindowContentScale(_GLFWwindow* window, |
||||
float* xscale, float* yscale) |
||||
{ |
||||
if (xscale) |
||||
*xscale = 1.f; |
||||
if (yscale) |
||||
*yscale = 1.f; |
||||
} |
||||
|
||||
void _glfwPlatformIconifyWindow(_GLFWwindow* window) |
||||
{ |
||||
MirWindowSpec* spec; |
||||
|
||||
spec = mir_create_window_spec(_glfw.mir.connection); |
||||
mir_window_spec_set_state(spec, mir_window_state_minimized); |
||||
|
||||
mir_window_apply_spec(window->mir.window, spec); |
||||
mir_window_spec_release(spec); |
||||
} |
||||
|
||||
void _glfwPlatformRestoreWindow(_GLFWwindow* window) |
||||
{ |
||||
MirWindowSpec* spec; |
||||
|
||||
spec = mir_create_window_spec(_glfw.mir.connection); |
||||
mir_window_spec_set_state(spec, mir_window_state_restored); |
||||
|
||||
mir_window_apply_spec(window->mir.window, spec); |
||||
mir_window_spec_release(spec); |
||||
} |
||||
|
||||
void _glfwPlatformMaximizeWindow(_GLFWwindow* window) |
||||
{ |
||||
MirWindowSpec* spec; |
||||
|
||||
spec = mir_create_window_spec(_glfw.mir.connection); |
||||
mir_window_spec_set_state(spec, mir_window_state_maximized); |
||||
|
||||
mir_window_apply_spec(window->mir.window, spec); |
||||
mir_window_spec_release(spec); |
||||
} |
||||
|
||||
void _glfwPlatformHideWindow(_GLFWwindow* window) |
||||
{ |
||||
MirWindowSpec* spec; |
||||
|
||||
spec = mir_create_window_spec(_glfw.mir.connection); |
||||
mir_window_spec_set_state(spec, mir_window_state_hidden); |
||||
|
||||
mir_window_apply_spec(window->mir.window, spec); |
||||
mir_window_spec_release(spec); |
||||
} |
||||
|
||||
void _glfwPlatformShowWindow(_GLFWwindow* window) |
||||
{ |
||||
MirWindowSpec* spec; |
||||
|
||||
spec = mir_create_window_spec(_glfw.mir.connection); |
||||
mir_window_spec_set_state(spec, mir_window_state_restored); |
||||
|
||||
mir_window_apply_spec(window->mir.window, spec); |
||||
mir_window_spec_release(spec); |
||||
} |
||||
|
||||
void _glfwPlatformRequestWindowAttention(_GLFWwindow* window) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
} |
||||
|
||||
void _glfwPlatformFocusWindow(_GLFWwindow* window) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
} |
||||
|
||||
void _glfwPlatformSetWindowMonitor(_GLFWwindow* window, |
||||
_GLFWmonitor* monitor, |
||||
int xpos, int ypos, |
||||
int width, int height, |
||||
int refreshRate) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
} |
||||
|
||||
int _glfwPlatformWindowFocused(_GLFWwindow* window) |
||||
{ |
||||
return mir_window_get_focus_state(window->mir.window) == mir_window_focus_state_focused; |
||||
} |
||||
|
||||
int _glfwPlatformWindowIconified(_GLFWwindow* window) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
return GLFW_FALSE; |
||||
} |
||||
|
||||
int _glfwPlatformWindowVisible(_GLFWwindow* window) |
||||
{ |
||||
return mir_window_get_visibility(window->mir.window) == mir_window_visibility_exposed; |
||||
} |
||||
|
||||
int _glfwPlatformWindowMaximized(_GLFWwindow* window) |
||||
{ |
||||
return mir_window_get_state(window->mir.window) == mir_window_state_maximized; |
||||
} |
||||
|
||||
int _glfwPlatformWindowHovered(_GLFWwindow* window) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
return GLFW_FALSE; |
||||
} |
||||
|
||||
int _glfwPlatformFramebufferTransparent(_GLFWwindow* window) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
return GLFW_FALSE; |
||||
} |
||||
|
||||
void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
} |
||||
|
||||
void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
} |
||||
|
||||
void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
} |
||||
|
||||
float _glfwPlatformGetWindowOpacity(_GLFWwindow* window) |
||||
{ |
||||
return 1.f; |
||||
} |
||||
|
||||
void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity) |
||||
{ |
||||
} |
||||
|
||||
void _glfwPlatformPollEvents(void) |
||||
{ |
||||
EventNode* node = NULL; |
||||
|
||||
while ((node = dequeueEvent(_glfw.mir.eventQueue))) |
||||
{ |
||||
handleEvent(node->event, node->window); |
||||
deleteNode(_glfw.mir.eventQueue, node); |
||||
} |
||||
} |
||||
|
||||
void _glfwPlatformWaitEvents(void) |
||||
{ |
||||
pthread_mutex_lock(&_glfw.mir.eventMutex); |
||||
|
||||
while (emptyEventQueue(_glfw.mir.eventQueue)) |
||||
pthread_cond_wait(&_glfw.mir.eventCond, &_glfw.mir.eventMutex); |
||||
|
||||
pthread_mutex_unlock(&_glfw.mir.eventMutex); |
||||
|
||||
_glfwPlatformPollEvents(); |
||||
} |
||||
|
||||
void _glfwPlatformWaitEventsTimeout(double timeout) |
||||
{ |
||||
pthread_mutex_lock(&_glfw.mir.eventMutex); |
||||
|
||||
if (emptyEventQueue(_glfw.mir.eventQueue)) |
||||
{ |
||||
struct timespec time; |
||||
clock_gettime(CLOCK_REALTIME, &time); |
||||
time.tv_sec += (long) timeout; |
||||
time.tv_nsec += (long) ((timeout - (long) timeout) * 1e9); |
||||
pthread_cond_timedwait(&_glfw.mir.eventCond, &_glfw.mir.eventMutex, &time); |
||||
} |
||||
|
||||
pthread_mutex_unlock(&_glfw.mir.eventMutex); |
||||
|
||||
_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) |
||||
{ |
||||
MirBufferStream* stream; |
||||
|
||||
int i_w = image->width; |
||||
int i_h = image->height; |
||||
|
||||
stream = mir_connection_create_buffer_stream_sync(_glfw.mir.connection, |
||||
i_w, i_h, |
||||
mir_pixel_format_argb_8888, |
||||
mir_buffer_usage_software); |
||||
|
||||
cursor->mir.conf = mir_cursor_configuration_from_buffer_stream(stream, xhot, yhot); |
||||
|
||||
MirGraphicsRegion region; |
||||
mir_buffer_stream_get_graphics_region(stream, ®ion); |
||||
|
||||
unsigned char* pixels = image->pixels; |
||||
char* dest = region.vaddr; |
||||
int i; |
||||
|
||||
for (i = 0; i < i_w * i_h; i++, pixels += 4) |
||||
{ |
||||
unsigned int alpha = pixels[3]; |
||||
*dest++ = (char)(pixels[2] * alpha / 255); |
||||
*dest++ = (char)(pixels[1] * alpha / 255); |
||||
*dest++ = (char)(pixels[0] * alpha / 255); |
||||
*dest++ = (char)alpha; |
||||
} |
||||
|
||||
mir_buffer_stream_swap_buffers_sync(stream); |
||||
cursor->mir.customCursor = stream; |
||||
|
||||
return GLFW_TRUE; |
||||
} |
||||
|
||||
static const char* getSystemCursorName(int shape) |
||||
{ |
||||
switch (shape) |
||||
{ |
||||
case GLFW_ARROW_CURSOR: |
||||
return mir_arrow_cursor_name; |
||||
case GLFW_IBEAM_CURSOR: |
||||
return mir_caret_cursor_name; |
||||
case GLFW_CROSSHAIR_CURSOR: |
||||
return mir_crosshair_cursor_name; |
||||
case GLFW_HAND_CURSOR: |
||||
return mir_open_hand_cursor_name; |
||||
case GLFW_HRESIZE_CURSOR: |
||||
return mir_horizontal_resize_cursor_name; |
||||
case GLFW_VRESIZE_CURSOR: |
||||
return mir_vertical_resize_cursor_name; |
||||
} |
||||
|
||||
return NULL; |
||||
} |
||||
|
||||
int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape) |
||||
{ |
||||
cursor->mir.conf = NULL; |
||||
cursor->mir.customCursor = NULL; |
||||
cursor->mir.cursorName = getSystemCursorName(shape); |
||||
|
||||
return cursor->mir.cursorName != NULL; |
||||
} |
||||
|
||||
void _glfwPlatformDestroyCursor(_GLFWcursor* cursor) |
||||
{ |
||||
if (cursor->mir.conf) |
||||
mir_cursor_configuration_destroy(cursor->mir.conf); |
||||
if (cursor->mir.customCursor) |
||||
mir_buffer_stream_release_sync(cursor->mir.customCursor); |
||||
} |
||||
|
||||
static void setCursorNameForWindow(MirWindow* window, char const* name) |
||||
{ |
||||
MirWindowSpec* spec = mir_create_window_spec(_glfw.mir.connection); |
||||
mir_window_spec_set_cursor_name(spec, name); |
||||
mir_window_apply_spec(window, spec); |
||||
mir_window_spec_release(spec); |
||||
} |
||||
|
||||
void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor) |
||||
{ |
||||
if (cursor) |
||||
{ |
||||
window->mir.currentCursor = cursor; |
||||
|
||||
if (cursor->mir.cursorName) |
||||
{ |
||||
setCursorNameForWindow(window->mir.window, cursor->mir.cursorName); |
||||
} |
||||
else if (cursor->mir.conf) |
||||
{ |
||||
mir_window_configure_cursor(window->mir.window, cursor->mir.conf); |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
setCursorNameForWindow(window->mir.window, mir_default_cursor_name); |
||||
} |
||||
} |
||||
|
||||
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 _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode) |
||||
{ |
||||
if (mode == GLFW_CURSOR_DISABLED) |
||||
{ |
||||
_glfw.mir.disabledCursorWindow = window; |
||||
setWindowConfinement(window, mir_pointer_confined_to_window); |
||||
setCursorNameForWindow(window->mir.window, mir_disabled_cursor_name); |
||||
} |
||||
else |
||||
{ |
||||
// If we were disabled before lets undo that!
|
||||
if (_glfw.mir.disabledCursorWindow == window) |
||||
{ |
||||
_glfw.mir.disabledCursorWindow = NULL; |
||||
setWindowConfinement(window, mir_pointer_unconfined); |
||||
} |
||||
|
||||
if (window->cursorMode == GLFW_CURSOR_NORMAL) |
||||
{ |
||||
_glfwPlatformSetCursor(window, window->mir.currentCursor); |
||||
} |
||||
else if (window->cursorMode == GLFW_CURSOR_HIDDEN) |
||||
{ |
||||
setCursorNameForWindow(window->mir.window, mir_disabled_cursor_name); |
||||
} |
||||
} |
||||
} |
||||
|
||||
const char* _glfwPlatformGetScancodeName(int scancode) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
return NULL; |
||||
} |
||||
|
||||
int _glfwPlatformGetKeyScancode(int key) |
||||
{ |
||||
return _glfw.mir.scancodes[key]; |
||||
} |
||||
|
||||
void _glfwPlatformSetClipboardString(const char* string) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
} |
||||
|
||||
const char* _glfwPlatformGetClipboardString(void) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Unsupported function %s", __PRETTY_FUNCTION__); |
||||
|
||||
return NULL; |
||||
} |
||||
|
||||
void _glfwPlatformGetRequiredInstanceExtensions(char** extensions) |
||||
{ |
||||
if (!_glfw.vk.KHR_surface || !_glfw.vk.KHR_mir_surface) |
||||
return; |
||||
|
||||
extensions[0] = "VK_KHR_surface"; |
||||
extensions[1] = "VK_KHR_mir_surface"; |
||||
} |
||||
|
||||
int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance, |
||||
VkPhysicalDevice device, |
||||
uint32_t queuefamily) |
||||
{ |
||||
PFN_vkGetPhysicalDeviceMirPresentationSupportKHR |
||||
vkGetPhysicalDeviceMirPresentationSupportKHR = |
||||
(PFN_vkGetPhysicalDeviceMirPresentationSupportKHR) |
||||
vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMirPresentationSupportKHR"); |
||||
if (!vkGetPhysicalDeviceMirPresentationSupportKHR) |
||||
{ |
||||
_glfwInputError(GLFW_API_UNAVAILABLE, |
||||
"Mir: Vulkan instance missing VK_KHR_mir_surface extension"); |
||||
return GLFW_FALSE; |
||||
} |
||||
|
||||
return vkGetPhysicalDeviceMirPresentationSupportKHR(device, |
||||
queuefamily, |
||||
_glfw.mir.connection); |
||||
} |
||||
|
||||
VkResult _glfwPlatformCreateWindowSurface(VkInstance instance, |
||||
_GLFWwindow* window, |
||||
const VkAllocationCallbacks* allocator, |
||||
VkSurfaceKHR* surface) |
||||
{ |
||||
VkResult err; |
||||
VkMirWindowCreateInfoKHR sci; |
||||
PFN_vkCreateMirWindowKHR vkCreateMirWindowKHR; |
||||
|
||||
vkCreateMirWindowKHR = (PFN_vkCreateMirWindowKHR) |
||||
vkGetInstanceProcAddr(instance, "vkCreateMirWindowKHR"); |
||||
if (!vkCreateMirWindowKHR) |
||||
{ |
||||
_glfwInputError(GLFW_API_UNAVAILABLE, |
||||
"Mir: Vulkan instance missing VK_KHR_mir_surface extension"); |
||||
return VK_ERROR_EXTENSION_NOT_PRESENT; |
||||
} |
||||
|
||||
memset(&sci, 0, sizeof(sci)); |
||||
sci.sType = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR; |
||||
sci.connection = _glfw.mir.connection; |
||||
sci.mirWindow = window->mir.window; |
||||
|
||||
err = vkCreateMirWindowKHR(instance, &sci, allocator, surface); |
||||
if (err) |
||||
{ |
||||
_glfwInputError(GLFW_PLATFORM_ERROR, |
||||
"Mir: Failed to create Vulkan surface: %s", |
||||
_glfwGetVulkanResultString(err)); |
||||
} |
||||
|
||||
return err; |
||||
} |
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW native API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
GLFWAPI MirConnection* glfwGetMirDisplay(void) |
||||
{ |
||||
_GLFW_REQUIRE_INIT_OR_RETURN(NULL); |
||||
return _glfw.mir.connection; |
||||
} |
||||
|
||||
GLFWAPI MirWindow* glfwGetMirWindow(GLFWwindow* handle) |
||||
{ |
||||
_GLFWwindow* window = (_GLFWwindow*) handle; |
||||
_GLFW_REQUIRE_INIT_OR_RETURN(NULL); |
||||
return window->mir.window; |
||||
} |
||||
|
||||
Loading…
Reference in New Issue