AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

Drop the mir backend

Browse Source 
Mir is in the process of switching over to the Wayland protocol,
so we don't need to maintain a separate backend, going forward.
This commit is contained in:
Matthias Clasen 2018-02-05 07:46:01 +01:00
parent 4abdc43688
commit fd25a8cdf2
19 changed files with 4 additions and 6580 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gdk/gdkdisplaymanager.c
View File

@ -59,10 +59,6 @@
#include "wayland/gdkprivate-wayland.h" #include "wayland/gdkprivate-wayland.h"
#endif #endif
#ifdef GDK_WINDOWING_MIR
#include "mir/gdkmir-private.h"
#endif
/** /**
* SECTION:gdkdisplaymanager * SECTION:gdkdisplaymanager
* @Short_description: Maintains a list of all open GdkDisplays * @Short_description: Maintains a list of all open GdkDisplays
@ -276,9 +272,6 @@ static GdkBackend gdk_backends[] = {
#ifdef GDK_WINDOWING_WAYLAND #ifdef GDK_WINDOWING_WAYLAND
{ "wayland", _gdk_wayland_display_open }, { "wayland", _gdk_wayland_display_open },
#endif #endif
#ifdef GDK_WINDOWING_MIR
{ "mir", _gdk_mir_display_open },
#endif
#ifdef GDK_WINDOWING_X11 #ifdef GDK_WINDOWING_X11
{ "x11", gdk_x11_display_open }, { "x11", gdk_x11_display_open },
#endif #endif

3
gdk/meson.build
View File

@ -126,7 +126,6 @@ gdkconfig_cdata.set('GDK_WINDOWING_X11', x11_enabled)
gdkconfig_cdata.set('GDK_WINDOWING_WAYLAND', wayland_enabled) gdkconfig_cdata.set('GDK_WINDOWING_WAYLAND', wayland_enabled)
gdkconfig_cdata.set('GDK_WINDOWING_WIN32', win32_enabled) gdkconfig_cdata.set('GDK_WINDOWING_WIN32', win32_enabled)
gdkconfig_cdata.set('GDK_WINDOWING_BROADWAY', broadway_enabled) gdkconfig_cdata.set('GDK_WINDOWING_BROADWAY', broadway_enabled)
gdkconfig_cdata.set('GDK_WINDOWING_MIR', mir_enabled)
gdkconfig_cdata.set('GDK_RENDERING_VULKAN', have_vulkan) gdkconfig_cdata.set('GDK_RENDERING_VULKAN', have_vulkan)
gdkconfig = configure_file( gdkconfig = configure_file(
@ -192,7 +191,7 @@ endif
gdk_backends = [] gdk_backends = []
gdk_backends_gen_headers = [] # non-public generated headers gdk_backends_gen_headers = [] # non-public generated headers
foreach backend : ['broadway', 'mir', 'quartz', 'wayland', 'win32', 'x11'] foreach backend : ['broadway', 'quartz', 'wayland', 'win32', 'x11']
if get_variable('@0@_enabled'.format(backend)) if get_variable('@0@_enabled'.format(backend))
subdir(backend) subdir(backend)
gdk_deps += get_variable('gdk_@0@_deps'.format(backend)) gdk_deps += get_variable('gdk_@0@_deps'.format(backend))

548
gdk/mir/gdkmir-debug.c
View File

@ -1,548 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "gdkmir-private.h"
#include <mir_toolkit/events/window_placement.h>
static void
_gdk_mir_print_modifiers (unsigned int modifiers)
{
g_printerr (" Modifiers");
if ((modifiers & mir_input_event_modifier_alt) != 0)
g_printerr (" alt");
if ((modifiers & mir_input_event_modifier_alt_left) != 0)
g_printerr (" alt-left");
if ((modifiers & mir_input_event_modifier_alt_right) != 0)
g_printerr (" alt-right");
if ((modifiers & mir_input_event_modifier_shift) != 0)
g_printerr (" shift");
if ((modifiers & mir_input_event_modifier_shift_left) != 0)
g_printerr (" shift-left");
if ((modifiers & mir_input_event_modifier_shift_right) != 0)
g_printerr (" shift-right");
if ((modifiers & mir_input_event_modifier_sym) != 0)
g_printerr (" sym");
if ((modifiers & mir_input_event_modifier_function) != 0)
g_printerr (" function");
if ((modifiers & mir_input_event_modifier_ctrl) != 0)
g_printerr (" ctrl");
if ((modifiers & mir_input_event_modifier_ctrl_left) != 0)
g_printerr (" ctrl-left");
if ((modifiers & mir_input_event_modifier_ctrl_right) != 0)
g_printerr (" ctrl-right");
if ((modifiers & mir_input_event_modifier_meta) != 0)
g_printerr (" meta");
if ((modifiers & mir_input_event_modifier_meta_left) != 0)
g_printerr (" meta-left");
if ((modifiers & mir_input_event_modifier_meta_right) != 0)
g_printerr (" meta-right");
if ((modifiers & mir_input_event_modifier_caps_lock) != 0)
g_printerr (" caps-lock");
if ((modifiers & mir_input_event_modifier_num_lock) != 0)
g_printerr (" num-lock");
if ((modifiers & mir_input_event_modifier_scroll_lock) != 0)
g_printerr (" scroll-lock");
g_printerr ("\n");
}
static void
_gdk_mir_print_key_event (const MirInputEvent *event)
{
const MirKeyboardEvent *keyboard_event = mir_input_event_get_keyboard_event (event);
if (!keyboard_event)
return;
g_printerr ("KEY\n");
g_printerr (" Device %lld\n", (long long int) mir_input_event_get_device_id (event));
g_printerr (" Action ");
switch (mir_keyboard_event_action (keyboard_event))
{
case mir_keyboard_action_down:
g_printerr ("down");
break;
case mir_keyboard_action_up:
g_printerr ("up");
break;
case mir_keyboard_action_repeat:
g_printerr ("repeat");
break;
default:
g_printerr ("%u", mir_keyboard_event_action (keyboard_event));
break;
}
g_printerr ("\n");
_gdk_mir_print_modifiers (mir_keyboard_event_modifiers (keyboard_event));
g_printerr (" Key Code %i\n", mir_keyboard_event_key_code (keyboard_event));
g_printerr (" Scan Code %i\n", mir_keyboard_event_scan_code (keyboard_event));
g_printerr (" Event Time %lli\n", (long long int) mir_input_event_get_event_time (event));
}
static void
_gdk_mir_print_touch_event (const MirInputEvent *event)
{
const MirTouchEvent *touch_event = mir_input_event_get_touch_event (event);
guint i;
guint n;
if (!touch_event)
return;
g_printerr ("TOUCH\n");
g_printerr (" Device %lld\n", (long long int) mir_input_event_get_device_id (event));
g_printerr (" Event Time %lld\n", (long long int) mir_input_event_get_event_time (event));
_gdk_mir_print_modifiers (mir_touch_event_modifiers (touch_event));
n = mir_touch_event_point_count (touch_event);
for (i = 0; i < n; i++)
{
g_printerr (" [%u] (%u/%u) ", mir_touch_event_id (touch_event, i), i + 1, n);
switch (mir_touch_event_action (touch_event, i))
{
case mir_touch_action_down:
g_printerr ("Down");
break;
case mir_touch_action_up:
g_printerr ("Up");
break;
case mir_touch_action_change:
g_printerr ("Change");
break;
default:
g_printerr ("%u", mir_touch_event_action (touch_event, i));
break;
}
switch (mir_touch_event_tooltype (touch_event, i))
{
default:
case mir_touch_tooltype_unknown:
g_printerr (" ? ");
break;
case mir_touch_tooltype_finger:
g_printerr (" finger ");
break;
case mir_touch_tooltype_stylus:
g_printerr (" stylus ");
break;
}
g_printerr ("\n x: %f y: %f P: %f A: %f B: %f d: %f\n",
mir_touch_event_axis_value (touch_event, i, mir_touch_axis_x),
mir_touch_event_axis_value (touch_event, i, mir_touch_axis_y),
mir_touch_event_axis_value (touch_event, i, mir_touch_axis_pressure),
mir_touch_event_axis_value (touch_event, i, mir_touch_axis_touch_major),
mir_touch_event_axis_value (touch_event, i, mir_touch_axis_touch_minor),
mir_touch_event_axis_value (touch_event, i, mir_touch_axis_size));
}
}
static void
_gdk_mir_print_motion_event (const MirInputEvent *event)
{
const MirPointerEvent *pointer_event = mir_input_event_get_pointer_event (event);
if (!pointer_event)
return;
g_printerr ("MOTION\n");
g_printerr (" Device %lld\n", (long long int) mir_input_event_get_device_id (event));
g_printerr (" Action ");
switch (mir_pointer_event_action (pointer_event))
{
case mir_pointer_action_button_down:
g_printerr ("down");
break;
case mir_pointer_action_button_up:
g_printerr ("up");
break;
case mir_pointer_action_enter:
g_printerr ("enter");
break;
case mir_pointer_action_leave:
g_printerr ("leave");
break;
case mir_pointer_action_motion:
g_printerr ("motion");
break;
default:
g_printerr ("%u", mir_pointer_event_action (pointer_event));
}
g_printerr ("\n");
_gdk_mir_print_modifiers (mir_pointer_event_modifiers (pointer_event));
g_printerr (" Button State");
if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_primary))
g_printerr (" primary");
if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_secondary))
g_printerr (" secondary");
if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_tertiary))
g_printerr (" tertiary");
if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_back))
g_printerr (" back");
if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_forward))
g_printerr (" forward");
g_printerr ("\n");
g_printerr (" Offset (%f, %f)\n", mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_x),
mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_y));
g_printerr (" Scroll (%f, %f)\n", mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_hscroll),
mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_vscroll));
g_printerr (" Event Time %lli\n", (long long int) mir_input_event_get_event_time (event));
}
static void
_gdk_mir_print_input_event (const MirInputEvent *event)
{
g_printerr ("INPUT\n");
}
static void
_gdk_mir_print_window_event (const MirWindowEvent *event)
{
g_printerr ("WINDOW\n");
g_printerr (" Attribute ");
switch (mir_window_event_get_attribute (event))
{
case mir_window_attrib_type:
g_printerr ("type");
break;
case mir_window_attrib_state:
g_printerr ("state");
break;
case mir_window_attrib_swapinterval:
g_printerr ("swapinterval");
break;
case mir_window_attrib_focus:
g_printerr ("focus");
break;
case mir_window_attrib_dpi:
g_printerr ("dpi");
break;
case mir_window_attrib_visibility:
g_printerr ("visibility");
break;
case mir_window_attrib_preferred_orientation:
g_printerr ("preferred_orientation");
break;
default:
g_printerr ("%u", mir_window_event_get_attribute (event));
break;
}
g_printerr ("\n");
g_printerr (" Value %i\n", mir_window_event_get_attribute_value (event));
}
static void
_gdk_mir_print_resize_event (const MirResizeEvent *event)
{
g_printerr ("RESIZE\n");
g_printerr (" Size (%i, %i)\n", mir_resize_event_get_width (event), mir_resize_event_get_height (event));
}
static void
_gdk_mir_print_prompt_session_state_change_event (const MirPromptSessionEvent *event)
{
g_printerr ("PROMPT_SESSION_STATE_CHANGE\n");
g_printerr (" State ");
switch (mir_prompt_session_event_get_state (event))
{
case mir_prompt_session_state_stopped:
g_printerr ("stopped");
break;
case mir_prompt_session_state_started:
g_printerr ("started");
break;
case mir_prompt_session_state_suspended:
g_printerr ("suspended");
break;
default:
g_printerr ("%u", mir_prompt_session_event_get_state (event));
break;
}
g_printerr ("\n");
}
static void
_gdk_mir_print_orientation_event (const MirOrientationEvent *event)
{
g_printerr ("ORIENTATION\n");
g_printerr (" Direction ");
switch (mir_orientation_event_get_direction (event))
{
case mir_orientation_normal:
g_printerr ("normal");
break;
case mir_orientation_left:
g_printerr ("left");
break;
case mir_orientation_inverted:
g_printerr ("inverted");
break;
case mir_orientation_right:
g_printerr ("right");
break;
default:
g_printerr ("%u", mir_orientation_event_get_direction (event));
break;
}
g_printerr ("\n");
}
static void
_gdk_mir_print_close_event (void)
{
g_printerr ("CLOSED\n");
}
static void
_gdk_mir_print_keymap_event (const MirKeymapEvent *event)
{
g_printerr ("KEYMAP\n");
}
static void
_gdk_mir_print_window_output_event (const MirWindowOutputEvent *event)
{
g_printerr ("WINDOW_OUTPUT\n");
g_printerr (" DPI %d\n", mir_window_output_event_get_dpi (event));
g_printerr (" Form Factor ");
switch (mir_window_output_event_get_form_factor (event))
{
case mir_form_factor_unknown:
g_printerr ("unknown");
break;
case mir_form_factor_phone:
g_printerr ("phone");
break;
case mir_form_factor_tablet:
g_printerr ("tablet");
break;
case mir_form_factor_monitor:
g_printerr ("monitor");
break;
case mir_form_factor_tv:
g_printerr ("tv");
break;
case mir_form_factor_projector:
g_printerr ("projector");
break;
default:
g_printerr ("%u", mir_window_output_event_get_form_factor (event));
break;
}
g_printerr ("\n");
g_printerr (" Scale %f\n", mir_window_output_event_get_scale (event));
g_printerr (" Refresh Rate %lf\n", mir_window_output_event_get_refresh_rate (event));
g_printerr (" Output ID %u\n", mir_window_output_event_get_output_id (event));
}
static void
_gdk_mir_print_input_device_state_event (const MirInputDeviceStateEvent *event)
{
MirPointerButtons buttons;
MirInputEventModifiers modifiers;
gint i;
gint j;
g_printerr ("INPUT_DEVICE_STATE\n");
g_printerr (" Pointer Buttons\n");
buttons = mir_input_device_state_event_pointer_buttons (event);
if (buttons == 0)
g_printerr (" none\n");
else
{
if (buttons & mir_pointer_button_primary)
g_printerr (" primary\n");
if (buttons & mir_pointer_button_secondary)
g_printerr (" secondary\n");
if (buttons & mir_pointer_button_tertiary)
g_printerr (" tertiary\n");
if (buttons & mir_pointer_button_back)
g_printerr (" back\n");
if (buttons & mir_pointer_button_forward)
g_printerr (" forward\n");
if (buttons & mir_pointer_button_side)
g_printerr (" side\n");
if (buttons & mir_pointer_button_extra)
g_printerr (" extra\n");
if (buttons & mir_pointer_button_task)
g_printerr (" task\n");
}
g_printerr (" Pointer Axis\n");
g_printerr (" X %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_x));
g_printerr (" Y %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_y));
g_printerr (" V Scroll %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_vscroll));
g_printerr (" H Scroll %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_hscroll));
g_printerr (" Relative X %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_relative_x));
g_printerr (" Relative Y %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_relative_y));
g_printerr (" Time %ld\n", mir_input_device_state_event_time (event));
g_printerr (" Event Modifiers\n");
modifiers = mir_input_device_state_event_modifiers (event);
if (modifiers & mir_input_event_modifier_none)
g_printerr (" none\n");
if (modifiers & mir_input_event_modifier_alt)
g_printerr (" alt\n");
if (modifiers & mir_input_event_modifier_alt_left)
g_printerr (" alt_left\n");
if (modifiers & mir_input_event_modifier_alt_right)
g_printerr (" alt_right\n");
if (modifiers & mir_input_event_modifier_shift)
g_printerr (" shift\n");
if (modifiers & mir_input_event_modifier_shift_left)
g_printerr (" shift_left\n");
if (modifiers & mir_input_event_modifier_shift_right)
g_printerr (" shift_right\n");
if (modifiers & mir_input_event_modifier_sym)
g_printerr (" sym\n");
if (modifiers & mir_input_event_modifier_function)
g_printerr (" function\n");
if (modifiers & mir_input_event_modifier_ctrl)
g_printerr (" ctrl\n");
if (modifiers & mir_input_event_modifier_ctrl_left)
g_printerr (" ctrl_left\n");
if (modifiers & mir_input_event_modifier_ctrl_right)
g_printerr (" ctrl_right\n");
if (modifiers & mir_input_event_modifier_meta)
g_printerr (" meta\n");
if (modifiers & mir_input_event_modifier_meta_left)
g_printerr (" meta_left\n");
if (modifiers & mir_input_event_modifier_meta_right)
g_printerr (" meta_right\n");
if (modifiers & mir_input_event_modifier_caps_lock)
g_printerr (" caps_lock\n");
if (modifiers & mir_input_event_modifier_num_lock)
g_printerr (" num_lock\n");
if (modifiers & mir_input_event_modifier_scroll_lock)
g_printerr (" scroll_lock\n");
for (i = 0; i < mir_input_device_state_event_device_count (event); i++)
{
g_printerr (" Device %ld\n", mir_input_device_state_event_device_id (event, i));
for (j = 0; j < mir_input_device_state_event_device_pressed_keys_count (event, i); j++)
g_printerr (" Pressed %u\n", mir_input_device_state_event_device_pressed_keys_for_index (event, i, j));
g_printerr (" Pointer Buttons\n");
buttons = mir_input_device_state_event_device_pointer_buttons (event, i);
if (buttons == 0)
g_printerr (" none\n");
else
{
if (buttons & mir_pointer_button_primary)
g_printerr (" primary\n");
if (buttons & mir_pointer_button_secondary)
g_printerr (" secondary\n");
if (buttons & mir_pointer_button_tertiary)
g_printerr (" tertiary\n");
if (buttons & mir_pointer_button_back)
g_printerr (" back\n");
if (buttons & mir_pointer_button_forward)
g_printerr (" forward\n");
if (buttons & mir_pointer_button_side)
g_printerr (" side\n");
if (buttons & mir_pointer_button_extra)
g_printerr (" extra\n");
if (buttons & mir_pointer_button_task)
g_printerr (" task\n");
}
}
}
static void
_gdk_mir_print_window_placement_event (const MirWindowPlacementEvent *event)
{
MirRectangle rect = mir_window_placement_get_relative_position (event);
g_printerr ("WINDOW_PLACEMENT\n");
g_printerr (" X %d\n", rect.left);
g_printerr (" Y %d\n", rect.top);
g_printerr (" Width %u\n", rect.width);
g_printerr (" Height %u\n", rect.height);
}
void
_gdk_mir_print_event (const MirEvent *event)
{
const MirInputEvent *input_event;
switch (mir_event_get_type (event))
{
case mir_event_type_input:
input_event = mir_event_get_input_event (event);
switch (mir_input_event_get_type (input_event))
{
case mir_input_event_type_key:
_gdk_mir_print_key_event (mir_event_get_input_event (event));
break;
case mir_input_event_type_touch:
_gdk_mir_print_touch_event (mir_event_get_input_event (event));
break;
case mir_input_event_type_pointer:
_gdk_mir_print_motion_event (mir_event_get_input_event (event));
break;
default:
_gdk_mir_print_input_event (mir_event_get_input_event (event));
break;
}
break;
case mir_event_type_key:
_gdk_mir_print_key_event (mir_event_get_input_event (event));
break;
case mir_event_type_motion:
_gdk_mir_print_motion_event (mir_event_get_input_event (event));
break;
case mir_event_type_window:
_gdk_mir_print_window_event (mir_event_get_window_event (event));
break;
case mir_event_type_resize:
_gdk_mir_print_resize_event (mir_event_get_resize_event (event));
break;
case mir_event_type_prompt_session_state_change:
_gdk_mir_print_prompt_session_state_change_event (mir_event_get_prompt_session_event (event));
break;
case mir_event_type_orientation:
_gdk_mir_print_orientation_event (mir_event_get_orientation_event (event));
break;
case mir_event_type_close_window:
_gdk_mir_print_close_event ();
break;
case mir_event_type_keymap:
_gdk_mir_print_keymap_event (mir_event_get_keymap_event (event));
break;
case mir_event_type_window_output:
_gdk_mir_print_window_output_event (mir_event_get_window_output_event (event));
break;
case mir_event_type_input_device_state:
_gdk_mir_print_input_device_state_event (mir_event_get_input_device_state_event (event));
break;
case mir_event_type_window_placement:
_gdk_mir_print_window_placement_event (mir_event_get_window_placement_event (event));
break;
default:
g_printerr ("EVENT %u\n", mir_event_get_type (event));
break;
}
}

143
gdk/mir/gdkmir-private.h
View File

@ -1,143 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __GDK_PRIVATE_MIR_H__
#define __GDK_PRIVATE_MIR_H__
#include <epoxy/egl.h>
#include "gdkmir.h"
#include "gdkdisplay.h"
#include "gdkscreen.h"
#include "gdkdevicemanager.h"
#include "gdkglcontextprivate.h"
#include "gdkkeys.h"
#include "gdkwindowimpl.h"
typedef struct _GdkMirWindowImpl GdkMirWindowImpl;
typedef struct _GdkMirWindowReference GdkMirWindowReference;
typedef struct _GdkMirEventSource GdkMirEventSource;
#define GDK_TYPE_MIR_WINDOW_IMPL (gdk_mir_window_impl_get_type ())
#define GDK_MIR_WINDOW_IMPL(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_WINDOW_IMPL, GdkMirWindowImpl))
#define GDK_IS_WINDOW_IMPL_MIR(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_WINDOW_IMPL))
GType gdk_mir_window_impl_get_type (void);
struct _GdkMirGLContext
{
GdkGLContext parent_instance;
EGLContext egl_context;
EGLConfig egl_config;
gboolean is_attached;
};
struct _GdkMirGLContextClass
{
GdkGLContextClass parent_class;
};
typedef struct _GdkMirGLContext GdkMirGLContext;
typedef struct _GdkMirGLContextClass GdkMirGLContextClass;
#define GDK_MIR_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_MIR_GL_CONTEXT, GdkMirGLContext))
GdkDisplay *_gdk_mir_display_open (const gchar *display_name);
GdkScreen *_gdk_mir_screen_new (GdkDisplay *display);
GdkDeviceManager *_gdk_mir_device_manager_new (GdkDisplay *display);
GdkDevice *_gdk_mir_device_manager_get_keyboard (GdkDeviceManager *device_manager);
GdkKeymap *_gdk_mir_keymap_new (void);
gboolean _gdk_mir_keymap_key_is_modifier (GdkKeymap *keymap, guint keycode);
GdkDevice *_gdk_mir_keyboard_new (GdkDeviceManager *device_manager, const gchar *name);
GdkDevice *_gdk_mir_pointer_new (GdkDeviceManager *device_manager, const gchar *name);
void _gdk_mir_pointer_set_location (GdkDevice *pointer, gdouble x, gdouble y, GdkWindow *window, GdkModifierType mask);
const gchar *_gdk_mir_cursor_get_name (GdkCursor *cursor);
MirWindow *_gdk_mir_window_get_mir_window (GdkWindow *window);
GdkWindowImpl *_gdk_mir_window_impl_new (GdkDisplay *display, GdkWindow *window);
void _gdk_mir_window_impl_set_window_state (GdkMirWindowImpl *impl, MirWindowState state);
void _gdk_mir_window_impl_set_window_type (GdkMirWindowImpl *impl, MirWindowType type);
void _gdk_mir_window_set_scale (GdkWindow *window, gdouble scale);
void _gdk_mir_window_set_final_rect (GdkWindow *window, MirRectangle rect);
void _gdk_mir_window_impl_set_cursor_state (GdkMirWindowImpl *impl, gdouble x, gdouble y, gboolean cursor_inside, guint button_state);
void _gdk_mir_window_impl_get_cursor_state (GdkMirWindowImpl *impl, gdouble *x, gdouble *y, gboolean *cursor_inside, guint *button_state);
GdkMirEventSource *_gdk_mir_display_get_event_source (GdkDisplay *display);
GdkMirEventSource *_gdk_mir_event_source_new (GdkDisplay *display);
GdkMirWindowReference *_gdk_mir_event_source_get_window_reference (GdkWindow *window);
void _gdk_mir_window_reference_unref (GdkMirWindowReference *ref);
void _gdk_mir_event_source_queue (GdkMirWindowReference *window_ref, const MirEvent *event);
MirPixelFormat _gdk_mir_display_get_pixel_format (GdkDisplay *display, MirBufferUsage usage);
void _gdk_mir_display_focus_window (GdkDisplay *display, GdkWindow *window);
void _gdk_mir_display_unfocus_window (GdkDisplay *display, GdkWindow *window);
void _gdk_mir_display_create_paste (GdkDisplay *display,
const gchar * const *paste_formats,
gconstpointer paste_data,
gsize paste_size);
gboolean _gdk_mir_display_init_egl_display (GdkDisplay *display);
EGLDisplay _gdk_mir_display_get_egl_display (GdkDisplay *display);
gboolean _gdk_mir_display_have_egl_khr_create_context (GdkDisplay *display);
gboolean _gdk_mir_display_have_egl_buffer_age (GdkDisplay *display);
gboolean _gdk_mir_display_have_egl_swap_buffers_with_damage (GdkDisplay *display);
gboolean _gdk_mir_display_have_egl_surfaceless_context (GdkDisplay *display);
EGLSurface _gdk_mir_window_get_egl_surface (GdkWindow *window, EGLConfig config);
EGLSurface _gdk_mir_window_get_dummy_egl_surface (GdkWindow *window, EGLConfig config);
void _gdk_mir_print_event (const MirEvent *event);
gboolean gdk_mir_screen_get_setting (GdkScreen *screen,
const gchar *name,
GValue *value);
#endif /* __GDK_PRIVATE_MIR_H__ */

52
gdk/mir/gdkmir.h
View File

@ -1,52 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __GDK_MIR_H__
#define __GDK_MIR_H__
#include <gdk/gdk.h>
#include <mir_toolkit/mir_client_library.h>
G_BEGIN_DECLS
#define GDK_TYPE_MIR_DISPLAY (gdk_mir_display_get_type ())
#define GDK_IS_MIR_DISPLAY(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_DISPLAY))
#define GDK_TYPE_MIR_GL_CONTEXT (gdk_mir_gl_context_get_type ())
#define GDK_MIR_IS_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_MIR_GL_CONTEXT))
#define GDK_TYPE_MIR_WINDOW (gdk_mir_window_get_type ())
#define GDK_IS_MIR_WINDOW(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_WINDOW))
GDK_AVAILABLE_IN_3_16
GType gdk_mir_display_get_type (void);
GDK_AVAILABLE_IN_3_16
MirConnection *gdk_mir_display_get_mir_connection (GdkDisplay *display);
GDK_AVAILABLE_IN_3_16
GType gdk_mir_window_get_type (void);
GDK_DEPRECATED_IN_3_22
MirSurface *gdk_mir_window_get_mir_surface (GdkWindow *window);
GDK_AVAILABLE_IN_3_16
GType gdk_mir_gl_context_get_type (void) G_GNUC_CONST;
G_END_DECLS
#endif /* __GDK_MIR_H__ */

166
gdk/mir/gdkmircursor.c
View File

@ -1,166 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkcursorprivate.h"
#include "gdkmir.h"
#include "gdkmir-private.h"
typedef struct GdkMirCursor GdkMirCursor;
typedef struct GdkMirCursorClass GdkMirCursorClass;
#define GDK_TYPE_MIR_CURSOR (gdk_mir_cursor_get_type ())
#define GDK_MIR_CURSOR(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_CURSOR, GdkMirCursor))
#define GDK_MIR_CURSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_CURSOR, GdkMirCursorClass))
#define GDK_IS_MIR_CURSOR(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_CURSOR))
#define GDK_IS_MIR_CURSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_CURSOR))
#define GDK_MIR_CURSOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_CURSOR, GdkMirCursorClass))
struct GdkMirCursor
{
GdkCursor parent_instance;
gchar *name;
};
struct GdkMirCursorClass
{
GdkCursorClass parent_class;
};
G_DEFINE_TYPE (GdkMirCursor, gdk_mir_cursor, GDK_TYPE_CURSOR)
static const gchar *
get_cursor_name_for_cursor_type (GdkCursorType cursor_type)
{
switch (cursor_type)
{
case GDK_BLANK_CURSOR:
return mir_disabled_cursor_name;
case GDK_X_CURSOR:
case GDK_ARROW:
case GDK_CENTER_PTR:
case GDK_DRAFT_LARGE:
case GDK_DRAFT_SMALL:
case GDK_LEFT_PTR:
case GDK_RIGHT_PTR:
case GDK_TOP_LEFT_ARROW:
return mir_arrow_cursor_name;
case GDK_CLOCK:
case GDK_WATCH:
return mir_busy_cursor_name;
case GDK_XTERM:
return mir_caret_cursor_name;
case GDK_HAND1:
case GDK_HAND2:
return mir_pointing_hand_cursor_name;
return mir_open_hand_cursor_name;
case GDK_FLEUR:
return mir_closed_hand_cursor_name;
case GDK_LEFT_SIDE:
case GDK_LEFT_TEE:
case GDK_RIGHT_SIDE:
case GDK_RIGHT_TEE:
case GDK_SB_LEFT_ARROW:
case GDK_SB_RIGHT_ARROW:
return mir_horizontal_resize_cursor_name;
case GDK_BASED_ARROW_DOWN:
case GDK_BASED_ARROW_UP:
case GDK_BOTTOM_SIDE:
case GDK_BOTTOM_TEE:
case GDK_DOUBLE_ARROW:
case GDK_SB_DOWN_ARROW:
case GDK_SB_UP_ARROW:
case GDK_TOP_SIDE:
case GDK_TOP_TEE:
return mir_vertical_resize_cursor_name;
case GDK_BOTTOM_LEFT_CORNER:
case GDK_LL_ANGLE:
case GDK_TOP_RIGHT_CORNER:
case GDK_UR_ANGLE:
return mir_diagonal_resize_bottom_to_top_cursor_name;
case GDK_BOTTOM_RIGHT_CORNER:
case GDK_LR_ANGLE:
case GDK_SIZING:
case GDK_TOP_LEFT_CORNER:
case GDK_UL_ANGLE:
return mir_diagonal_resize_top_to_bottom_cursor_name;
return mir_omnidirectional_resize_cursor_name;
case GDK_SB_V_DOUBLE_ARROW:
return mir_vsplit_resize_cursor_name;
case GDK_SB_H_DOUBLE_ARROW:
return mir_hsplit_resize_cursor_name;
default:
return mir_default_cursor_name;
}
}
GdkCursor *
_gdk_mir_cursor_new_for_name (GdkDisplay *display, const gchar *name)
{
GdkMirCursor *cursor;
cursor = g_object_new (GDK_TYPE_MIR_CURSOR, "display", display, "cursor-type", GDK_CURSOR_IS_PIXMAP, NULL);
cursor->name = g_strdup (name);
return GDK_CURSOR (cursor);
}
GdkCursor *
_gdk_mir_cursor_new_for_type (GdkDisplay *display, GdkCursorType type)
{
GdkMirCursor *cursor;
cursor = g_object_new (GDK_TYPE_MIR_CURSOR, "display", display, "cursor-type", type, NULL);
cursor->name = g_strdup (get_cursor_name_for_cursor_type (type));
return GDK_CURSOR (cursor);
}
const gchar *
_gdk_mir_cursor_get_name (GdkCursor *cursor)
{
GdkMirCursor *mir_cursor = GDK_MIR_CURSOR (cursor);
return mir_cursor->name;
}
static void
gdk_mir_cursor_init (GdkMirCursor *cursor)
{
}
static void
gdk_mir_cursor_finalize (GObject *object)
{
GdkMirCursor *mir_cursor = GDK_MIR_CURSOR (object);
g_free (mir_cursor->name);
G_OBJECT_CLASS (gdk_mir_cursor_parent_class)->finalize (object);
}
static void
gdk_mir_cursor_class_init (GdkMirCursorClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gdk_mir_cursor_finalize;
}

125
gdk/mir/gdkmirdevicemanager.c
View File

@ -1,125 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkdevicemanagerprivate.h"
#include "gdkdisplayprivate.h"
#include "gdkdeviceprivate.h"
#include "gdkseatdefaultprivate.h"
#include "gdkmir.h"
#include "gdkmir-private.h"
typedef struct GdkMirDeviceManager GdkMirDeviceManager;
typedef struct GdkMirDeviceManagerClass GdkMirDeviceManagerClass;
#define GDK_TYPE_MIR_DEVICE_MANAGER (gdk_mir_device_manager_get_type ())
#define GDK_MIR_DEVICE_MANAGER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_DEVICE_MANAGER, GdkMirDeviceManager))
#define GDK_MIR_DEVICE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_DEVICE_MANAGER, GdkMirDeviceManagerClass))
#define GDK_IS_MIR_DEVICE_MANAGER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_DEVICE_MANAGER))
#define GDK_IS_MIR_DEVICE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_DEVICE_MANAGER))
#define GDK_MIR_DEVICE_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_DEVICE_MANAGER, GdkMirDeviceManagerClass))
struct GdkMirDeviceManager
{
GdkDeviceManager parent_instance;
GdkDevice *pointer;
GdkDevice *keyboard;
};
struct GdkMirDeviceManagerClass
{
GdkDeviceManagerClass parent_class;
};
G_DEFINE_TYPE (GdkMirDeviceManager, gdk_mir_device_manager, GDK_TYPE_DEVICE_MANAGER)
GdkDeviceManager *
_gdk_mir_device_manager_new (GdkDisplay *display)
{
return g_object_new (GDK_TYPE_MIR_DEVICE_MANAGER, "display", display, NULL);
}
static GList *
gdk_mir_device_manager_list_devices (GdkDeviceManager *device_manager,
GdkDeviceType type)
{
GdkMirDeviceManager *dm = GDK_MIR_DEVICE_MANAGER (device_manager);
if (type == GDK_DEVICE_TYPE_MASTER)
{
GList *devices;
devices = g_list_append (NULL, dm->keyboard);
devices = g_list_append (devices, dm->pointer);
return devices;
}
return NULL;
}
static GdkDevice *
gdk_mir_device_manager_get_client_pointer (GdkDeviceManager *device_manager)
{
return GDK_MIR_DEVICE_MANAGER (device_manager)->pointer;
}
GdkDevice *
_gdk_mir_device_manager_get_keyboard (GdkDeviceManager *device_manager)
{
return GDK_MIR_DEVICE_MANAGER (device_manager)->keyboard;
}
static void
gdk_mir_device_manager_init (GdkMirDeviceManager *device_manager)
{
}
static void
gdk_mir_device_manager_constructed (GObject *object)
{
GdkMirDeviceManager *device_manager = GDK_MIR_DEVICE_MANAGER (object);
GdkDisplay *display;
GdkSeat *seat;
device_manager->keyboard = _gdk_mir_keyboard_new (GDK_DEVICE_MANAGER (device_manager), "Mir Keyboard");
device_manager->pointer = _gdk_mir_pointer_new (GDK_DEVICE_MANAGER (device_manager), "Mir Pointer");
_gdk_device_set_associated_device (device_manager->keyboard, device_manager->pointer);
_gdk_device_set_associated_device (device_manager->pointer, device_manager->keyboard);
display = gdk_device_manager_get_display (GDK_DEVICE_MANAGER (device_manager));
seat = gdk_seat_default_new_for_master_pair (device_manager->pointer, device_manager->keyboard);
gdk_display_add_seat (display, seat);
g_object_unref (seat);
G_OBJECT_CLASS (gdk_mir_device_manager_parent_class)->constructed (object);
}
static void
gdk_mir_device_manager_class_init (GdkMirDeviceManagerClass *klass)
{
GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
device_manager_class->list_devices = gdk_mir_device_manager_list_devices;
device_manager_class->get_client_pointer = gdk_mir_device_manager_get_client_pointer;
object_class->constructed = gdk_mir_device_manager_constructed;
}

832
gdk/mir/gdkmirdisplay.c
View File

@ -1,832 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkdisplayprivate.h"
#include "gdkmonitorprivate.h"
#include "gdkinternals.h"
#include "gdkmir.h"
#include "gdkmir-private.h"
#include <string.h>
#include <com/ubuntu/content/glib/content-hub-glib.h>
#define GDK_TYPE_DISPLAY_MIR (gdk_mir_display_get_type ())
#define GDK_MIR_DISPLAY(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_MIR, GdkMirDisplay))
#define GDK_MIR_DISPLAY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DISPLAY_MIR, GdkMirDisplayClass))
#define GDK_IS_MIR_DISPLAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_DISPLAY))
#define GDK_MIR_DISPLAY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_DISPLAY, GdkMirDisplayImplClass))
typedef struct GdkMirDisplay
{
GdkDisplay parent_instance;
/* Connection to Mir server */
MirConnection *connection;
const MirDisplayConfig *config;
GList *monitors;
/* Event source */
GdkMirEventSource *event_source;
/* Serial number? */
gulong serial;
/* Screen information */
GdkScreen *screen;
GdkKeymap *keymap;
GdkWindow *focused_window;
MirPixelFormat sw_pixel_format;
MirPixelFormat hw_pixel_format;
EGLDisplay egl_display;
guint have_egl_khr_create_context : 1;
guint have_egl_buffer_age : 1;
guint have_egl_swap_buffers_with_damage : 1;
guint have_egl_surfaceless_context : 1;
ContentHubService *content_service;
ContentHubHandler *content_handler;
GVariant *paste_data;
} GdkMirDisplay;
typedef struct GdkMirDisplayClass
{
GdkDisplayClass parent_class;
} GdkMirDisplayClass;
static void get_pixel_formats (MirConnection *, MirPixelFormat *sw, MirPixelFormat *hw);
/**
* SECTION:mir_interaction
* @Short_description: Mir backend-specific functions
* @Title: Mir Interaction
*
* The functions in this section are specific to the GDK Mir backend.
* To use them, you need to include the <literal>&lt;gdk/gdkmir.h&gt;</literal>
* header and use the Mir-specific pkg-config files to build your
* application (either <literal>gdk-mir-3.0</literal> or
* <literal>gtk+-mir-3.0</literal>).
*
* To make your code compile with other GDK backends, guard backend-specific
* calls by an ifdef as follows. Since GDK may be built with multiple
* backends, you should also check for the backend that is in use (e.g. by
* using the GDK_IS_MIR_DISPLAY() macro).
* |[
* #ifdef GDK_WINDOWING_MIR
* if (GDK_IS_MIR_DISPLAY (display))
* {
* /&ast; make Mir-specific calls here &ast;/
* }
* else
* #endif
* #ifdef GDK_WINDOWING_X11
* if (GDK_IS_X11_DISPLAY (display))
* {
* /&ast; make X11-specific calls here &ast;/
* }
* else
* #endif
* g_error ("Unsupported GDK backend");
* ]|
*/
G_DEFINE_TYPE (GdkMirDisplay, gdk_mir_display, GDK_TYPE_DISPLAY)
static void
config_changed_cb (MirConnection *connection,
void *context)
{
GdkMirDisplay *display = context;
GdkMonitor *monitor;
const MirOutput *output;
const MirOutputMode *mode;
gint i;
g_list_free_full (display->monitors, g_object_unref);
g_clear_pointer (&display->config, mir_display_config_release);
display->config = mir_connection_create_display_configuration (display->connection);
display->monitors = NULL;
for (i = mir_display_config_get_num_outputs (display->config) - 1; i >= 0; i--)
{
output = mir_display_config_get_output (display->config, i);
if (!mir_output_is_enabled (output))
continue;
mode = mir_output_get_current_mode (output);
monitor = gdk_monitor_new (GDK_DISPLAY (display));
gdk_monitor_set_position (monitor,
mir_output_get_position_x (output),
mir_output_get_position_y (output));
gdk_monitor_set_size (monitor,
mir_output_mode_get_width (mode),
mir_output_mode_get_height (mode));
gdk_monitor_set_physical_size (monitor,
mir_output_get_physical_width_mm (output),
mir_output_get_physical_height_mm (output));
gdk_monitor_set_scale_factor (monitor,
(gint) mir_output_get_scale_factor (output));
gdk_monitor_set_refresh_rate (monitor,
(gint) mir_output_mode_get_refresh_rate (mode));
display->monitors = g_list_prepend (display->monitors, monitor);
}
}
static void
pasteboard_changed_cb (GdkMirDisplay *display,
gpointer user_data)
{
g_clear_pointer (&display->paste_data, g_variant_unref);
}
GdkDisplay *
_gdk_mir_display_open (const gchar *display_name)
{
MirConnection *connection;
MirPixelFormat sw_pixel_format, hw_pixel_format;
GdkMirDisplay *display;
GDBusConnection *session;
GError *error = NULL;
connection = mir_connect_sync (NULL, g_get_prgname ());
if (!connection)
return NULL;
if (!mir_connection_is_valid (connection))
{
mir_connection_release (connection);
return NULL;
}
get_pixel_formats (connection, &sw_pixel_format, &hw_pixel_format);
if (sw_pixel_format == mir_pixel_format_invalid ||
hw_pixel_format == mir_pixel_format_invalid)
{
g_printerr ("Mir display does not support required pixel formats\n");
mir_connection_release (connection);
return NULL;
}
display = g_object_new (GDK_TYPE_MIR_DISPLAY, NULL);
display->connection = connection;
config_changed_cb (display->connection, display);
mir_connection_set_display_config_change_callback (display->connection, config_changed_cb, display);
GDK_DISPLAY (display)->device_manager = _gdk_mir_device_manager_new (GDK_DISPLAY (display));
display->screen = _gdk_mir_screen_new (GDK_DISPLAY (display));
display->sw_pixel_format = sw_pixel_format;
display->hw_pixel_format = hw_pixel_format;
session = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (session == NULL)
{
g_error ("Error connecting to D-Bus session bus: %s", error->message);
g_clear_error (&error);
mir_connection_release (connection);
return NULL;
}
display->content_service = content_hub_service_proxy_new_sync (
session,
G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
"com.ubuntu.content.dbus.Service",
"/",
NULL,
NULL);
g_signal_connect_swapped (
display->content_service,
"pasteboard-changed",
G_CALLBACK (pasteboard_changed_cb),
display);
display->content_handler = content_hub_handler_skeleton_new ();
g_dbus_interface_skeleton_export (
G_DBUS_INTERFACE_SKELETON (display->content_handler),
session,
"/org/gnome/gtk/content/handler",
NULL);
g_object_unref (session);
content_hub_service_call_register_import_export_handler_sync (
display->content_service,
g_application_get_application_id (g_application_get_default ()),
"/org/gnome/gtk/content/handler",
NULL,
NULL);
content_hub_service_call_handler_active_sync (
display->content_service,
g_application_get_application_id (g_application_get_default ()),
NULL,
NULL);
g_signal_emit_by_name (display, "opened");
return GDK_DISPLAY (display);
}
/**
* gdk_mir_display_get_mir_connection
* @display: (type GdkMirDisplay): a #GdkDisplay
*
* Returns the #MirConnection for a #GdkDisplay
*
* Returns: (transfer none): a #MirConnection
*
* Since: 3.14
*/
struct MirConnection *
gdk_mir_display_get_mir_connection (GdkDisplay *display)
{
g_return_val_if_fail (GDK_IS_MIR_DISPLAY (display), NULL);
return GDK_MIR_DISPLAY (display)->connection;
}
GdkMirEventSource *
_gdk_mir_display_get_event_source (GdkDisplay *display)
{
g_return_val_if_fail (GDK_IS_MIR_DISPLAY (display), NULL);
return GDK_MIR_DISPLAY (display)->event_source;
}
static void
gdk_mir_display_dispose (GObject *object)
{
GdkMirDisplay *display = GDK_MIR_DISPLAY (object);
g_clear_pointer (&display->paste_data, g_variant_unref);
g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (display->content_handler));
g_clear_object (&display->content_handler);
g_clear_object (&display->content_service);
g_clear_object (&display->screen);
g_clear_object (&display->keymap);
g_clear_pointer (&display->event_source, g_source_unref);
g_list_free_full (display->monitors, g_object_unref);
display->monitors = NULL;
G_OBJECT_CLASS (gdk_mir_display_parent_class)->dispose (object);
}
static void
gdk_mir_display_finalize (GObject *object)
{
GdkMirDisplay *display = GDK_MIR_DISPLAY (object);
g_clear_pointer (&display->config, mir_display_config_release);
mir_connection_release (display->connection);
G_OBJECT_CLASS (gdk_mir_display_parent_class)->finalize (object);
}
static const gchar *
gdk_mir_display_get_name (GdkDisplay *display)
{
return "Mir";
}
static GdkScreen *
gdk_mir_display_get_default_screen (GdkDisplay *display)
{
return GDK_MIR_DISPLAY (display)->screen;
}
static void
gdk_mir_display_beep (GdkDisplay *display)
{
/* No system level beep... */
}
static void
gdk_mir_display_sync (GdkDisplay *display)
{
}
static void
gdk_mir_display_flush (GdkDisplay *display)
{
}
static gboolean
gdk_mir_display_has_pending (GdkDisplay *display)
{
/* We don't need to poll for events - so nothing pending */
return FALSE;
}
static void
gdk_mir_display_queue_events (GdkDisplay *display)
{
/* We don't need to poll for events - so don't do anything*/
}
static void
gdk_mir_display_make_default (GdkDisplay *display)
{
}
static GdkWindow *
gdk_mir_display_get_default_group (GdkDisplay *display)
{
return NULL;
}
static gboolean
gdk_mir_display_supports_shapes (GdkDisplay *display)
{
/* Mir doesn't support shaped windows */
return FALSE;
}
static gboolean
gdk_mir_display_supports_input_shapes (GdkDisplay *display)
{
return FALSE;
}
static gboolean
gdk_mir_display_supports_cursor_alpha (GdkDisplay *display)
{
return FALSE;
}
static gboolean
gdk_mir_display_supports_cursor_color (GdkDisplay *display)
{
return FALSE;
}
static void
gdk_mir_display_get_default_cursor_size (GdkDisplay *display,
guint *width,
guint *height)
{
*width = *height = 32; // FIXME: Random value
}
static void
gdk_mir_display_get_maximal_cursor_size (GdkDisplay *display,
guint *width,
guint *height)
{
*width = *height = 32; // FIXME: Random value
}
static GdkAppLaunchContext *
gdk_mir_display_get_app_launch_context (GdkDisplay *display)
{
return NULL;
}
static gulong
gdk_mir_display_get_next_serial (GdkDisplay *display)
{
return GDK_MIR_DISPLAY (display)->serial++;
}
static void
gdk_mir_display_notify_startup_complete (GdkDisplay *display,
const gchar *startup_id)
{
}
static void
gdk_mir_display_create_window_impl (GdkDisplay *display,
GdkWindow *window,
GdkWindow *real_parent,
GdkEventMask event_mask,
GdkWindowAttr *attributes)
{
if (attributes->wclass == GDK_INPUT_OUTPUT)
{
window->impl = _gdk_mir_window_impl_new (display, window);
window->impl_window = window;
}
else /* attributes->wclass == GDK_INPUT_ONLY */
{
window->impl = g_object_ref (real_parent->impl);
window->impl_window = real_parent;
/* FIXME: this is called in gdk_window_new, which sets window->impl_window
* back to window after this function returns. */
}
}
static GdkKeymap *
gdk_mir_display_get_keymap (GdkDisplay *display)
{
return GDK_MIR_DISPLAY (display)->keymap;
}
static void
gdk_mir_display_push_error_trap (GdkDisplay *display)
{
}
static gint
gdk_mir_display_pop_error_trap (GdkDisplay *display,
gboolean ignored)
{
return 0;
}
static gint
gdk_mir_display_text_property_to_utf8_list (GdkDisplay *display,
GdkAtom encoding,
gint format,
const guchar *text,
gint length,
gchar ***list)
{
GPtrArray *array;
const gchar *ptr;
gsize chunk_len;
gchar *copy;
guint nitems;
ptr = (const gchar *) text;
array = g_ptr_array_new ();
/* split text into utf-8 strings */
while (ptr < (const gchar *) &text[length])
{
chunk_len = strlen (ptr);
if (g_utf8_validate (ptr, chunk_len, NULL))
{
copy = g_strndup (ptr, chunk_len);
g_ptr_array_add (array, copy);
}
ptr = &ptr[chunk_len + 1];
}
nitems = array->len;
g_ptr_array_add (array, NULL);
if (list)
*list = (gchar **) g_ptr_array_free (array, FALSE);
else
g_ptr_array_free (array, TRUE);
return nitems;
}
static gchar *
gdk_mir_display_utf8_to_string_target (GdkDisplay *display,
const gchar *str)
{
return NULL;
}
static void
get_pixel_formats (MirConnection *connection,
MirPixelFormat *sw_pixel_format,
MirPixelFormat *hw_pixel_format)
{
MirPixelFormat formats[mir_pixel_formats];
unsigned int n_formats, i;
mir_connection_get_available_surface_formats (connection, formats,
mir_pixel_formats, &n_formats);
if (sw_pixel_format)
{
*sw_pixel_format = mir_pixel_format_invalid;
for (i = 0; i < n_formats && *sw_pixel_format == mir_pixel_format_invalid; i++)
{
switch (formats[i])
{
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_rgb_565:
*sw_pixel_format = formats[i];
break;
default:
break;
}
}
}
if (hw_pixel_format)
{
*hw_pixel_format = mir_pixel_format_invalid;
for (i = 0; i < n_formats && *hw_pixel_format == mir_pixel_format_invalid; i++)
{
switch (formats[i])
{
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_rgb_565:
*hw_pixel_format = formats[i];
break;
default:
break;
}
}
}
}
MirPixelFormat
_gdk_mir_display_get_pixel_format (GdkDisplay *display,
MirBufferUsage usage)
{
GdkMirDisplay *mir_dpy = GDK_MIR_DISPLAY (display);
if (usage == mir_buffer_usage_hardware)
return mir_dpy->hw_pixel_format;
return mir_dpy->sw_pixel_format;
}
void
_gdk_mir_display_focus_window (GdkDisplay *display,
GdkWindow *window)
{
GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
g_set_object (&mir_display->focused_window, window);
}
void
_gdk_mir_display_unfocus_window (GdkDisplay *display,
GdkWindow *window)
{
GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
if (window == mir_display->focused_window)
g_clear_object (&mir_display->focused_window);
}
void
_gdk_mir_display_create_paste (GdkDisplay *display,
const gchar * const *paste_formats,
gconstpointer paste_data,
gsize paste_size)
{
GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
MirWindow *mir_window;
MirWindowId *mir_window_id;
if (!mir_display->focused_window)
return;
mir_window = _gdk_mir_window_get_mir_window (mir_display->focused_window);
if (!mir_window)
return;
mir_window_id = mir_window_request_window_id_sync (mir_window);
if (!mir_window_id)
return;
if (mir_window_id_is_valid (mir_window_id))
content_hub_service_call_create_paste_sync (
mir_display->content_service,
g_application_get_application_id (g_application_get_default ()),
mir_window_id_as_string (mir_window_id),
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, paste_data, paste_size, sizeof (guchar)),
paste_formats,
NULL,
NULL,
NULL);
mir_window_id_release (mir_window_id);
}
gboolean
_gdk_mir_display_init_egl_display (GdkDisplay *display)
{
GdkMirDisplay *mir_dpy = GDK_MIR_DISPLAY (display);
EGLint major_version, minor_version;
EGLDisplay *dpy;
if (mir_dpy->egl_display)
return TRUE;
dpy = eglGetDisplay (mir_connection_get_egl_native_display (mir_dpy->connection));
if (dpy == NULL)
return FALSE;
if (!eglInitialize (dpy, &major_version, &minor_version))
return FALSE;
if (!eglBindAPI (EGL_OPENGL_API))
return FALSE;
mir_dpy->egl_display = dpy;
mir_dpy->have_egl_khr_create_context =
epoxy_has_egl_extension (dpy, "EGL_KHR_create_context");
mir_dpy->have_egl_buffer_age =
epoxy_has_egl_extension (dpy, "EGL_EXT_buffer_age");
mir_dpy->have_egl_swap_buffers_with_damage =
epoxy_has_egl_extension (dpy, "EGL_EXT_swap_buffers_with_damage");
mir_dpy->have_egl_surfaceless_context =
epoxy_has_egl_extension (dpy, "EGL_KHR_surfaceless_context");
GDK_NOTE (OPENGL,
g_print ("EGL API version %d.%d found\n"
" - Vendor: %s\n"
" - Version: %s\n"
" - Client APIs: %s\n"
" - Extensions:\n"
"\t%s\n",
major_version,
minor_version,
eglQueryString (dpy, EGL_VENDOR),
eglQueryString (dpy, EGL_VERSION),
eglQueryString (dpy, EGL_CLIENT_APIS),
eglQueryString (dpy, EGL_EXTENSIONS)));
return TRUE;
}
static gboolean
gdk_mir_display_make_gl_context_current (GdkDisplay *display,
GdkGLContext *context)
{
EGLDisplay egl_display = _gdk_mir_display_get_egl_display (display);
GdkMirGLContext *mir_context;
GdkWindow *window;
EGLSurface egl_surface;
if (context == NULL)
{
eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
return TRUE;
}
mir_context = GDK_MIR_GL_CONTEXT (context);
window = gdk_gl_context_get_window (context);
if (mir_context->is_attached || gdk_draw_context_is_drawing (GDK_DRAW_CONTEXT (context)))
{
egl_surface = _gdk_mir_window_get_egl_surface (window,
mir_context->egl_config);
}
else
{
if (_gdk_mir_display_have_egl_surfaceless_context (display))
egl_surface = EGL_NO_SURFACE;
else
egl_surface = _gdk_mir_window_get_dummy_egl_surface (window,
mir_context->egl_config);
}
if (!eglMakeCurrent (egl_display, egl_surface, egl_surface, mir_context->egl_context))
{
g_warning ("eglMakeCurrent failed");
return FALSE;
}
return TRUE;
}
EGLDisplay _gdk_mir_display_get_egl_display (GdkDisplay *display)
{
return GDK_MIR_DISPLAY (display)->egl_display;
}
gboolean _gdk_mir_display_have_egl_khr_create_context (GdkDisplay *display)
{
return GDK_MIR_DISPLAY (display)->have_egl_khr_create_context;
}
gboolean _gdk_mir_display_have_egl_buffer_age (GdkDisplay *display)
{
/* FIXME: this is not really supported by mir yet (despite is advertised) */
// return GDK_MIR_DISPLAY (display)->have_egl_buffer_age;
return FALSE;
}
gboolean _gdk_mir_display_have_egl_swap_buffers_with_damage (GdkDisplay *display)
{
/* FIXME: this is not really supported by mir yet (despite is advertised) */
// return GDK_MIR_DISPLAY (display)->have_egl_swap_buffers_with_damage;
return FALSE;
}
gboolean _gdk_mir_display_have_egl_surfaceless_context (GdkDisplay *display)
{
return GDK_MIR_DISPLAY (display)->have_egl_surfaceless_context;
}
static int
gdk_mir_display_get_n_monitors (GdkDisplay *display)
{
return g_list_length (GDK_MIR_DISPLAY (display)->monitors);
}
static GdkMonitor *
gdk_mir_display_get_monitor (GdkDisplay *display,
int index)
{
g_return_val_if_fail (0 <= index && index < gdk_display_get_n_monitors (display), NULL);
return g_list_nth_data (GDK_MIR_DISPLAY (display)->monitors, index);
}
static gboolean
gdk_mir_display_get_setting (GdkDisplay *display,
const char *name,
GValue *value)
{
return gdk_mir_screen_get_setting (GDK_MIR_DISPLAY (display)->screen, name, value);
}
static void
gdk_mir_display_init (GdkMirDisplay *display)
{
display->event_source = _gdk_mir_event_source_new (GDK_DISPLAY (display));
display->keymap = _gdk_mir_keymap_new ();
}
static void
gdk_mir_display_class_init (GdkMirDisplayClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GdkDisplayClass *display_class = GDK_DISPLAY_CLASS (klass);
object_class->dispose = gdk_mir_display_dispose;
object_class->finalize = gdk_mir_display_finalize;
display_class->window_type = gdk_mir_window_get_type ();
display_class->get_name = gdk_mir_display_get_name;
display_class->get_default_screen = gdk_mir_display_get_default_screen;
display_class->beep = gdk_mir_display_beep;
display_class->sync = gdk_mir_display_sync;
display_class->flush = gdk_mir_display_flush;
display_class->has_pending = gdk_mir_display_has_pending;
display_class->queue_events = gdk_mir_display_queue_events;
display_class->make_default = gdk_mir_display_make_default;
display_class->get_default_group = gdk_mir_display_get_default_group;
display_class->supports_shapes = gdk_mir_display_supports_shapes;
display_class->supports_input_shapes = gdk_mir_display_supports_input_shapes;
display_class->supports_cursor_alpha = gdk_mir_display_supports_cursor_alpha;
display_class->supports_cursor_color = gdk_mir_display_supports_cursor_color;
display_class->get_default_cursor_size = gdk_mir_display_get_default_cursor_size;
display_class->get_maximal_cursor_size = gdk_mir_display_get_maximal_cursor_size;
display_class->get_app_launch_context = gdk_mir_display_get_app_launch_context;
display_class->get_next_serial = gdk_mir_display_get_next_serial;
display_class->notify_startup_complete = gdk_mir_display_notify_startup_complete;
display_class->create_window_impl = gdk_mir_display_create_window_impl;
display_class->get_keymap = gdk_mir_display_get_keymap;
display_class->push_error_trap = gdk_mir_display_push_error_trap;
display_class->pop_error_trap = gdk_mir_display_pop_error_trap;
display_class->text_property_to_utf8_list = gdk_mir_display_text_property_to_utf8_list;
display_class->utf8_to_string_target = gdk_mir_display_utf8_to_string_target;
display_class->make_gl_context_current = gdk_mir_display_make_gl_context_current;
display_class->get_n_monitors = gdk_mir_display_get_n_monitors;
display_class->get_monitor = gdk_mir_display_get_monitor;
display_class->get_setting = gdk_mir_display_get_setting;
}

835
gdk/mir/gdkmireventsource.c
View File

@ -1,835 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkinternals.h"
#include "gdkdisplayprivate.h"
#include "gdkmir.h"
#include "gdkmir-private.h"
#include <mir_toolkit/events/window_placement.h>
#define NANO_TO_MILLI(x) ((x) / 1000000)
struct _GdkMirWindowReference {
GdkMirEventSource *source;
GdkWindow *window;
gint ref_count;
};
typedef struct {
GdkMirWindowReference *window_ref;
const MirEvent *event;
} GdkMirQueuedEvent;
struct _GdkMirEventSource
{
GSource parent_instance;
GMutex mir_event_lock;
GQueue mir_events;
gboolean log_events;
GdkDisplay *display;
};
static void
send_event (GdkWindow *window, GdkDevice *device, GdkEvent *event)
{
GdkDisplay *display;
GList *node;
display = gdk_window_get_display (window);
gdk_event_set_device (event, device);
gdk_event_set_source_device (event, device);
gdk_event_set_display (event, display);
event->any.window = g_object_ref (window);
node = _gdk_event_queue_append (display, event);
_gdk_windowing_got_event (display, node, event, _gdk_display_get_next_serial (display));
}
static void
set_key_event_string (GdkEventKey *event)
{
gunichar c = 0;
if (event->keyval != GDK_KEY_VoidSymbol)
c = gdk_keyval_to_unicode (event->keyval);
if (c)
{
gchar buf[7];
gint len;
gsize bytes_written;
/* Apply the control key - Taken from Xlib
*/
if (event->state & GDK_CONTROL_MASK)
{
if ((c >= '@' && c < '\177') || c == ' ') c &= 0x1F;
else if (c == '2')
{
event->string = g_memdup ("\0\0", 2);
event->length = 1;
buf[0] = '\0';
return;
}
else if (c >= '3' && c <= '7') c -= ('3' - '\033');
else if (c == '8') c = '\177';
else if (c == '/') c = '_' & 0x1F;
}
len = g_unichar_to_utf8 (c, buf);
buf[len] = '\0';
event->string = g_locale_from_utf8 (buf, len,
NULL, &bytes_written,
NULL);
if (event->string)
event->length = bytes_written;
}
else if (event->keyval == GDK_KEY_Escape)
{
event->length = 1;
event->string = g_strdup ("\033");
}
else if (event->keyval == GDK_KEY_Return ||
event->keyval == GDK_KEY_KP_Enter)
{
event->length = 1;
event->string = g_strdup ("\r");
}
if (!event->string)
{
event->length = 0;
event->string = g_strdup ("");
}
}
static void
generate_key_event (GdkWindow *window, GdkEventType type, guint state, guint keyval, guint16 keycode, gboolean is_modifier, guint32 event_time)
{
GdkEvent *event;
GdkDisplay *display;
GdkSeat *seat;
GdkDevice *keyboard;
event = gdk_event_new (type);
event->key.state = state;
event->key.keyval = keyval;
event->key.hardware_keycode = keycode + 8;
gdk_event_set_scancode (event, keycode + 8);
event->key.is_modifier = is_modifier;
event->key.time = event_time;
set_key_event_string (&event->key);
display = gdk_window_get_display (window);
seat = gdk_display_get_default_seat (display);
keyboard = gdk_seat_get_keyboard (seat);
send_event (window, keyboard, event);
}
static GdkDevice *
get_pointer (GdkWindow *window)
{
GdkDisplay *display;
GdkSeat *seat;
GdkDevice *pointer;
display = gdk_window_get_display (window);
seat = gdk_display_get_default_seat (display);
pointer = gdk_seat_get_pointer (seat);
return pointer;
}
static void
generate_button_event (GdkWindow *window, GdkEventType type, gdouble x, gdouble y, guint button, guint state, guint32 event_time)
{
GdkEvent *event;
event = gdk_event_new (type);
event->button.x = x;
event->button.y = y;
event->button.state = state;
event->button.button = button;
event->button.time = event_time;
send_event (window, get_pointer (window), event);
}
static void
generate_scroll_event (GdkWindow *window, gdouble x, gdouble y, gdouble delta_x, gdouble delta_y, guint state, guint32 event_time)
{
GdkEvent *event;
event = gdk_event_new (GDK_SCROLL);
event->scroll.x = x;
event->scroll.y = y;
event->scroll.state = state;
event->scroll.time = event_time;
if (ABS (delta_x) == 1 && delta_y == 0)
{
event->scroll.direction = (delta_x < 0) ? GDK_SCROLL_LEFT : GDK_SCROLL_RIGHT;
}
else if (ABS (delta_y) == 1 && delta_x == 0)
{
event->scroll.direction = (delta_y < 0) ? GDK_SCROLL_DOWN : GDK_SCROLL_UP;
}
else
{
event->scroll.direction = GDK_SCROLL_SMOOTH;
event->scroll.delta_x = delta_x;
event->scroll.delta_y = -delta_y;
}
send_event (window, get_pointer (window), event);
}
static void
generate_motion_event (GdkWindow *window, gdouble x, gdouble y, guint state, guint32 event_time)
{
GdkEvent *event;
event = gdk_event_new (GDK_MOTION_NOTIFY);
event->motion.x = x;
event->motion.y = y;
event->motion.state = state;
event->motion.is_hint = FALSE;
event->motion.time = event_time;
send_event (window, get_pointer (window), event);
}
static void
generate_crossing_event (GdkWindow *window, GdkEventType type, gdouble x, gdouble y, guint32 event_time)
{
GdkEvent *event;
event = gdk_event_new (type);
event->crossing.x = x;
event->crossing.y = y;
event->crossing.mode = GDK_CROSSING_NORMAL;
event->crossing.detail = GDK_NOTIFY_ANCESTOR;
event->crossing.focus = TRUE;
event->crossing.time = event_time;
send_event (window, get_pointer (window), event);
}
static void
generate_focus_event (GdkWindow *window, gboolean focused)
{
GdkEvent *event;
if (focused)
{
gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_FOCUSED);
_gdk_mir_display_focus_window (gdk_window_get_display (window), window);
}
else
{
gdk_synthesize_window_state (window, GDK_WINDOW_STATE_FOCUSED, 0);
_gdk_mir_display_unfocus_window (gdk_window_get_display (window), window);
}
event = gdk_event_new (GDK_FOCUS_CHANGE);
event->focus_change.send_event = FALSE;
event->focus_change.in = focused;
send_event (window, get_pointer (window), event);
}
static guint
get_modifier_state (unsigned int modifiers, guint button_state)
{
guint modifier_state = button_state;
if ((modifiers & (mir_input_event_modifier_alt |
mir_input_event_modifier_alt_left |
mir_input_event_modifier_alt_right)) != 0)
modifier_state |= GDK_MOD1_MASK;
if ((modifiers & (mir_input_event_modifier_shift |
mir_input_event_modifier_shift_left |
mir_input_event_modifier_shift_right)) != 0)
modifier_state |= GDK_SHIFT_MASK;
if ((modifiers & (mir_input_event_modifier_ctrl |
mir_input_event_modifier_ctrl_left |
mir_input_event_modifier_ctrl_right)) != 0)
modifier_state |= GDK_CONTROL_MASK;
if ((modifiers & (mir_input_event_modifier_meta |
mir_input_event_modifier_meta_left |
mir_input_event_modifier_meta_right)) != 0)
modifier_state |= GDK_META_MASK;
if ((modifiers & mir_input_event_modifier_caps_lock) != 0)
modifier_state |= GDK_LOCK_MASK;
return modifier_state;
}
static void
handle_key_event (GdkWindow *window, const MirInputEvent *event)
{
const MirKeyboardEvent *keyboard_event = mir_input_event_get_keyboard_event (event);
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
GdkKeymap *keymap;
guint modifier_state;
guint button_state;
if (!keyboard_event)
return;
_gdk_mir_window_impl_get_cursor_state (impl, NULL, NULL, NULL, &button_state);
modifier_state = get_modifier_state (mir_keyboard_event_modifiers (keyboard_event), button_state);
keymap = gdk_display_get_keymap (gdk_window_get_display (window));
generate_key_event (window,
mir_keyboard_event_action (keyboard_event) == mir_keyboard_action_up ? GDK_KEY_RELEASE : GDK_KEY_PRESS,
modifier_state,
mir_keyboard_event_key_code (keyboard_event),
mir_keyboard_event_scan_code (keyboard_event),
_gdk_mir_keymap_key_is_modifier (keymap, mir_keyboard_event_key_code (keyboard_event)),
NANO_TO_MILLI (mir_input_event_get_event_time (event)));
}
static void
handle_touch_event (GdkWindow *window,
const MirTouchEvent *mir_touch_event)
{
const MirInputEvent *mir_input_event = mir_touch_event_input_event (mir_touch_event);
guint n = mir_touch_event_point_count (mir_touch_event);
GdkEvent *gdk_event;
guint i;
for (i = 0; i < n; i++)
{
MirTouchAction action = mir_touch_event_action (mir_touch_event, i);
if (action == mir_touch_action_up)
gdk_event = gdk_event_new (GDK_TOUCH_END);
else if (action == mir_touch_action_down)
gdk_event = gdk_event_new (GDK_TOUCH_BEGIN);
else
gdk_event = gdk_event_new (GDK_TOUCH_UPDATE);
gdk_event->touch.window = window;
gdk_event->touch.sequence = GINT_TO_POINTER (mir_touch_event_id (mir_touch_event, i));
gdk_event->touch.time = mir_input_event_get_event_time (mir_input_event);
gdk_event->touch.state = get_modifier_state (mir_touch_event_modifiers (mir_touch_event), 0);
gdk_event->touch.x = mir_touch_event_axis_value (mir_touch_event, i, mir_touch_axis_x);
gdk_event->touch.y = mir_touch_event_axis_value (mir_touch_event, i, mir_touch_axis_y);
gdk_event->touch.x_root = mir_touch_event_axis_value (mir_touch_event, i, mir_touch_axis_x);
gdk_event->touch.y_root = mir_touch_event_axis_value (mir_touch_event, i, mir_touch_axis_y);
gdk_event->touch.emulating_pointer = TRUE;
gdk_event_set_pointer_emulated (gdk_event, TRUE);
send_event (window, get_pointer (window), gdk_event);
}
}
static guint
get_button_state (const MirPointerEvent *event)
{
guint state = 0;
if (mir_pointer_event_button_state (event, mir_pointer_button_primary)) /* left */
state |= GDK_BUTTON1_MASK;
if (mir_pointer_event_button_state (event, mir_pointer_button_secondary)) /* right */
state |= GDK_BUTTON3_MASK;
if (mir_pointer_event_button_state (event, mir_pointer_button_tertiary)) /* middle */
state |= GDK_BUTTON2_MASK;
return state;
}
static void
handle_motion_event (GdkWindow *window, const MirInputEvent *event)
{
const MirPointerEvent *pointer_event = mir_input_event_get_pointer_event (event);
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
gdouble x, y;
gboolean cursor_inside;
guint button_state;
guint new_button_state;
guint modifier_state;
guint32 event_time;
GdkEventType event_type;
guint changed_button_state;
if (!pointer_event)
return;
_gdk_mir_window_impl_get_cursor_state (impl, &x, &y, &cursor_inside, &button_state);
new_button_state = get_button_state (pointer_event);
modifier_state = get_modifier_state (mir_pointer_event_modifiers (pointer_event), new_button_state);
event_time = NANO_TO_MILLI (mir_input_event_get_event_time (event));
if (window)
{
gdouble new_x;
gdouble new_y;
gdouble hscroll;
gdouble vscroll;
/* Update which window has focus */
_gdk_mir_pointer_set_location (get_pointer (window), x, y, window, modifier_state);
switch (mir_pointer_event_action (pointer_event))
{
case mir_pointer_action_button_up:
case mir_pointer_action_button_down:
event_type = mir_pointer_event_action (pointer_event) == mir_pointer_action_button_down ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE;
changed_button_state = button_state ^ new_button_state;
if (changed_button_state == 0 || (changed_button_state & GDK_BUTTON1_MASK) != 0)
generate_button_event (window, event_type, x, y, GDK_BUTTON_PRIMARY, modifier_state, event_time);
if ((changed_button_state & GDK_BUTTON2_MASK) != 0)
generate_button_event (window, event_type, x, y, GDK_BUTTON_MIDDLE, modifier_state, event_time);
if ((changed_button_state & GDK_BUTTON3_MASK) != 0)
generate_button_event (window, event_type, x, y, GDK_BUTTON_SECONDARY, modifier_state, event_time);
button_state = new_button_state;
break;
case mir_pointer_action_motion:
new_x = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_x);
new_y = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_y);
hscroll = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_hscroll);
vscroll = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_vscroll);
if (hscroll != 0.0 || vscroll != 0.0)
generate_scroll_event (window, x, y, hscroll, vscroll, modifier_state, event_time);
if (ABS (new_x - x) > 0.5 || ABS (new_y - y) > 0.5)
{
generate_motion_event (window, new_x, new_y, modifier_state, event_time);
x = new_x;
y = new_y;
}
break;
case mir_pointer_action_enter:
if (!cursor_inside)
{
cursor_inside = TRUE;
generate_crossing_event (window, GDK_ENTER_NOTIFY, x, y, event_time);
}
break;
case mir_pointer_action_leave:
if (cursor_inside)
{
cursor_inside = FALSE;
generate_crossing_event (window, GDK_LEAVE_NOTIFY, x, y, event_time);
}
break;
default:
break;
}
_gdk_mir_window_impl_set_cursor_state (impl, x, y, cursor_inside, button_state);
}
}
static void
handle_window_event (GdkWindow *window,
const MirWindowEvent *event)
{
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
MirWindowState state;
switch (mir_window_event_get_attribute (event))
{
case mir_window_attrib_type:
_gdk_mir_window_impl_set_window_type (impl, mir_window_event_get_attribute_value (event));
break;
case mir_window_attrib_state:
state = mir_window_event_get_attribute_value (event);
_gdk_mir_window_impl_set_window_state (impl, state);
switch (state)
{
case mir_window_state_restored:
case mir_window_state_hidden:
gdk_synthesize_window_state (window,
GDK_WINDOW_STATE_ICONIFIED |
GDK_WINDOW_STATE_MAXIMIZED |
GDK_WINDOW_STATE_FULLSCREEN,
0);
break;
case mir_window_state_minimized:
gdk_synthesize_window_state (window,
GDK_WINDOW_STATE_MAXIMIZED |
GDK_WINDOW_STATE_FULLSCREEN,
GDK_WINDOW_STATE_ICONIFIED);
break;
case mir_window_state_maximized:
case mir_window_state_vertmaximized:
case mir_window_state_horizmaximized:
gdk_synthesize_window_state (window,
GDK_WINDOW_STATE_ICONIFIED |
GDK_WINDOW_STATE_FULLSCREEN,
GDK_WINDOW_STATE_MAXIMIZED);
break;
case mir_window_state_fullscreen:
gdk_synthesize_window_state (window,
GDK_WINDOW_STATE_ICONIFIED |
GDK_WINDOW_STATE_MAXIMIZED,
GDK_WINDOW_STATE_FULLSCREEN);
break;
default:
break;
}
break;
case mir_window_attrib_swapinterval:
break;
case mir_window_attrib_focus:
generate_focus_event (window, mir_window_event_get_attribute_value (event) != 0);
break;
default:
break;
}
}
static void
generate_configure_event (GdkWindow *window,
gint width,
gint height)
{
GdkEvent *event;
event = gdk_event_new (GDK_CONFIGURE);
event->configure.send_event = FALSE;
event->configure.width = width;
event->configure.height = height;
send_event (window, get_pointer (window), event);
}
static void
handle_resize_event (GdkWindow *window,
const MirResizeEvent *event)
{
window->width = mir_resize_event_get_width (event);
window->height = mir_resize_event_get_height (event);
_gdk_window_update_size (window);
generate_configure_event (window, mir_resize_event_get_width (event), mir_resize_event_get_height (event));
}
static void
handle_close_event (GdkWindow *window)
{
send_event (window, get_pointer (window), gdk_event_new (GDK_DESTROY));
gdk_window_destroy_notify (window);
}
static void
handle_window_output_event (GdkWindow *window,
const MirWindowOutputEvent *event)
{
_gdk_mir_window_set_scale (window, mir_window_output_event_get_scale (event));
}
static void
handle_window_placement_event (GdkWindow *window,
const MirWindowPlacementEvent *event)
{
_gdk_mir_window_set_final_rect (window, mir_window_placement_get_relative_position (event));
}
typedef struct
{
GdkWindow *window;
MirEvent *event;
} EventData;
static void
gdk_mir_event_source_queue_event (GdkDisplay *display,
GdkWindow *window,
const MirEvent *event)
{
const MirInputEvent *input_event;
// FIXME: Only generate events if the window wanted them?
switch (mir_event_get_type (event))
{
case mir_event_type_input:
input_event = mir_event_get_input_event (event);
switch (mir_input_event_get_type (input_event))
{
case mir_input_event_type_key:
handle_key_event (window, input_event);
break;
case mir_input_event_type_touch:
handle_touch_event (window, mir_input_event_get_touch_event (input_event));
break;
case mir_input_event_type_pointer:
handle_motion_event (window, input_event);
break;
default:
break;
}
break;
case mir_event_type_key:
handle_key_event (window, mir_event_get_input_event (event));
break;
case mir_event_type_motion:
handle_motion_event (window, mir_event_get_input_event (event));
break;
case mir_event_type_window:
handle_window_event (window, mir_event_get_window_event (event));
break;
case mir_event_type_resize:
handle_resize_event (window, mir_event_get_resize_event (event));
break;
case mir_event_type_prompt_session_state_change:
break;
case mir_event_type_orientation:
break;
case mir_event_type_close_window:
handle_close_event (window);
break;
case mir_event_type_keymap:
break;
case mir_event_type_window_output:
handle_window_output_event (window, mir_event_get_window_output_event (event));
break;
case mir_event_type_input_device_state:
break;
case mir_event_type_window_placement:
handle_window_placement_event (window, mir_event_get_window_placement_event (event));
break;
default:
g_warning ("Ignoring unknown Mir event %d", mir_event_get_type (event));
break;
}
}
static GdkMirQueuedEvent *
gdk_mir_event_source_take_queued_event (GdkMirEventSource *source)
{
GdkMirQueuedEvent *queued_event;
g_mutex_lock (&source->mir_event_lock);
queued_event = g_queue_pop_head (&source->mir_events);
g_mutex_unlock (&source->mir_event_lock);
return queued_event;
}
static void
gdk_mir_queued_event_free (GdkMirQueuedEvent *event)
{
_gdk_mir_window_reference_unref (event->window_ref);
mir_event_unref (event->event);
g_slice_free (GdkMirQueuedEvent, event);
}
static void
gdk_mir_event_source_convert_events (GdkMirEventSource *source)
{
GdkMirQueuedEvent *event;
while ((event = gdk_mir_event_source_take_queued_event (source)))
{
GdkWindow *window = event->window_ref->window;
/* The window may have been destroyed in the main thread while the
* event was being dispatched...
*/
if (window != NULL)
{
if (source->log_events)
_gdk_mir_print_event (event->event);
gdk_mir_event_source_queue_event (source->display, window, event->event);
}
else
g_warning ("window was destroyed before event arrived...");
gdk_mir_queued_event_free (event);
}
}
static gboolean
gdk_mir_event_source_prepare (GSource *g_source,
gint *timeout)
{
GdkMirEventSource *source = (GdkMirEventSource *) g_source;
gboolean mir_events_in_queue;
if (_gdk_event_queue_find_first (source->display))
return TRUE;
g_mutex_lock (&source->mir_event_lock);
mir_events_in_queue = g_queue_get_length (&source->mir_events) > 0;
g_mutex_unlock (&source->mir_event_lock);
return mir_events_in_queue;
}
static gboolean
gdk_mir_event_source_check (GSource *g_source)
{
return gdk_mir_event_source_prepare (g_source, NULL);
}
static gboolean
gdk_mir_event_source_dispatch (GSource *g_source,
GSourceFunc callback,
gpointer user_data)
{
GdkMirEventSource *source = (GdkMirEventSource *) g_source;
GdkEvent *event;
/* First, run the queue of events from the thread */
gdk_mir_event_source_convert_events (source);
/* Next, dispatch one single event from the display's queue.
*
* If there is more than one event then we will soon find ourselves
* back here again.
*/
event = gdk_display_get_event (source->display);
if (event)
{
_gdk_event_emit (event);
gdk_event_free (event);
}
return TRUE;
}
static void
gdk_mir_event_source_finalize (GSource *g_source)
{
GdkMirEventSource *source = (GdkMirEventSource *) g_source;
GdkMirQueuedEvent *event;
while ((event = gdk_mir_event_source_take_queued_event (source)))
gdk_mir_queued_event_free (event);
g_mutex_clear (&source->mir_event_lock);
}
static GSourceFuncs gdk_mir_event_source_funcs = {
gdk_mir_event_source_prepare,
gdk_mir_event_source_check,
gdk_mir_event_source_dispatch,
gdk_mir_event_source_finalize
};
GdkMirEventSource *
_gdk_mir_event_source_new (GdkDisplay *display)
{
GdkMirEventSource *source;
GSource *g_source;
char *name;
g_source = g_source_new (&gdk_mir_event_source_funcs, sizeof (GdkMirEventSource));
name = g_strdup_printf ("GDK Mir Event source (%s)", gdk_display_get_name (display));
g_source_set_name (g_source, name);
g_free (name);
g_source_set_priority (g_source, GDK_PRIORITY_EVENTS);
g_source_set_can_recurse (g_source, TRUE);
g_source_attach (g_source, NULL);
source = (GdkMirEventSource *) g_source;
g_mutex_init (&source->mir_event_lock);
source->display = display;
source->log_events = (g_getenv ("GDK_MIR_LOG_EVENTS") != NULL);
return source;
}
GdkMirWindowReference *
_gdk_mir_event_source_get_window_reference (GdkWindow *window)
{
static GQuark win_ref_quark;
GdkMirWindowReference *ref;
if G_UNLIKELY (!win_ref_quark)
win_ref_quark = g_quark_from_string ("GdkMirEventSource window reference");
ref = g_object_get_qdata (G_OBJECT (window), win_ref_quark);
if (!ref)
{
GdkMirEventSource *source;
source = _gdk_mir_display_get_event_source (gdk_window_get_display (window));
g_source_ref ((GSource *) source);
ref = g_slice_new (GdkMirWindowReference);
ref->window = window;
ref->source = source;
ref->ref_count = 0;
g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &ref->window);
g_object_set_qdata_full (G_OBJECT (window), win_ref_quark,
ref, (GDestroyNotify) _gdk_mir_window_reference_unref);
}
g_atomic_int_inc (&ref->ref_count);
return ref;
}
void
_gdk_mir_window_reference_unref (GdkMirWindowReference *ref)
{
if (g_atomic_int_dec_and_test (&ref->ref_count))
{
if (ref->window)
g_object_remove_weak_pointer (G_OBJECT (ref->window), (gpointer *) &ref->window);
g_source_unref ((GSource *) ref->source);
g_slice_free (GdkMirWindowReference, ref);
}
}
void
_gdk_mir_event_source_queue (GdkMirWindowReference *window_ref,
const MirEvent *event)
{
GdkMirEventSource *source = window_ref->source;
GdkMirQueuedEvent *queued_event;
/* We are in the wrong thread right now. We absolutely cannot touch
* the window.
*
* We can do pretty much anything we want with the source, though...
*/
queued_event = g_slice_new (GdkMirQueuedEvent);
g_atomic_int_inc (&window_ref->ref_count);
queued_event->window_ref = window_ref;
queued_event->event = mir_event_ref (event);
g_mutex_lock (&source->mir_event_lock);
g_queue_push_tail (&source->mir_events, queued_event);
g_mutex_unlock (&source->mir_event_lock);
g_main_context_wakeup (NULL);
}

228
gdk/mir/gdkmirglcontext.c
View File

@ -1,228 +0,0 @@
/* GDK - The GIMP Drawing Kit
*
* gdkmirglcontext.c: Mir specific OpenGL wrappers
*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkmir-private.h"
#include "gdkinternals.h"
#include "gdkintl.h"
G_DEFINE_TYPE (GdkMirGLContext, gdk_mir_gl_context, GDK_TYPE_GL_CONTEXT)
#define N_EGL_ATTRS 16
static gboolean
gdk_mir_gl_context_realize (GdkGLContext *context,
GError **error)
{
GdkMirGLContext *context_mir = GDK_MIR_GL_CONTEXT (context);
GdkDisplay *display = gdk_gl_context_get_display (context);
GdkGLContext *share = gdk_gl_context_get_shared_context (context);
EGLContext ctx;
EGLint context_attribs[N_EGL_ATTRS];
int major, minor, flags;
gboolean debug_bit, forward_bit;
int i = 0;
if (!_gdk_mir_display_init_egl_display (display))
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("No GL implementation is available"));
return FALSE;
}
gdk_gl_context_get_required_version (context, &major, &minor);
debug_bit = gdk_gl_context_get_debug_enabled (context);
forward_bit = gdk_gl_context_get_forward_compatible (context);
flags = 0;
if (debug_bit)
flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
if (forward_bit)
flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
/* We want a core profile */
context_attribs[i++] = EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR;
context_attribs[i++] = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
/* Specify the version */
context_attribs[i++] = EGL_CONTEXT_MAJOR_VERSION_KHR;
context_attribs[i++] = major;
context_attribs[i++] = EGL_CONTEXT_MINOR_VERSION_KHR;
context_attribs[i++] = minor;
/* Specify the flags */
context_attribs[i++] = EGL_CONTEXT_FLAGS_KHR;
context_attribs[i++] = flags;
context_attribs[i++] = EGL_NONE;
g_assert (i < N_EGL_ATTRS);
ctx = eglCreateContext (_gdk_mir_display_get_egl_display (display),
context_mir->egl_config,
share != NULL ? GDK_MIR_GL_CONTEXT (share)->egl_context
: EGL_NO_CONTEXT,
context_attribs);
if (ctx == NULL)
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("Unable to create a GL context"));
return FALSE;
}
GDK_NOTE (OPENGL, g_print ("Created EGL context[%p]\n", ctx));
context_mir->egl_context = ctx;
return TRUE;
}
static cairo_region_t *
gdk_mir_gl_context_get_damage (GdkGLContext *context)
{
GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
EGLSurface egl_surface;
GdkWindow *window = gdk_draw_context_get_window (GDK_DRAW_CONTEXT (context));
int buffer_age = 0;
if (_gdk_mir_display_have_egl_buffer_age (display))
{
GdkGLContext *shared;
GdkMirGLContext *shared_mir;
shared = gdk_gl_context_get_shared_context (context);
if (shared == NULL)
shared = context;
shared_mir = GDK_MIR_GL_CONTEXT (shared);
egl_surface = _gdk_mir_window_get_egl_surface (window, shared_mir->egl_config);
gdk_gl_context_make_current (shared);
eglQuerySurface (_gdk_mir_display_get_egl_display (display), egl_surface,
EGL_BUFFER_AGE_EXT, &buffer_age);
if (buffer_age >= 2)
{
if (window->old_updated_area[0])
return cairo_region_copy (window->old_updated_area[0]);
}
else if (buffer_age >= 3)
{
if (window->old_updated_area[0] &&
window->old_updated_area[1])
{
cairo_region_t *damage = cairo_region_copy (window->old_updated_area[0]);
cairo_region_union (damage, window->old_updated_area[1]);
return damage;
}
}
}
return GDK_GL_CONTEXT_CLASS (gdk_mir_gl_context_parent_class)->get_damage (context);
}
static void
gdk_mir_gl_context_end_frame (GdkDrawContext *context,
cairo_region_t *painted,
cairo_region_t *damage)
{
GdkGLContext *gl_context = GDK_GL_CONTEXT (context);
GdkMirGLContext *context_mir = GDK_MIR_GL_CONTEXT (gl_context);
GdkWindow *window = gdk_gl_context_get_window (gl_context);
GdkDisplay *display = gdk_window_get_display (window);
EGLDisplay egl_display = _gdk_mir_display_get_egl_display (display);
EGLSurface egl_surface;
GDK_DRAW_CONTEXT_CLASS (gdk_mir_gl_context_parent_class)->end_frame (context, painted, damage);
if (gdk_gl_context_get_shared_context (gl_context))
return;
gdk_gl_context_make_current (gl_context);
egl_surface = _gdk_mir_window_get_egl_surface (window,
context_mir->egl_config);
if (_gdk_mir_display_have_egl_swap_buffers_with_damage (display))
{
int i, j, n_rects = cairo_region_num_rectangles (damage);
EGLint *rects = g_new (EGLint, n_rects * 4);
cairo_rectangle_int_t rect;
int window_height = gdk_window_get_height (window);
for (i = 0, j = 0; i < n_rects; i++)
{
cairo_region_get_rectangle (damage, i, &rect);
rects[j++] = rect.x;
rects[j++] = window_height - rect.height - rect.y;
rects[j++] = rect.width;
rects[j++] = rect.height;
}
eglSwapBuffersWithDamageEXT (egl_display, egl_surface, rects, n_rects);
g_free (rects);
}
else
{
eglSwapBuffers (egl_display, egl_surface);
}
}
static void
gdk_mir_gl_context_dispose (GObject *gobject)
{
GdkMirGLContext *context_mir = GDK_MIR_GL_CONTEXT (gobject);
if (context_mir->egl_context != NULL)
{
GdkGLContext *context = GDK_GL_CONTEXT (gobject);
GdkWindow *window = gdk_gl_context_get_window (context);
GdkDisplay *display = gdk_window_get_display (window);
EGLDisplay egl_display = _gdk_mir_display_get_egl_display (display);
if (eglGetCurrentContext () == context_mir->egl_context)
eglMakeCurrent (egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
GDK_NOTE (OPENGL, g_print ("Destroying EGL context\n"));
eglDestroyContext (egl_display, context_mir->egl_context);
context_mir->egl_context = NULL;
}
G_OBJECT_CLASS (gdk_mir_gl_context_parent_class)->dispose (gobject);
}
static void
gdk_mir_gl_context_class_init (GdkMirGLContextClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GdkDrawContextClass *draw_context_class = GDK_DRAW_CONTEXT_CLASS (klass);
GdkGLContextClass *gl_context_class = GDK_GL_CONTEXT_CLASS (klass);
gl_context_class->realize = gdk_mir_gl_context_realize;
gl_context_class->get_damage = gdk_mir_gl_context_get_damage;
draw_context_class->end_frame = gdk_mir_gl_context_end_frame;
gobject_class->dispose = gdk_mir_gl_context_dispose;
}
static void
gdk_mir_gl_context_init (GdkMirGLContext *self)
{
}

162
gdk/mir/gdkmirkeyboard.c
View File

@ -1,162 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkdeviceprivate.h"
typedef struct GdkMirKeyboard GdkMirKeyboard;
typedef struct GdkMirKeyboardClass GdkMirKeyboardClass;
#define GDK_TYPE_MIR_KEYBOARD (gdk_mir_keyboard_get_type ())
#define GDK_MIR_KEYBOARD(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_KEYBOARD, GdkMirKeyboard))
#define GDK_MIR_KEYBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_KEYBOARD, GdkMirKeyboardClass))
#define GDK_IS_MIR_KEYBOARD(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_KEYBOARD))
#define GDK_IS_MIR_KEYBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_KEYBOARD))
#define GDK_MIR_KEYBOARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_KEYBOARD, GdkMirKeyboardClass))
struct GdkMirKeyboard
{
GdkDevice parent_instance;
};
struct GdkMirKeyboardClass
{
GdkDeviceClass parent_class;
};
G_DEFINE_TYPE (GdkMirKeyboard, gdk_mir_keyboard, GDK_TYPE_DEVICE)
GdkDevice *
_gdk_mir_keyboard_new (GdkDeviceManager *device_manager, const gchar *name)
{
return g_object_new (GDK_TYPE_MIR_KEYBOARD,
"display", gdk_device_manager_get_display (device_manager),
"device-manager", device_manager,
"name", name,
"type", GDK_DEVICE_TYPE_MASTER,
"input-source", GDK_SOURCE_KEYBOARD,
"input-mode", GDK_MODE_SCREEN,
"has-cursor", FALSE,
NULL);
}
static gboolean
gdk_mir_keyboard_get_history (GdkDevice *device,
GdkWindow *window,
guint32 start,
guint32 stop,
GdkTimeCoord ***events,
gint *n_events)
{
return FALSE;
}
static void
gdk_mir_keyboard_get_state (GdkDevice *device,
GdkWindow *window,
gdouble *axes,
GdkModifierType *mask)
{
}
static void
gdk_mir_keyboard_set_window_cursor (GdkDevice *device,
GdkWindow *window,
GdkCursor *cursor)
{
/* Keyboards don't have cursors... */
}
static void
gdk_mir_keyboard_warp (GdkDevice *device,
gdouble x,
gdouble y)
{
/* Can't warp a keyboard... */
}
static void
gdk_mir_keyboard_query_state (GdkDevice *device,
GdkWindow *window,
GdkWindow **child_window,
gdouble *root_x,
gdouble *root_y,
gdouble *win_x,
gdouble *win_y,
GdkModifierType *mask)
{
}
static GdkGrabStatus
gdk_mir_keyboard_grab (GdkDevice *device,
GdkWindow *window,
gboolean owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
GdkCursor *cursor,
guint32 time_)
{
/* Mir doesn't do grabs, so sure, you have the grab */
return GDK_GRAB_SUCCESS;
}
static void
gdk_mir_keyboard_ungrab (GdkDevice *device,
guint32 time_)
{
/* Mir doesn't do grabs */
}
static GdkWindow *
gdk_mir_keyboard_window_at_position (GdkDevice *device,
gdouble *win_x,
gdouble *win_y,
GdkModifierType *mask,
gboolean get_toplevel)
{
/* Keyboard don't have locations... */
return NULL; // FIXME: Or the window with the keyboard focus?
}
static void
gdk_mir_keyboard_select_window_events (GdkDevice *device,
GdkWindow *window,
GdkEventMask event_mask)
{
}
static void
gdk_mir_keyboard_init (GdkMirKeyboard *device)
{
}
static void
gdk_mir_keyboard_class_init (GdkMirKeyboardClass *klass)
{
GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
device_class->get_history = gdk_mir_keyboard_get_history;
device_class->get_state = gdk_mir_keyboard_get_state;
device_class->set_window_cursor = gdk_mir_keyboard_set_window_cursor;
device_class->warp = gdk_mir_keyboard_warp;
device_class->query_state = gdk_mir_keyboard_query_state;
device_class->grab = gdk_mir_keyboard_grab;
device_class->ungrab = gdk_mir_keyboard_ungrab;
device_class->window_at_position = gdk_mir_keyboard_window_at_position;
device_class->select_window_events = gdk_mir_keyboard_select_window_events;
}

476
gdk/mir/gdkmirkeymap.c
View File

@ -1,476 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <xkbcommon/xkbcommon.h>
#include "gdkkeysprivate.h"
typedef struct GdkMirKeymap GdkMirKeymap;
typedef struct GdkMirKeymapClass GdkMirKeymapClass;
#define GDK_TYPE_MIR_KEYMAP (gdk_mir_keymap_get_type ())
#define GDK_MIR_KEYMAP(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_KEYMAP, GdkMirKeymap))
#define GDK_MIR_KEYMAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_KEYMAP, GdkMirKeymapClass))
#define GDK_IS_MIR_KEYMAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_KEYMAP))
#define GDK_IS_MIR_KEYMAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_KEYMAP))
#define GDK_MIR_KEYMAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_KEYMAP, GdkMirKeymapClass))
#define IsModifierKey(keysym) \
(((keysym) >= XKB_KEY_Shift_L && (keysym) <= XKB_KEY_Hyper_R) || \
((keysym) >= XKB_KEY_ISO_Lock && (keysym) <= XKB_KEY_ISO_Last_Group_Lock) || \
((keysym) == XKB_KEY_Mode_switch) || \
((keysym) == XKB_KEY_Num_Lock))
struct GdkMirKeymap
{
GdkKeymap parent_instance;
struct xkb_keymap *xkb_keymap;
struct xkb_state *xkb_state;
PangoDirection *direction;
gboolean bidi;
};
struct GdkMirKeymapClass
{
GdkKeymapClass parent_class;
};
G_DEFINE_TYPE (GdkMirKeymap, gdk_mir_keymap, GDK_TYPE_KEYMAP)
GdkKeymap *
_gdk_mir_keymap_new (void)
{
return g_object_new (GDK_TYPE_MIR_KEYMAP, NULL);
}
static PangoDirection
gdk_mir_keymap_get_direction (GdkKeymap *keymap)
{
GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
gint i;
for (i = 0; i < xkb_keymap_num_layouts (mir_keymap->xkb_keymap); i++)
{
if (xkb_state_layout_index_is_active (mir_keymap->xkb_state, i, XKB_STATE_LAYOUT_EFFECTIVE))
return mir_keymap->direction[i];
}
return PANGO_DIRECTION_NEUTRAL;
}
static gboolean
gdk_mir_keymap_have_bidi_layouts (GdkKeymap *keymap)
{
return FALSE;
}
static gboolean
gdk_mir_keymap_get_caps_lock_state (GdkKeymap *keymap)
{
return xkb_state_led_name_is_active (GDK_MIR_KEYMAP (keymap)->xkb_state, XKB_LED_NAME_CAPS);
}
static gboolean
gdk_mir_keymap_get_num_lock_state (GdkKeymap *keymap)
{
return xkb_state_led_name_is_active (GDK_MIR_KEYMAP (keymap)->xkb_state, XKB_LED_NAME_NUM);
}
static gboolean
gdk_mir_keymap_get_scroll_lock_state (GdkKeymap *keymap)
{
return xkb_state_led_name_is_active (GDK_MIR_KEYMAP (keymap)->xkb_state, XKB_LED_NAME_SCROLL);
}
static gboolean
gdk_mir_keymap_get_entries_for_keyval (GdkKeymap *keymap,
guint keyval,
GdkKeymapKey **keys,
gint *n_keys)
{
GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
GArray *key_array;
guint keycode;
key_array = g_array_new (FALSE, FALSE, sizeof (GdkKeymapKey));
for (keycode = 8; keycode < 255; keycode++) /* FIXME: min/max keycode */
{
gint num_layouts, layout;
num_layouts = xkb_keymap_num_layouts_for_key (mir_keymap->xkb_keymap, keycode);
for (layout = 0; layout < num_layouts; layout++)
{
gint num_levels, level;
num_levels = xkb_keymap_num_levels_for_key (mir_keymap->xkb_keymap, keycode, layout);
for (level = 0; level < num_levels; level++)
{
const xkb_keysym_t *syms;
gint num_syms, sym;
num_syms = xkb_keymap_key_get_syms_by_level (mir_keymap->xkb_keymap, keycode, layout, level, &syms);
for (sym = 0; sym < num_syms; sym++)
{
if (syms[sym] == keyval)
{
GdkKeymapKey key;
key.keycode = keycode;
key.group = layout;
key.level = level;
g_array_append_val (key_array, key);
}
}
}
}
}
*n_keys = key_array->len;
*keys = (GdkKeymapKey*) g_array_free (key_array, FALSE);
return TRUE;
}
static gboolean
gdk_mir_keymap_get_entries_for_keycode (GdkKeymap *keymap,
guint hardware_keycode,
GdkKeymapKey **keys,
guint **keyvals,
gint *n_entries)
{
GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
gint num_layouts, layout;
gint num_entries;
gint i;
num_layouts = xkb_keymap_num_layouts_for_key (mir_keymap->xkb_keymap, hardware_keycode);
num_entries = 0;
for (layout = 0; layout < num_layouts; layout++)
num_entries += xkb_keymap_num_levels_for_key (mir_keymap->xkb_keymap, hardware_keycode, layout);
if (n_entries)
*n_entries = num_entries;
if (keys)
*keys = g_new0 (GdkKeymapKey, num_entries);
if (keyvals)
*keyvals = g_new0 (guint, num_entries);
i = 0;
for (layout = 0; layout < num_layouts; layout++)
{
gint num_levels, level;
num_levels = xkb_keymap_num_levels_for_key (mir_keymap->xkb_keymap, hardware_keycode, layout);
for (level = 0; level < num_levels; level++)
{
const xkb_keysym_t *syms;
int num_syms;
num_syms = xkb_keymap_key_get_syms_by_level (mir_keymap->xkb_keymap, hardware_keycode, layout, 0, &syms);
if (keys)
{
(*keys)[i].keycode = hardware_keycode;
(*keys)[i].group = layout;
(*keys)[i].level = level;
}
if (keyvals && num_syms > 0)
(*keyvals)[i] = syms[0];
i++;
}
}
return num_entries > 0;
}
static guint
gdk_mir_keymap_lookup_key (GdkKeymap *keymap,
const GdkKeymapKey *key)
{
GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
const xkb_keysym_t *syms;
int num_syms;
num_syms = xkb_keymap_key_get_syms_by_level (mir_keymap->xkb_keymap,
key->keycode,
key->group,
key->level,
&syms);
if (num_syms > 0)
return syms[0];
else
return XKB_KEY_NoSymbol;
}
static guint32
get_xkb_modifiers (struct xkb_keymap *xkb_keymap,
GdkModifierType state)
{
guint32 mods = 0;
if (state & GDK_SHIFT_MASK)
mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_SHIFT);
if (state & GDK_LOCK_MASK)
mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CAPS);
if (state & GDK_CONTROL_MASK)
mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CTRL);
if (state & GDK_MOD1_MASK)
mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_ALT);
if (state & GDK_MOD2_MASK)
mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod2");
if (state & GDK_MOD3_MASK)
mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod3");
if (state & GDK_MOD4_MASK)
mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_LOGO);
if (state & GDK_MOD5_MASK)
mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod5");
return mods;
}
static GdkModifierType
get_gdk_modifiers (struct xkb_keymap *xkb_keymap,
guint32 mods)
{
GdkModifierType state = 0;
if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_SHIFT)))
state |= GDK_SHIFT_MASK;
if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CAPS)))
state |= GDK_LOCK_MASK;
if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CTRL)))
state |= GDK_CONTROL_MASK;
if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_ALT)))
state |= GDK_MOD1_MASK;
if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod2")))
state |= GDK_MOD2_MASK;
if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod3")))
state |= GDK_MOD3_MASK;
if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_LOGO)))
state |= GDK_MOD4_MASK;
if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod5")))
state |= GDK_MOD5_MASK;
return state;
}
static gboolean
gdk_mir_keymap_translate_keyboard_state (GdkKeymap *keymap,
guint hardware_keycode,
GdkModifierType state,
gint group,
guint *keyval,
gint *effective_group,
gint *effective_level,
GdkModifierType *consumed_modifiers)
{
GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
struct xkb_state *xkb_state;
guint32 modifiers;
guint32 consumed;
xkb_layout_index_t layout;
xkb_level_index_t level;
xkb_keysym_t sym;
modifiers = get_xkb_modifiers (mir_keymap->xkb_keymap, state);
xkb_state = xkb_state_new (mir_keymap->xkb_keymap);
xkb_state_update_mask (xkb_state, modifiers, 0, 0, group, 0, 0);
layout = xkb_state_key_get_layout (xkb_state, hardware_keycode);
level = xkb_state_key_get_level (xkb_state, hardware_keycode, layout);
sym = xkb_state_key_get_one_sym (xkb_state, hardware_keycode);
consumed = modifiers & ~xkb_state_mod_mask_remove_consumed (xkb_state, hardware_keycode, modifiers);
xkb_state_unref (xkb_state);
if (keyval)
*keyval = sym;
if (effective_group)
*effective_group = layout;
if (effective_level)
*effective_level = level;
if (consumed_modifiers)
*consumed_modifiers = get_gdk_modifiers (mir_keymap->xkb_keymap, consumed);
return TRUE;
}
static void
gdk_mir_keymap_add_virtual_modifiers (GdkKeymap *keymap,
GdkModifierType *state)
{
// FIXME: What is this?
}
static gboolean
gdk_mir_keymap_map_virtual_modifiers (GdkKeymap *keymap,
GdkModifierType *state)
{
// FIXME: What is this?
return TRUE;
}
static guint
gdk_mir_keymap_get_modifier_state (GdkKeymap *keymap)
{
GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
xkb_mod_mask_t mods;
mods = xkb_state_serialize_mods (mir_keymap->xkb_state, XKB_STATE_MODS_EFFECTIVE);
return get_gdk_modifiers (mir_keymap->xkb_keymap, mods);
}
gboolean
_gdk_mir_keymap_key_is_modifier (GdkKeymap *keymap,
guint keycode)
{
// FIXME: use xkb_state
return IsModifierKey (keycode);
}
static void
update_direction (GdkMirKeymap *keymap)
{
gint num_layouts;
gint *rtl;
guint key;
gboolean have_rtl, have_ltr;
gint i;
num_layouts = xkb_keymap_num_layouts (keymap->xkb_keymap);
g_free (keymap->direction);
keymap->direction = g_new0 (PangoDirection, num_layouts);
rtl = g_new0 (gint, num_layouts);
for (key = 8; key < 255; key++) /* FIXME: min/max keycode */
{
gint layouts;
gint layout;
layouts = xkb_keymap_num_layouts_for_key (keymap->xkb_keymap, key);
for (layout = 0; layout < layouts; layout++)
{
const xkb_keysym_t *syms;
gint num_syms;
gint sym;
num_syms = xkb_keymap_key_get_syms_by_level (keymap->xkb_keymap, key, layout, 0, &syms);
for (sym = 0; sym < num_syms; sym++)
{
PangoDirection dir;
dir = pango_unichar_direction (xkb_keysym_to_utf32 (syms[sym]));
switch (dir)
{
case PANGO_DIRECTION_RTL:
rtl[layout]++;
break;
case PANGO_DIRECTION_LTR:
rtl[layout]--;
break;
default:
break;
}
}
}
}
have_rtl = have_ltr = FALSE;
for (i = 0; i < num_layouts; i++)
{
if (rtl[i] > 0)
{
keymap->direction[i] = PANGO_DIRECTION_RTL;
have_rtl = TRUE;
}
else
{
keymap->direction[i] = PANGO_DIRECTION_LTR;
have_ltr = TRUE;
}
}
if (have_rtl && have_ltr)
keymap->bidi = TRUE;
g_free (rtl);
}
static void
gdk_mir_keymap_init (GdkMirKeymap *keymap)
{
struct xkb_context *context;
struct xkb_rule_names names;
context = xkb_context_new (0);
names.rules = "evdev";
names.model = "pc105";
names.layout = "us";
names.variant = "";
names.options = "";
keymap->xkb_keymap = xkb_keymap_new_from_names (context, &names, 0);
keymap->xkb_state = xkb_state_new (keymap->xkb_keymap);
xkb_context_unref (context);
update_direction (keymap);
}
static void
gdk_mir_keymap_finalize (GObject *object)
{
GdkMirKeymap *keymap = GDK_MIR_KEYMAP (object);
xkb_keymap_unref (keymap->xkb_keymap);
xkb_state_unref (keymap->xkb_state);
g_free (keymap->direction);
G_OBJECT_CLASS (gdk_mir_keymap_parent_class)->finalize (object);
}
static void
gdk_mir_keymap_class_init (GdkMirKeymapClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GdkKeymapClass *keymap_class = GDK_KEYMAP_CLASS (klass);
object_class->finalize = gdk_mir_keymap_finalize;
keymap_class->get_direction = gdk_mir_keymap_get_direction;
keymap_class->have_bidi_layouts = gdk_mir_keymap_have_bidi_layouts;
keymap_class->get_caps_lock_state = gdk_mir_keymap_get_caps_lock_state;
keymap_class->get_num_lock_state = gdk_mir_keymap_get_num_lock_state;
keymap_class->get_scroll_lock_state = gdk_mir_keymap_get_scroll_lock_state;
keymap_class->get_entries_for_keyval = gdk_mir_keymap_get_entries_for_keyval;
keymap_class->get_entries_for_keycode = gdk_mir_keymap_get_entries_for_keycode;
keymap_class->lookup_key = gdk_mir_keymap_lookup_key;
keymap_class->translate_keyboard_state = gdk_mir_keymap_translate_keyboard_state;
keymap_class->add_virtual_modifiers = gdk_mir_keymap_add_virtual_modifiers;
keymap_class->map_virtual_modifiers = gdk_mir_keymap_map_virtual_modifiers;
keymap_class->get_modifier_state = gdk_mir_keymap_get_modifier_state;
}

243
gdk/mir/gdkmirpointer.c
View File

@ -1,243 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkdisplayprivate.h"
#include "gdkdeviceprivate.h"
#include "gdkscreen.h"
#include "gdkwindow.h"
typedef struct GdkMirPointer GdkMirPointer;
typedef struct GdkMirPointerClass GdkMirPointerClass;
#define GDK_TYPE_MIR_POINTER (gdk_mir_pointer_get_type ())
#define GDK_MIR_POINTER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_POINTER, GdkMirPointer))
#define GDK_MIR_POINTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_POINTER, GdkMirPointerClass))
#define GDK_IS_MIR_POINTER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_POINTER))
#define GDK_IS_MIR_POINTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_POINTER))
#define GDK_MIR_POINTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_POINTER, GdkMirPointerClass))
struct GdkMirPointer
{
GdkDevice parent_instance;
/* Location of pointer */
gdouble x;
gdouble y;
/* Window this pointer is over */
GdkWindow *over_window;
/* Current modifier mask */
GdkModifierType modifier_mask;
};
struct GdkMirPointerClass
{
GdkDeviceClass parent_class;
};
G_DEFINE_TYPE (GdkMirPointer, gdk_mir_pointer, GDK_TYPE_DEVICE)
GdkDevice *
_gdk_mir_pointer_new (GdkDeviceManager *device_manager, const gchar *name)
{
return g_object_new (GDK_TYPE_MIR_POINTER,
"display", gdk_device_manager_get_display (device_manager),
"device-manager", device_manager,
"name", name,
"type", GDK_DEVICE_TYPE_MASTER,
"input-source", GDK_SOURCE_MOUSE,
"input-mode", GDK_MODE_SCREEN,
"has-cursor", TRUE,
NULL);
}
void
_gdk_mir_pointer_set_location (GdkDevice *pointer,
gdouble x,
gdouble y,
GdkWindow *window,
GdkModifierType mask)
{
GdkMirPointer *p = GDK_MIR_POINTER (pointer);
p->x = x;
p->y = y;
if (p->over_window)
g_object_unref (p->over_window);
p->over_window = g_object_ref (window);
p->modifier_mask = mask;
}
static gboolean
gdk_mir_pointer_get_history (GdkDevice *device,
GdkWindow *window,
guint32 start,
guint32 stop,
GdkTimeCoord ***events,
gint *n_events)
{
return FALSE;
}
static void
gdk_mir_pointer_get_state (GdkDevice *device,
GdkWindow *window,
gdouble *axes,
GdkModifierType *mask)
{
GdkMirPointer *p = GDK_MIR_POINTER (device);
gdouble x, y;
gdk_window_get_device_position_double (window, device, &x, &y, mask);
if (axes)
{
axes[0] = p->x;
axes[1] = p->y;
}
}
static void
gdk_mir_pointer_set_window_cursor (GdkDevice *device,
GdkWindow *window,
GdkCursor *cursor)
{
/* Mir doesn't support cursors */
}
static void
gdk_mir_pointer_warp (GdkDevice *device,
gdouble x,
gdouble y)
{
/* Mir doesn't support warping */
}
static void
gdk_mir_pointer_query_state (GdkDevice *device,
GdkWindow *window,
GdkWindow **child_window,
gdouble *root_x,
gdouble *root_y,
gdouble *win_x,
gdouble *win_y,
GdkModifierType *mask)
{
GdkMirPointer *p = GDK_MIR_POINTER (device);
if (child_window)
*child_window = p->over_window;
if (root_x)
*root_x = p->x;
if (root_y)
*root_y = p->y;
if (win_x)
*win_x = p->x; // FIXME
if (win_y)
*win_y = p->y;
if (mask)
*mask = p->modifier_mask;
}
static GdkGrabStatus
gdk_mir_pointer_grab (GdkDevice *device,
GdkWindow *window,
gboolean owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
GdkCursor *cursor,
guint32 time_)
{
/* Mir doesn't do grabs, so sure, you have the grab */
return GDK_GRAB_SUCCESS;
}
static void
gdk_mir_pointer_ungrab (GdkDevice *device,
guint32 time_)
{
/* Mir doesn't do grabs */
GdkDeviceGrabInfo *grab = _gdk_display_get_last_device_grab (gdk_device_get_display (device), device);
if (grab)
grab->serial_end = grab->serial_start;
}
static GdkWindow *
gdk_mir_pointer_window_at_position (GdkDevice *device,
gdouble *win_x,
gdouble *win_y,
GdkModifierType *mask,
gboolean get_toplevel)
{
GdkMirPointer *p = GDK_MIR_POINTER (device);
if (win_x)
*win_x = p->x;
if (win_y)
*win_y = p->y;
if (mask)
*mask = p->modifier_mask;
return p->over_window;
}
static void
gdk_mir_pointer_select_window_events (GdkDevice *device,
GdkWindow *window,
GdkEventMask event_mask)
{
// FIXME?
}
static void
gdk_mir_pointer_init (GdkMirPointer *device)
{
}
static void
gdk_mir_pointer_finalize (GObject *object)
{
GdkMirPointer *p = GDK_MIR_POINTER (object);
if (p->over_window)
g_object_unref (p->over_window);
G_OBJECT_CLASS (gdk_mir_pointer_parent_class)->finalize (object);
}
static void
gdk_mir_pointer_class_init (GdkMirPointerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
object_class->finalize = gdk_mir_pointer_finalize;
device_class->get_history = gdk_mir_pointer_get_history;
device_class->get_state = gdk_mir_pointer_get_state;
device_class->set_window_cursor = gdk_mir_pointer_set_window_cursor;
device_class->warp = gdk_mir_pointer_warp;
device_class->query_state = gdk_mir_pointer_query_state;
device_class->grab = gdk_mir_pointer_grab;
device_class->ungrab = gdk_mir_pointer_ungrab;
device_class->window_at_position = gdk_mir_pointer_window_at_position;
device_class->select_window_events = gdk_mir_pointer_select_window_events;
}

709
gdk/mir/gdkmirscreen.c
View File

@ -1,709 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <string.h>
#include "gdkscreenprivate.h"
#include "gdkdisplayprivate.h"
#include "gdkinternals.h"
#include "gdkmir.h"
#include "gdkmir-private.h"
#define VISUAL_TYPE GDK_VISUAL_TRUE_COLOR
typedef struct GdkMirScreen GdkMirScreen;
typedef struct GdkMirScreenClass GdkMirScreenClass;
#define GDK_TYPE_MIR_SCREEN (gdk_mir_screen_get_type ())
#define GDK_MIR_SCREEN(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_SCREEN, GdkMirScreen))
#define GDK_MIR_SCREEN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_SCREEN, GdkMirScreenClass))
#define GDK_IS_MIR_SCREEN(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_SCREEN))
#define GDK_IS_MIR_SCREEN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_SCREEN))
#define GDK_MIR_SCREEN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_SCREEN, GdkMirScreenClass))
struct GdkMirScreen
{
GdkScreen parent_instance;
/* Display this screen is running on */
GdkDisplay *display;
/* Current monitor configuration */
MirDisplayConfig *display_config;
/* Root window */
GdkWindow *root_window;
/* Settings */
GHashTable *settings_objects;
GHashTable *current_settings;
};
struct GdkMirScreenClass
{
GdkScreenClass parent_class;
};
G_DEFINE_TYPE (GdkMirScreen, gdk_mir_screen, GDK_TYPE_SCREEN)
static MirConnection *
get_connection (GdkMirScreen *screen)
{
return gdk_mir_display_get_mir_connection (GDK_DISPLAY (screen->display));
}
static void
get_screen_size (MirDisplayConfig *config,
gint *width,
gint *height)
{
const MirOutput *output;
const MirOutputMode *mode;
gint right;
gint bottom;
gint i;
*width = 0;
*height = 0;
if (!config)
return;
for (i = 0; i < mir_display_config_get_num_outputs (config); i++)
{
output = mir_display_config_get_output (config, i);
if (!mir_output_is_enabled (output))
continue;
mode = mir_output_get_current_mode (output);
right = mir_output_get_position_x (output) + mir_output_mode_get_width (mode);
bottom = mir_output_get_position_y (output) + mir_output_mode_get_height (mode);
if (right > *width)
*width = right;
if (bottom > *height)
*height = bottom;
}
}
static void
update_display_config (GdkMirScreen *screen)
{
gdk_mir_display_get_mir_connection (GDK_DISPLAY (screen->display));
mir_display_config_release (screen->display_config);
screen->display_config = mir_connection_create_display_configuration (get_connection (screen));
}
static void
config_changed_cb (MirConnection *connection, void *data)
{
GdkMirScreen *screen = data;
update_display_config (screen);
}
GdkScreen *
_gdk_mir_screen_new (GdkDisplay *display)
{
GdkMirScreen *screen;
screen = g_object_new (GDK_TYPE_MIR_SCREEN, NULL);
screen->display = display;
mir_connection_set_display_config_change_callback (get_connection (screen), config_changed_cb, screen);
update_display_config (screen);
return GDK_SCREEN (screen);
}
static void
gdk_mir_screen_dispose (GObject *object)
{
GdkMirScreen *screen = GDK_MIR_SCREEN (object);
g_clear_pointer (&screen->current_settings, g_hash_table_unref);
g_clear_pointer (&screen->settings_objects, g_hash_table_unref);
G_OBJECT_CLASS (gdk_mir_screen_parent_class)->dispose (object);
}
static void
gdk_mir_screen_finalize (GObject *object)
{
GdkMirScreen *screen = GDK_MIR_SCREEN (object);
mir_connection_set_display_config_change_callback (get_connection (screen), NULL, NULL);
mir_display_config_release (screen->display_config);
g_clear_object (&screen->root_window);
G_OBJECT_CLASS (gdk_mir_screen_parent_class)->finalize (object);
}
static GdkDisplay *
gdk_mir_screen_get_display (GdkScreen *screen)
{
return GDK_DISPLAY (GDK_MIR_SCREEN (screen)->display);
}
static GdkWindow *
gdk_mir_screen_get_root_window (GdkScreen *screen)
{
GdkMirScreen *s = GDK_MIR_SCREEN (screen);
gint width, height;
if (s->root_window)
return s->root_window;
get_screen_size (GDK_MIR_SCREEN (screen)->display_config, &width, &height);
s->root_window = _gdk_display_create_window (s->display);
s->root_window->impl_window = s->root_window;
s->root_window->window_type = GDK_WINDOW_ROOT;
s->root_window->x = 0;
s->root_window->y = 0;
s->root_window->abs_x = 0;
s->root_window->abs_y = 0;
s->root_window->width = width;
s->root_window->height = height;
s->root_window->viewable = TRUE;
s->root_window->impl = _gdk_mir_window_impl_new (s->display, s->root_window);
return s->root_window;
}
static void setting_changed (GSettings *settings,
const gchar *key,
GdkMirScreen *screen);
static GSettings *
get_settings (GdkMirScreen *screen,
const gchar *schema_id)
{
GSettings *settings;
GSettingsSchemaSource *source;
GSettingsSchema *schema;
settings = g_hash_table_lookup (screen->settings_objects, schema_id);
if (settings)
return g_object_ref (settings);
source = g_settings_schema_source_get_default ();
if (!source)
{
g_warning ("no schemas installed");
return NULL;
}
schema = g_settings_schema_source_lookup (source, schema_id, TRUE);
if (!schema)
{
g_warning ("schema not found: %s", schema_id);
return NULL;
}
settings = g_settings_new_full (schema, NULL, NULL);
g_signal_connect (settings, "changed", G_CALLBACK (setting_changed), screen);
g_hash_table_insert (screen->settings_objects, g_strdup (schema_id), g_object_ref (settings));
g_settings_schema_unref (schema);
return settings;
}
static GVariant *
read_setting (GdkMirScreen *screen,
const gchar *schema_id,
const gchar *key)
{
GSettings *settings;
GVariant *variant;
settings = get_settings (screen, schema_id);
if (!settings)
return NULL;
variant = g_settings_get_value (settings, key);
g_object_unref (settings);
return variant;
}
static void
change_setting (GdkMirScreen *screen,
const gchar *name,
GVariant *variant)
{
GVariant *old_variant;
old_variant = g_hash_table_lookup (screen->current_settings, name);
if (variant == old_variant)
return;
if (variant && old_variant && g_variant_equal (variant, old_variant))
return;
if (variant)
g_hash_table_insert (screen->current_settings, g_strdup (name), g_variant_ref_sink (variant));
else
g_hash_table_remove (screen->current_settings, name);
gdk_display_setting_changed (GDK_DISPLAY (GDK_MIR_SCREEN (screen)->display), name);
}
static const struct
{
const gchar *name;
const gchar *schema_id;
const gchar *key;
} SETTINGS_MAP[] = {
{
"gtk-double-click-time",
"org.gnome.settings-daemon.peripherals.mouse",
"double-click"
},
{
"gtk-cursor-blink",
"org.gnome.desktop.interface",
"cursor-blink"
},
{
"gtk-cursor-blink-time",
"org.gnome.desktop.interface",
"cursor-blink-time"
},
{
"gtk-cursor-blink-timeout",
"org.gnome.desktop.interface",
"cursor-blink-timeout"
},
{
"gtk-theme-name",
"org.gnome.desktop.interface",
"gtk-theme"
},
{
"gtk-icon-theme-name",
"org.gnome.desktop.interface",
"icon-theme"
},
{
"gtk-key-theme-name",
"org.gnome.desktop.interface",
"gtk-key-theme"
},
{
"gtk-dnd-drag-threshold",
"org.gnome.settings-daemon.peripherals.mouse",
"drag-threshold"
},
{
"gtk-font-name",
"org.gnome.desktop.interface",
"font-name"
},
{
"gtk-xft-antialias",
"org.gnome.settings-daemon.plugins.xsettings",
"antialiasing"
},
{
"gtk-xft-hinting",
"org.gnome.settings-daemon.plugins.xsettings",
"hinting"
},
{
"gtk-xft-hintstyle",
"org.gnome.settings-daemon.plugins.xsettings",
"hinting"
},
{
"gtk-xft-rgba",
"org.gnome.settings-daemon.plugins.xsettings",
"rgba-order"
},
{
"gtk-xft-dpi",
"org.gnome.desktop.interface",
"text-scaling-factor"
},
{
"gtk-cursor-theme-name",
"org.gnome.desktop.interface",
"cursor-theme"
},
{
"gtk-cursor-theme-size",
"org.gnome.desktop.interface",
"cursor-size"
},
{
"gtk-enable-animations",
"org.gnome.desktop.interface",
"enable-animations"
},
{
"gtk-im-module",
"org.gnome.desktop.interface",
"gtk-im-module"
},
{
"gtk-recent-files-max-age",
"org.gnome.desktop.privacy",
"recent-files-max-age"
},
{
"gtk-sound-theme-name",
"org.gnome.desktop.sound",
"theme-name"
},
{
"gtk-enable-input-feedback-sounds",
"org.gnome.desktop.sound",
"input-feedback-sounds"
},
{
"gtk-enable-event-sounds",
"org.gnome.desktop.sound",
"event-sounds"
},
{
"gtk-shell-shows-desktop",
"org.gnome.desktop.background",
"show-desktop-icons"
},
{
"gtk-decoration-layout",
"org.gnome.desktop.wm.preferences",
"button-layout"
},
{
"gtk-titlebar-double-click",
"org.gnome.desktop.wm.preferences",
"action-double-click-titlebar"
},
{
"gtk-titlebar-middle-click",
"org.gnome.desktop.wm.preferences",
"action-middle-click-titlebar"
},
{
"gtk-titlebar-right-click",
"org.gnome.desktop.wm.preferences",
"action-right-click-titlebar"
},
{
"gtk-enable-primary-paste",
"org.gnome.desktop.interface",
"gtk-enable-primary-paste"
},
{
"gtk-recent-files-enabled",
"org.gnome.desktop.privacy",
"remember-recent-files"
},
{
"gtk-keynav-use-caret",
"org.gnome.desktop.a11y",
"always-show-text-caret"
},
{ NULL }
};
static guint
get_scaling_factor (GdkMirScreen *screen)
{
GVariant *variant;
guint scaling_factor;
variant = read_setting (screen, "org.gnome.desktop.interface", "scaling-factor");
if (!variant)
{
g_warning ("no scaling factor: org.gnome.desktop.interface.scaling-factor");
variant = g_variant_ref_sink (g_variant_new_uint32 (0));
}
scaling_factor = g_variant_get_uint32 (variant);
g_variant_unref (variant);
if (scaling_factor)
return scaling_factor;
scaling_factor = 1;
/* TODO: scaling_factor = 2 if HiDPI >= 2 * 96 */
return scaling_factor;
}
static void
update_setting (GdkMirScreen *screen,
const gchar *name)
{
GVariant *variant;
GVariant *antialiasing_variant;
gboolean gtk_xft_antialias;
gboolean gtk_xft_hinting;
gdouble text_scaling_factor;
gint cursor_size;
gint i;
if (!g_strcmp0 (name, "gtk-modules"))
{
/* TODO: X-GTK-Module-Enabled-Schema, X-GTK-Module-Enabled-Key */
/* TODO: org.gnome.settings-daemon.plugins.xsettings.enabled-gtk-modules */
/* TODO: org.gnome.settings-daemon.plugins.xsettings.disabled-gtk-modules */
return;
}
else
{
for (i = 0; SETTINGS_MAP[i].name; i++)
if (!g_strcmp0 (name, SETTINGS_MAP[i].name))
break;
if (!SETTINGS_MAP[i].name)
return;
variant = read_setting (screen, SETTINGS_MAP[i].schema_id, SETTINGS_MAP[i].key);
if (!variant)
{
g_warning ("no setting for %s: %s.%s", SETTINGS_MAP[i].name, SETTINGS_MAP[i].schema_id, SETTINGS_MAP[i].key);
return;
}
}
if (!g_strcmp0 (name, "gtk-xft-antialias"))
{
gtk_xft_antialias = g_strcmp0 (g_variant_get_string (variant, NULL), "none");
g_variant_unref (variant);
variant = g_variant_ref_sink (g_variant_new_int32 (gtk_xft_antialias ? 1 : 0));
}
else if (!g_strcmp0 (name, "gtk-xft-hinting"))
{
gtk_xft_hinting = g_strcmp0 (g_variant_get_string (variant, NULL), "none");
g_variant_unref (variant);
variant = g_variant_ref_sink (g_variant_new_int32 (gtk_xft_hinting ? 1 : 0));
}
else if (!g_strcmp0 (name, "gtk-xft-hintstyle"))
{
if (!g_strcmp0 (g_variant_get_string (variant, NULL), "none"))
{
g_variant_unref (variant);
variant = g_variant_ref_sink (g_variant_new_string ("hintnone"));
}
else if (!g_strcmp0 (g_variant_get_string (variant, NULL), "slight"))
{
g_variant_unref (variant);
variant = g_variant_ref_sink (g_variant_new_string ("hintslight"));
}
else if (!g_strcmp0 (g_variant_get_string (variant, NULL), "medium"))
{
g_variant_unref (variant);
variant = g_variant_ref_sink (g_variant_new_string ("hintmedium"));
}
else if (!g_strcmp0 (g_variant_get_string (variant, NULL), "full"))
{
g_variant_unref (variant);
variant = g_variant_ref_sink (g_variant_new_string ("hintfull"));
}
else
{
g_warning ("unknown org.gnome.settings-daemon.plugins.xsettings.hinting value: %s", g_variant_get_string (variant, NULL));
g_variant_unref (variant);
return;
}
}
else if (!g_strcmp0 (name, "gtk-xft-rgba"))
{
antialiasing_variant = read_setting (screen, "org.gnome.settings-daemon.plugins.xsettings", "antialiasing");
if (g_strcmp0 (g_variant_get_string (antialiasing_variant, NULL), "rgba"))
{
g_variant_unref (variant);
variant = g_variant_ref_sink (g_variant_new_string ("none"));
}
else if (g_strcmp0 (g_variant_get_string (variant, NULL), "rgba"))
{
g_variant_unref (variant);
variant = g_variant_ref_sink (g_variant_new_string ("rgb"));
}
g_variant_unref (antialiasing_variant);
}
else if (!g_strcmp0 (name, "gtk-xft-dpi"))
{
text_scaling_factor = g_variant_get_double (variant);
g_variant_unref (variant);
variant = g_variant_ref_sink (g_variant_new_int32 (1024 * get_scaling_factor (screen) * text_scaling_factor + 0.5));
}
else if (!g_strcmp0 (name, "gtk-cursor-theme-size"))
{
cursor_size = g_variant_get_int32 (variant);
g_variant_unref (variant);
variant = g_variant_ref_sink (g_variant_new_int32 (get_scaling_factor (screen) * cursor_size));
}
else if (!g_strcmp0 (name, "gtk-enable-animations"))
{
/* TODO: disable under vnc/vino/llvmpipe */
}
change_setting (screen, name, variant);
g_variant_unref (variant);
}
static void
setting_changed (GSettings *settings,
const gchar *key,
GdkMirScreen *screen)
{
gchar *schema_id;
gint i;
g_object_get (settings, "schema-id", &schema_id, NULL);
for (i = 0; SETTINGS_MAP[i].name; i++)
if (!g_strcmp0 (schema_id, SETTINGS_MAP[i].schema_id) && !g_strcmp0 (key, SETTINGS_MAP[i].key))
update_setting (screen, SETTINGS_MAP[i].name);
if (!g_strcmp0 (schema_id, "org.gnome.settings-daemon.plugins.xsettings"))
{
if (!g_strcmp0 (key, "enabled-gtk-modules"))
update_setting (screen, "gtk-modules");
else if (!g_strcmp0 (key, "disabled-gtk-modules"))
update_setting (screen, "gtk-modules");
else if (!g_strcmp0 (key, "antialiasing"))
update_setting (screen, "rgba-order");
}
else if (!g_strcmp0 (schema_id, "org.gnome.desktop.interface"))
{
if (!g_strcmp0 (key, "scaling-factor"))
{
update_setting (screen, "gtk-xft-dpi");
update_setting (screen, "gtk-cursor-theme-size");
}
}
g_free (schema_id);
}
static const gchar * const KNOWN_SETTINGS[] =
{
"gtk-double-click-time",
"gtk-double-click-distance",
"gtk-cursor-blink",
"gtk-cursor-blink-time",
"gtk-cursor-blink-timeout",
"gtk-split-cursor",
"gtk-theme-name",
"gtk-icon-theme-name",
"gtk-key-theme-name",
"gtk-dnd-drag-threshold",
"gtk-font-name",
"gtk-modules",
"gtk-xft-antialias",
"gtk-xft-hinting",
"gtk-xft-hintstyle",
"gtk-xft-rgba",
"gtk-xft-dpi",
"gtk-cursor-theme-name",
"gtk-cursor-theme-size",
"gtk-alternative-button-order",
"gtk-alternative-sort-arrows",
"gtk-enable-animations",
"gtk-error-bell",
"gtk-print-backends",
"gtk-print-preview-command",
"gtk-enable-accels",
"gtk-im-module",
"gtk-recent-files-max-age",
"gtk-fontconfig-timestamp",
"gtk-sound-theme-name",
"gtk-enable-input-feedback-sounds",
"gtk-enable-event-sounds",
"gtk-primary-button-warps-slider",
"gtk-application-prefer-dark-theme",
"gtk-entry-select-on-focus",
"gtk-entry-password-hint-timeout",
"gtk-label-select-on-focus",
"gtk-shell-shows-app-menu",
"gtk-shell-shows-menubar",
"gtk-shell-shows-desktop",
"gtk-decoration-layout",
"gtk-titlebar-double-click",
"gtk-titlebar-middle-click",
"gtk-titlebar-right-click",
"gtk-dialogs-use-header",
"gtk-enable-primary-paste",
"gtk-recent-files-enabled",
"gtk-long-press-time",
"gtk-keynav-use-caret",
NULL
};
gboolean
gdk_mir_screen_get_setting (GdkScreen *screen,
const gchar *name,
GValue *value)
{
GdkMirScreen *mir_screen;
GVariant *variant;
mir_screen = GDK_MIR_SCREEN (screen);
variant = g_hash_table_lookup (mir_screen->current_settings, name);
if (!variant)
update_setting (mir_screen, name);
variant = g_hash_table_lookup (mir_screen->current_settings, name);
if (!variant)
{
if (!g_strv_contains (KNOWN_SETTINGS, name))
g_warning ("unknown setting: %s", name);
return FALSE;
}
g_dbus_gvariant_to_gvalue (variant, value);
return TRUE;
}
static void
gdk_mir_screen_init (GdkMirScreen *screen)
{
screen->settings_objects = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
screen->current_settings = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
}
static void
gdk_mir_screen_class_init (GdkMirScreenClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GdkScreenClass *screen_class = GDK_SCREEN_CLASS (klass);
object_class->dispose = gdk_mir_screen_dispose;
object_class->finalize = gdk_mir_screen_finalize;
screen_class->get_display = gdk_mir_screen_get_display;
screen_class->get_root_window = gdk_mir_screen_get_root_window;
}

52
gdk/mir/gdkmirwindow.c
View File

@ -1,52 +0,0 @@
/*
* Copyright © 2014 Canonical Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkinternals.h"
#include "gdkmir.h"
#define GDK_MIR_WINDOW(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW_MIR, GdkMirWindow))
#define GDK_MIR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_MIR, GdkMirWindowClass))
#define GDK_IS_WINDOW_MIR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_MIR))
#define GDK_MIR_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW_MIR, GdkMirWindowClass))
typedef struct _GdkMirWindow GdkMirWindow;
typedef struct _GdkMirWindowClass GdkMirWindowClass;
struct _GdkMirWindow
{
GdkWindow parent_instance;
};
struct _GdkMirWindowClass
{
GdkWindowClass parent_class;
};
G_DEFINE_TYPE (GdkMirWindow, gdk_mir_window, GDK_TYPE_WINDOW)
static void
gdk_mir_window_init (GdkMirWindow *impl)
{
}
static void
gdk_mir_window_class_init (GdkMirWindowClass *klass)
{
}

1948
gdk/mir/gdkmirwindowimpl.c
View File

File diff suppressed because it is too large Load Diff

31
gdk/mir/meson.build
View File

@ -1,31 +0,0 @@
gdk_mir_sources = files([
'gdkmircursor.c',
'gdkmirdevicemanager.c',
'gdkmirdisplay.c',
'gdkmireventsource.c',
'gdkmirglcontext.c',
'gdkmirkeyboard.c',
'gdkmirkeymap.c',
'gdkmirpointer.c',
'gdkmirscreen.c',
'gdkmirwindow.c',
'gdkmirwindowimpl.c',
'gdkmir-debug.c',
])
#gdk_mir_public_headers = []
#install_headers(gdk_mir_public_headers, subdir: 'gtk-4.0/gdk/mir/')
install_headers('gdkmir.h', subdir: 'gtk-4.0/gdk/')
gdk_mir_deps = [
mirclient_dep,
mircookie_dep,
libcontent_hub_glib_dep,
]
libgdk_mir = static_library('gdk-mir',
gdk_mir_sources, gdkconfig, gdkenum_h,
include_directories: [confinc, gdkinc],
c_args: ['-DGDK_COMPILATION', '-DG_LOG_DOMAIN="Gdk"'],
dependencies: [gdk_deps, gdk_mir_deps])

22
meson.build
View File

@ -34,8 +34,6 @@ gdk_pixbuf_req = '>= 2.30.0'
introspection_req = '>= 1.39.0' introspection_req = '>= 1.39.0'
wayland_proto_req = '>= 1.9' wayland_proto_req = '>= 1.9'
wayland_req = '>= 1.9.91' wayland_req = '>= 1.9.91'
mirclient_req = '>= 0.22.0'
mircookie_req = '>= 0.17.0'
graphene_req = '>= 1.5.1' graphene_req = '>= 1.5.1'
epoxy_req = '>= 1.4' epoxy_req = '>= 1.4'
cloudproviders_req = '>= 0.2.5' cloudproviders_req = '>= 0.2.5'
@ -92,7 +90,6 @@ gtk_api_version = '4.0'
x11_enabled = get_option('enable-x11-backend') x11_enabled = get_option('enable-x11-backend')
wayland_enabled = get_option('enable-wayland-backend') wayland_enabled = get_option('enable-wayland-backend')
broadway_enabled = get_option('enable-broadway-backend') broadway_enabled = get_option('enable-broadway-backend')
mir_enabled = get_option('enable-mir-backend')
quartz_enabled = get_option('enable-quartz-backend') quartz_enabled = get_option('enable-quartz-backend')
win32_enabled = get_option('enable-win32-backend') win32_enabled = get_option('enable-win32-backend')
cloudproviders_enabled = get_option('enable-cloudproviders') cloudproviders_enabled = get_option('enable-cloudproviders')
@ -364,7 +361,7 @@ cairo_backends = []
foreach backend: [ ['cairo-xlib', cairo_req, x11_enabled], foreach backend: [ ['cairo-xlib', cairo_req, x11_enabled],
['cairo-win32', cairo_req, win32_enabled], ['cairo-win32', cairo_req, win32_enabled],
['cairo-quartz', cairo_req, quartz_enabled], ['cairo-quartz', cairo_req, quartz_enabled],
['cairo', cairo_req, broadway_enabled or wayland_enabled or mir_enabled], ] ['cairo', cairo_req, broadway_enabled or wayland_enabled], ]
backend_enabled = backend.get(2) backend_enabled = backend.get(2)
cairo_backend_req = backend.get(1) cairo_backend_req = backend.get(1)
cairo_backend = backend.get(0) cairo_backend = backend.get(0)
@ -519,19 +516,6 @@ if x11_enabled
cdata.set('HAVE_RANDR15', xrandr15_dep.found()) cdata.set('HAVE_RANDR15', xrandr15_dep.found())
endif endif
mir_pkgs = []
if mir_enabled
mirclient_dep = dependency('mirclient', version: mirclient_req)
mircookie_dep = dependency('mircookie', version: mircookie_req)
libcontent_hub_glib_dep = dependency('libcontenthub-glib')
mir_pkgs = [
'mirclient', mirclient_req,
'mircookie', mircookie_req,
'libcontent-hub-glib',
]
endif
if broadway_enabled if broadway_enabled
pc_gdk_extra_libs += ['-lz'] pc_gdk_extra_libs += ['-lz']
backend_immodules += ['broadway'] backend_immodules += ['broadway']
@ -653,7 +637,7 @@ pc_gdk_extra_libs += cairo_libs
gio_pkgname = os_unix ? 'gio-unix-2.0' : 'gio-2.0' gio_pkgname = os_unix ? 'gio-unix-2.0' : 'gio-2.0'
pkgconf.set('GDK_PRIVATE_PACKAGES', pkgconf.set('GDK_PRIVATE_PACKAGES',
' '.join([ gio_pkgname, glib_req, ' '.join([ gio_pkgname, glib_req,
'epoxy', epoxy_req ] + x11_pkgs + wayland_pkgs + mir_pkgs + cairo_backends)) 'epoxy', epoxy_req ] + x11_pkgs + wayland_pkgs + cairo_backends))
pkgconf.set('GSK_PRIVATE_PACKAGES', '') # all already in GDK_PRIVATE_PACKAGES pkgconf.set('GSK_PRIVATE_PACKAGES', '') # all already in GDK_PRIVATE_PACKAGES
pangoft2_pkgs = (wayland_enabled or x11_enabled) ? ['pangoft2'] : [] pangoft2_pkgs = (wayland_enabled or x11_enabled) ? ['pangoft2'] : []
pkgconf.set('GTK_PRIVATE_PACKAGES', ' '.join(atk_pkgs + pangoft2_pkgs)) pkgconf.set('GTK_PRIVATE_PACKAGES', ' '.join(atk_pkgs + pangoft2_pkgs))
@ -671,7 +655,7 @@ pkg_install_dir = join_paths(get_option('libdir'), 'pkgconfig')
pkgs = [ 'gtk+-4.0.pc' ] pkgs = [ 'gtk+-4.0.pc' ]
pkg_targets = '' pkg_targets = ''
foreach backend: [ 'broadway', 'mir', 'quartz', 'wayland', 'win32', 'x11', ] foreach backend: [ 'broadway', 'quartz', 'wayland', 'win32', 'x11', ]
if get_variable('@0@_enabled'.format(backend)) if get_variable('@0@_enabled'.format(backend))
pkgs += ['gtk+-@0@-4.0.pc'.format(backend)] pkgs += ['gtk+-@0@-4.0.pc'.format(backend)]
pkg_targets += ' ' + backend pkg_targets += ' ' + backend

2
meson_options.txt
View File

@ -6,8 +6,6 @@ option('enable-wayland-backend', type: 'boolean', value: 'true',
description : 'Enable the wayland gdk backend') description : 'Enable the wayland gdk backend')
option('enable-broadway-backend', type: 'boolean', value: 'false', option('enable-broadway-backend', type: 'boolean', value: 'false',
description : 'Enable the broadway (HTML5) gdk backend') description : 'Enable the broadway (HTML5) gdk backend')
option('enable-mir-backend', type: 'boolean', value: 'false',
description : 'Enable the Mir gdk backend (UNTESTED, NEEDS WORK)')
option('enable-win32-backend', type: 'boolean', value: 'false', option('enable-win32-backend', type: 'boolean', value: 'false',
description : 'Enable the Windows gdk backend') description : 'Enable the Windows gdk backend')
option('enable-quartz-backend', type: 'boolean', value: 'false', option('enable-quartz-backend', type: 'boolean', value: 'false',