AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-25 05:01:09 +00:00
Code Issues 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"
#endif
#ifdef GDK_WINDOWING_MIR
#include "mir/gdkmir-private.h"
#endif
/**
* SECTION:gdkdisplaymanager
* @Short_description: Maintains a list of all open GdkDisplays
@ -276,9 +272,6 @@ static GdkBackend gdk_backends[] = {
#ifdef GDK_WINDOWING_WAYLAND
{ "wayland", _gdk_wayland_display_open },
#endif
#ifdef GDK_WINDOWING_MIR
{ "mir", _gdk_mir_display_open },
#endif
#ifdef GDK_WINDOWING_X11
{ "x11", gdk_x11_display_open },
#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_WIN32', win32_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 = configure_file(
@ -192,7 +191,7 @@ endif
gdk_backends = []
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))
subdir(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'
wayland_proto_req = '>= 1.9'
wayland_req = '>= 1.9.91'
mirclient_req = '>= 0.22.0'
mircookie_req = '>= 0.17.0'
graphene_req = '>= 1.5.1'
epoxy_req = '>= 1.4'
cloudproviders_req = '>= 0.2.5'
@ -92,7 +90,6 @@ gtk_api_version = '4.0'
x11_enabled = get_option('enable-x11-backend')
wayland_enabled = get_option('enable-wayland-backend')
broadway_enabled = get_option('enable-broadway-backend')
mir_enabled = get_option('enable-mir-backend')
quartz_enabled = get_option('enable-quartz-backend')
win32_enabled = get_option('enable-win32-backend')
cloudproviders_enabled = get_option('enable-cloudproviders')
@ -364,7 +361,7 @@ cairo_backends = []
foreach backend: [ ['cairo-xlib', cairo_req, x11_enabled],
['cairo-win32', cairo_req, win32_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)
cairo_backend_req = backend.get(1)
cairo_backend = backend.get(0)
@ -519,19 +516,6 @@ if x11_enabled
cdata.set('HAVE_RANDR15', xrandr15_dep.found())
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
pc_gdk_extra_libs += ['-lz']
backend_immodules += ['broadway']
@ -653,7 +637,7 @@ pc_gdk_extra_libs += cairo_libs
gio_pkgname = os_unix ? 'gio-unix-2.0' : 'gio-2.0'
pkgconf.set('GDK_PRIVATE_PACKAGES',
' '.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
pangoft2_pkgs = (wayland_enabled or x11_enabled) ? ['pangoft2'] : []
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' ]
pkg_targets = ''
foreach backend: [ 'broadway', 'mir', 'quartz', 'wayland', 'win32', 'x11', ]
foreach backend: [ 'broadway', 'quartz', 'wayland', 'win32', 'x11', ]
if get_variable('@0@_enabled'.format(backend))
pkgs += ['gtk+-@0@-4.0.pc'.format(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')
option('enable-broadway-backend', type: 'boolean', value: 'false',
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',
description : 'Enable the Windows gdk backend')
option('enable-quartz-backend', type: 'boolean', value: 'false',