mainnika
/
weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update to new libxkbcommon API

Browse Source 
We no longer depend on xproto, we use xkbcommon keycodes now. Yay!
Kristian Høgsberg 13 years ago
parent d174521b56
commit bef52d1423
6 changed files with 72 additions and 81 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      clients/clickdot.c
  2. 12
      clients/resizor.c
  3. 110
      clients/terminal.c
  4. 11
      clients/window.c
  5. 2
      src/compositor-x11.c
  6. 14
      src/compositor.c

4
clients/clickdot.c
Unescape View File

@ -35,8 +35,6 @@
#include "window.h" #include "window.h"
#include <X11/keysym.h>
struct clickdot { struct clickdot {
struct display *display; struct display *display;
struct window *window; struct window *window;
@ -190,7 +188,7 @@ key_handler(struct window *window, struct input *input, uint32_t time,
return; return;
switch (sym) { switch (sym) {
case XK_Escape: case XKB_KEY_Escape:
display_exit(clickdot->display); display_exit(clickdot->display);
break; break;
} }

12
clients/resizor.c
Unescape View File

@ -33,8 +33,6 @@
#include "window.h" #include "window.h"
#include <X11/keysym.h>
struct spring { struct spring {
double current; double current;
double target; double target;
@ -158,35 +156,35 @@ key_handler(struct window *window, struct input *input, uint32_t time,
resizor->height.target = allocation.height; resizor->height.target = allocation.height;
switch (sym) { switch (sym) {
case XK_Up: case XKB_KEY_Up:
if (allocation.height < 400) if (allocation.height < 400)
break; break;
resizor->height.target = allocation.height - 200; resizor->height.target = allocation.height - 200;
break; break;
case XK_Down: case XKB_KEY_Down:
if (allocation.height > 1000) if (allocation.height > 1000)
break; break;
resizor->height.target = allocation.height + 200; resizor->height.target = allocation.height + 200;
break; break;
case XK_Left: case XKB_KEY_Left:
if (allocation.width < 400) if (allocation.width < 400)
break; break;
resizor->width.target = allocation.width - 200; resizor->width.target = allocation.width - 200;
break; break;
case XK_Right: case XKB_KEY_Right:
if (allocation.width > 1000) if (allocation.width > 1000)
break; break;
resizor->width.target = allocation.width + 200; resizor->width.target = allocation.width + 200;
break; break;
case XK_Escape: case XKB_KEY_Escape:
display_exit(resizor->display); display_exit(resizor->display);
break; break;
} }

110
clients/terminal.c
Unescape View File

@ -34,8 +34,6 @@
#include <glib.h> #include <glib.h>
#include <sys/epoll.h> #include <sys/epoll.h>
#include <X11/keysym.h>
#include <wayland-client.h> #include <wayland-client.h>
#include "window.h" #include "window.h"
@ -241,28 +239,28 @@ struct key_map {
typedef struct key_map *keyboard_mode; typedef struct key_map *keyboard_mode;
static struct key_map KM_NORMAL[] = { static struct key_map KM_NORMAL[] = {
{XK_Left, 1, '[', 'D'}, { XKB_KEY_Left, 1, '[', 'D' },
{XK_Right, 1, '[', 'C'}, { XKB_KEY_Right, 1, '[', 'C' },
{XK_Up, 1, '[', 'A'}, { XKB_KEY_Up, 1, '[', 'A' },
{XK_Down, 1, '[', 'B'}, { XKB_KEY_Down, 1, '[', 'B' },
{XK_Home, 1, '[', 'H'}, { XKB_KEY_Home, 1, '[', 'H' },
{XK_End, 1, '[', 'F'}, { XKB_KEY_End, 1, '[', 'F' },
{0, 0, 0, 0} { 0, 0, 0, 0 }
}; };
static struct key_map KM_APPLICATION[] = { static struct key_map KM_APPLICATION[] = {
{XK_Left, 1, 'O', 'D'}, { XKB_KEY_Left, 1, 'O', 'D' },
{XK_Right, 1, 'O', 'C'}, { XKB_KEY_Right, 1, 'O', 'C' },
{XK_Up, 1, 'O', 'A'}, { XKB_KEY_Up, 1, 'O', 'A' },
{XK_Down, 1, 'O', 'B'}, { XKB_KEY_Down, 1, 'O', 'B' },
{XK_Home, 1, 'O', 'H'}, { XKB_KEY_Home, 1, 'O', 'H' },
{XK_End, 1, 'O', 'F'}, { XKB_KEY_End, 1, 'O', 'F' },
{XK_KP_Enter, 1, 'O', 'M'}, { XKB_KEY_KP_Enter, 1, 'O', 'M' },
{XK_KP_Multiply, 1, 'O', 'j'}, { XKB_KEY_KP_Multiply, 1, 'O', 'j' },
{XK_KP_Add, 1, 'O', 'k'}, { XKB_KEY_KP_Add, 1, 'O', 'k' },
{XK_KP_Separator, 1, 'O', 'l'}, { XKB_KEY_KP_Separator, 1, 'O', 'l' },
{XK_KP_Subtract, 1, 'O', 'm'}, { XKB_KEY_KP_Subtract, 1, 'O', 'm' },
{XK_KP_Divide, 1, 'O', 'o'}, { XKB_KEY_KP_Divide, 1, 'O', 'o' },
{0, 0, 0, 0} { 0, 0, 0, 0 }
}; };
static int static int
@ -2045,10 +2043,10 @@ handle_bound_key(struct terminal *terminal,
struct input *input, uint32_t sym, uint32_t time) struct input *input, uint32_t sym, uint32_t time)
{ {
switch (sym) { switch (sym) {
case XK_X: case XKB_KEY_X:
/* Cut selection; terminal doesn't do cut, fall /* Cut selection; terminal doesn't do cut, fall
* through to copy. */ * through to copy. */
case XK_C: case XKB_KEY_C:
terminal->selection = terminal->selection =
display_create_data_source(terminal->display); display_create_data_source(terminal->display);
wl_data_source_offer(terminal->selection, wl_data_source_offer(terminal->selection,
@ -2057,7 +2055,7 @@ handle_bound_key(struct terminal *terminal,
&data_source_listener, terminal); &data_source_listener, terminal);
input_set_selection(input, terminal->selection, time); input_set_selection(input, terminal->selection, time);
return 1; return 1;
case XK_V: case XKB_KEY_V:
input_receive_selection_data_to_fd(input, input_receive_selection_data_to_fd(input,
"text/plain;charset=utf-8", "text/plain;charset=utf-8",
terminal->master); terminal->master);
@ -2084,25 +2082,25 @@ key_handler(struct window *window, struct input *input, uint32_t time,
return; return;
switch (sym) { switch (sym) {
case XK_F11: case XKB_KEY_F11:
if (!state) if (!state)
break; break;
terminal->fullscreen ^= 1; terminal->fullscreen ^= 1;
window_set_fullscreen(window, terminal->fullscreen); window_set_fullscreen(window, terminal->fullscreen);
break; break;
case XK_BackSpace: case XKB_KEY_BackSpace:
case XK_Tab: case XKB_KEY_Tab:
case XK_Linefeed: case XKB_KEY_Linefeed:
case XK_Clear: case XKB_KEY_Clear:
case XK_Pause: case XKB_KEY_Pause:
case XK_Scroll_Lock: case XKB_KEY_Scroll_Lock:
case XK_Sys_Req: case XKB_KEY_Sys_Req:
case XK_Escape: case XKB_KEY_Escape:
ch[len++] = sym & 0x7f; ch[len++] = sym & 0x7f;
break; break;
case XK_Return: case XKB_KEY_Return:
if (terminal->mode & MODE_LF_NEWLINE) { if (terminal->mode & MODE_LF_NEWLINE) {
ch[len++] = 0x0D; ch[len++] = 0x0D;
ch[len++] = 0x0A; ch[len++] = 0x0A;
@ -2111,61 +2109,61 @@ key_handler(struct window *window, struct input *input, uint32_t time,
} }
break; break;
case XK_Shift_L: case XKB_KEY_Shift_L:
case XK_Shift_R: case XKB_KEY_Shift_R:
case XK_Control_L: case XKB_KEY_Control_L:
case XK_Control_R: case XKB_KEY_Control_R:
case XK_Alt_L: case XKB_KEY_Alt_L:
case XK_Alt_R: case XKB_KEY_Alt_R:
break; break;
case XK_Insert: case XKB_KEY_Insert:
len = function_key_response('[', 2, modifiers, '~', ch); len = function_key_response('[', 2, modifiers, '~', ch);
break; break;
case XK_Delete: case XKB_KEY_Delete:
if (terminal->mode & MODE_DELETE_SENDS_DEL) { if (terminal->mode & MODE_DELETE_SENDS_DEL) {
ch[len++] = '\x04'; ch[len++] = '\x04';
} else { } else {
len = function_key_response('[', 3, modifiers, '~', ch); len = function_key_response('[', 3, modifiers, '~', ch);
} }
break; break;
case XK_Page_Up: case XKB_KEY_Page_Up:
len = function_key_response('[', 5, modifiers, '~', ch); len = function_key_response('[', 5, modifiers, '~', ch);
break; break;
case XK_Page_Down: case XKB_KEY_Page_Down:
len = function_key_response('[', 6, modifiers, '~', ch); len = function_key_response('[', 6, modifiers, '~', ch);
break; break;
case XK_F1: case XKB_KEY_F1:
len = function_key_response('O', 1, modifiers, 'P', ch); len = function_key_response('O', 1, modifiers, 'P', ch);
break; break;
case XK_F2: case XKB_KEY_F2:
len = function_key_response('O', 1, modifiers, 'Q', ch); len = function_key_response('O', 1, modifiers, 'Q', ch);
break; break;
case XK_F3: case XKB_KEY_F3:
len = function_key_response('O', 1, modifiers, 'R', ch); len = function_key_response('O', 1, modifiers, 'R', ch);
break; break;
case XK_F4: case XKB_KEY_F4:
len = function_key_response('O', 1, modifiers, 'S', ch); len = function_key_response('O', 1, modifiers, 'S', ch);
break; break;
case XK_F5: case XKB_KEY_F5:
len = function_key_response('[', 15, modifiers, '~', ch); len = function_key_response('[', 15, modifiers, '~', ch);
break; break;
case XK_F6: case XKB_KEY_F6:
len = function_key_response('[', 17, modifiers, '~', ch); len = function_key_response('[', 17, modifiers, '~', ch);
break; break;
case XK_F7: case XKB_KEY_F7:
len = function_key_response('[', 18, modifiers, '~', ch); len = function_key_response('[', 18, modifiers, '~', ch);
break; break;
case XK_F8: case XKB_KEY_F8:
len = function_key_response('[', 19, modifiers, '~', ch); len = function_key_response('[', 19, modifiers, '~', ch);
break; break;
case XK_F9: case XKB_KEY_F9:
len = function_key_response('[', 20, modifiers, '~', ch); len = function_key_response('[', 20, modifiers, '~', ch);
break; break;
case XK_F10: case XKB_KEY_F10:
len = function_key_response('[', 21, modifiers, '~', ch); len = function_key_response('[', 21, modifiers, '~', ch);
break; break;
case XK_F12: case XKB_KEY_F12:
len = function_key_response('[', 24, modifiers, '~', ch); len = function_key_response('[', 24, modifiers, '~', ch);
break; break;
default: default:

11
clients/window.c
Unescape View File

@ -56,8 +56,6 @@
#endif #endif
#include <xkbcommon/xkbcommon.h> #include <xkbcommon/xkbcommon.h>
#include <X11/keysym.h>
#include <X11/X.h>
#include <X11/Xcursor/Xcursor.h> #include <X11/Xcursor/Xcursor.h>
#include <linux/input.h> #include <linux/input.h>
@ -1833,7 +1831,7 @@ input_handle_key(void *data, struct wl_input_device *input_device,
xkb_state_update_key(d->xkb.state, code, xkb_state_update_key(d->xkb.state, code,
state ? XKB_KEY_DOWN : XKB_KEY_UP); state ? XKB_KEY_DOWN : XKB_KEY_UP);
mask = xkb_state_serialise_mods(d->xkb.state, mask = xkb_state_serialize_mods(d->xkb.state,
XKB_STATE_DEPRESSED | XKB_STATE_DEPRESSED |
XKB_STATE_LATCHED); XKB_STATE_LATCHED);
input->modifiers = 0; input->modifiers = 0;
@ -1844,7 +1842,7 @@ input_handle_key(void *data, struct wl_input_device *input_device,
if (mask & input->display->xkb.shift_mask) if (mask & input->display->xkb.shift_mask)
input->modifiers |= MOD_SHIFT_MASK; input->modifiers |= MOD_SHIFT_MASK;
if (num_syms == 1 && syms[0] == XK_F5 && if (num_syms == 1 && syms[0] == XKB_KEY_F5 &&
input->modifiers == MOD_ALT_MASK) { input->modifiers == MOD_ALT_MASK) {
if (state) if (state)
window_set_maximized(window, window_set_maximized(window,
@ -3121,14 +3119,13 @@ init_xkb(struct display *d)
d->xkb.names.variant = (char *) option_xkb_variant; d->xkb.names.variant = (char *) option_xkb_variant;
d->xkb.names.options = (char *) option_xkb_options; d->xkb.names.options = (char *) option_xkb_options;
d->xkb.context = xkb_context_new(); d->xkb.context = xkb_context_new(0);
if (!d->xkb.context) { if (!d->xkb.context) {
fprintf(stderr, "Failed to create XKB context\n"); fprintf(stderr, "Failed to create XKB context\n");
exit(1); exit(1);
} }
d->xkb.keymap = d->xkb.keymap = xkb_map_new_from_names(d->xkb.context, &d->xkb.names, 0);
xkb_map_new_from_names(d->xkb.context, &d->xkb.names);
if (!d->xkb.keymap) { if (!d->xkb.keymap) {
fprintf(stderr, "Failed to compile keymap\n"); fprintf(stderr, "Failed to compile keymap\n");
exit(1); exit(1);

2
src/compositor-x11.c
Unescape View File

@ -737,7 +737,7 @@ x11_compositor_get_keymap(struct x11_compositor *c)
length_part = strlen(value_part); \ length_part = strlen(value_part); \
if (value_part + length_part > (value_all + length_all) && \ if (value_part + length_part > (value_all + length_all) && \
length_part > 0 && c->base.xkb_info.names.to == NULL) { \ length_part > 0 && c->base.xkb_info.names.to == NULL) { \
free(c->base.xkb_info.names.to); \ free((char *) c->base.xkb_info.names.to); \
c->base.xkb_info.names.to = strdup(value_part); \ c->base.xkb_info.names.to = strdup(value_part); \
} \ } \
value_part += length_part + 1; value_part += length_part + 1;

14
src/compositor.c
Unescape View File

@ -2614,7 +2614,7 @@ weston_compositor_shutdown(struct weston_compositor *ec)
static int weston_compositor_xkb_init(struct weston_compositor *ec, static int weston_compositor_xkb_init(struct weston_compositor *ec,
struct xkb_rule_names *names) struct xkb_rule_names *names)
{ {
ec->xkb_info.context = xkb_context_new(); ec->xkb_info.context = xkb_context_new(0);
if (ec->xkb_info.context == NULL) { if (ec->xkb_info.context == NULL) {
fprintf(stderr, "failed to create XKB context\n"); fprintf(stderr, "failed to create XKB context\n");
return -1; return -1;
@ -2629,7 +2629,7 @@ static int weston_compositor_xkb_init(struct weston_compositor *ec,
ec->xkb_info.names.layout = strdup("us"); ec->xkb_info.names.layout = strdup("us");
ec->xkb_info.keymap = xkb_map_new_from_names(ec->xkb_info.context, ec->xkb_info.keymap = xkb_map_new_from_names(ec->xkb_info.context,
&ec->xkb_info.names); &ec->xkb_info.names, 0);
if (ec->xkb_info.keymap == NULL) { if (ec->xkb_info.keymap == NULL) {
fprintf(stderr, "failed to compile XKB keymap\n"); fprintf(stderr, "failed to compile XKB keymap\n");
return -1; return -1;
@ -2650,11 +2650,11 @@ static void weston_compositor_xkb_destroy(struct weston_compositor *ec)
xkb_map_unref(ec->xkb_info.keymap); xkb_map_unref(ec->xkb_info.keymap);
xkb_context_unref(ec->xkb_info.context); xkb_context_unref(ec->xkb_info.context);
free(ec->xkb_info.names.rules); free((char *) ec->xkb_info.names.rules);
free(ec->xkb_info.names.model); free((char *) ec->xkb_info.names.model);
free(ec->xkb_info.names.layout); free((char *) ec->xkb_info.names.layout);
free(ec->xkb_info.names.variant); free((char *) ec->xkb_info.names.variant);
free(ec->xkb_info.names.options); free((char *) ec->xkb_info.names.options);
} }
static int on_term_signal(int signal_number, void *data) static int on_term_signal(int signal_number, void *data)

Write Preview
Loading…
Cancel
Save