#include <linux/input.h>
#include <wayland-client.h>
#include "../shared/cairo-util.h"
+#include "xdg-shell-client-protocol.h"
#include "text-cursor-position-client-protocol.h"
#include "workspaces-client-protocol.h"
#include "../shared/os-compatibility.h"
struct wl_registry *registry;
struct wl_compositor *compositor;
struct wl_subcompositor *subcompositor;
- struct wl_shell *shell;
struct wl_shm *shm;
struct wl_data_device_manager *data_device_manager;
struct text_cursor_position *text_cursor_position;
struct workspace_manager *workspace_manager;
+ struct xdg_shell *xdg_shell;
EGLDisplay dpy;
EGLConfig argb_config;
EGLContext argb_ctx;
int seat_version;
};
-enum {
- TYPE_NONE,
- TYPE_TOPLEVEL,
- TYPE_FULLSCREEN,
- TYPE_MAXIMIZED,
- TYPE_TRANSIENT,
- TYPE_MENU,
- TYPE_CUSTOM
-};
-
struct window_output {
struct output *output;
struct wl_list link;
struct window {
struct display *display;
- struct window *parent;
struct wl_list window_output_list;
char *title;
struct rectangle saved_allocation;
struct rectangle min_allocation;
struct rectangle pending_allocation;
+ struct rectangle last_geometry;
int x, y;
- int resize_edges;
int redraw_needed;
int redraw_task_scheduled;
struct task redraw_task;
int resize_needed;
- int saved_type;
- int type;
- int focus_count;
+ int custom;
+ int focused;
int resizing;
- int fullscreen_method;
- int configure_requests;
+
+ int fullscreen;
+ int maximized;
enum preferred_format preferred_format;
window_close_handler_t close_handler;
window_fullscreen_handler_t fullscreen_handler;
window_output_handler_t output_handler;
+ window_state_changed_handler_t state_changed_handler;
struct surface *main_surface;
- struct wl_shell_surface *shell_surface;
+ struct xdg_surface *xdg_surface;
+ struct xdg_popup *xdg_popup;
+
+ struct window *parent;
+ struct wl_surface *last_parent_surface;
struct window_frame *frame;
int opaque;
int tooltip_count;
int default_cursor;
+ /* If this is set to false then no cairo surface will be
+ * created before redrawing the surface. This is useful if the
+ * redraw handler is going to do completely custom rendering
+ * such as using EGL directly */
+ int use_cairo;
};
struct touch_point {
int32_t id;
+ float x, y;
struct widget *widget;
struct wl_list link;
};
struct wl_data_device *data_device;
struct data_offer *drag_offer;
struct data_offer *selection_offer;
+ uint32_t touch_grab;
+ int32_t touch_grab_id;
+ float drag_x, drag_y;
+ struct window *drag_focus;
+ uint32_t drag_enter_serial;
struct {
struct xkb_keymap *keymap;
xkb_mod_mask_t shift_mask;
} xkb;
+ int32_t repeat_rate_sec;
+ int32_t repeat_rate_nsec;
+ int32_t repeat_delay_sec;
+ int32_t repeat_delay_nsec;
+
struct task repeat_task;
int repeat_timer_fd;
uint32_t repeat_sym;
struct wl_list link;
int transform;
int scale;
+ char *make;
+ char *model;
display_output_handler_t destroy_handler;
void *user_data;
struct widget *widget;
struct widget *child;
struct frame *frame;
+
+ uint32_t last_time;
+ uint32_t did_double, double_click;
};
struct menu {
+ void *user_data;
struct window *window;
struct widget *widget;
struct input *input;
struct tooltip {
struct widget *parent;
- struct window *window;
struct widget *widget;
char *entry;
struct task tooltip_task;
CURSOR_UNSET
};
-enum window_location {
- WINDOW_INTERIOR = 0,
- WINDOW_RESIZING_TOP = 1,
- WINDOW_RESIZING_BOTTOM = 2,
- WINDOW_RESIZING_LEFT = 4,
- WINDOW_RESIZING_TOP_LEFT = 5,
- WINDOW_RESIZING_BOTTOM_LEFT = 6,
- WINDOW_RESIZING_RIGHT = 8,
- WINDOW_RESIZING_TOP_RIGHT = 9,
- WINDOW_RESIZING_BOTTOM_RIGHT = 10,
- WINDOW_RESIZING_MASK = 15,
- WINDOW_EXTERIOR = 16,
- WINDOW_TITLEBAR = 17,
- WINDOW_CLIENT_AREA = 18,
-};
-
static const cairo_user_data_key_t shm_surface_data_key;
/* #define DEBUG */
if (!device)
return;
- if (!eglMakeCurrent(surface->display->dpy, NULL, NULL,
- surface->display->argb_ctx))
+ if (!eglMakeCurrent(surface->display->dpy,
+ EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT))
fprintf(stderr, "failed to make context current\n");
cairo_device_release(device);
surface->flags,
leaf->resize_pool,
&leaf->data);
+ if (!leaf->cairo_surface)
+ return NULL;
+
wl_buffer_add_listener(leaf->data->buffer,
&shm_surface_buffer_listener, surface);
weston_config_destroy(config);
display->cursor_theme = wl_cursor_theme_load(theme, size, display->shm);
+ if (!display->cursor_theme) {
+ fprintf(stderr, "could not load theme '%s'\n", theme);
+ return;
+ }
free(theme);
display->cursors =
xmalloc(ARRAY_LENGTH(cursors) * sizeof display->cursors[0]);
int
window_has_focus(struct window *window)
{
- return window->focus_count > 0;
+ return window->focused;
}
static void
-window_flush(struct window *window)
+window_close(struct window *window)
{
- struct surface *surface;
-
- if (window->type == TYPE_NONE) {
- window->type = TYPE_TOPLEVEL;
- if (window->shell_surface)
- wl_shell_surface_set_toplevel(window->shell_surface);
- }
-
- wl_list_for_each(surface, &window->subsurface_list, link) {
- if (surface == window->main_surface)
- continue;
-
- surface_flush(surface);
- }
-
- surface_flush(window->main_surface);
+ if (window->close_handler)
+ window->close_handler(window->user_data);
+ else
+ display_exit(window->display);
}
struct display *
}
static void
-surface_create_surface(struct surface *surface, int dx, int dy, uint32_t flags)
+surface_create_surface(struct surface *surface, uint32_t flags)
{
struct display *display = surface->window->display;
struct rectangle allocation = surface->allocation;
flags, &allocation);
surface->cairo_surface = surface->toysurface->prepare(
- surface->toysurface, dx, dy,
+ surface->toysurface, 0, 0,
allocation.width, allocation.height, flags,
surface->buffer_transform, surface->buffer_scale);
}
{
struct surface *surface = window->main_surface;
uint32_t flags = 0;
- int dx = 0;
- int dy = 0;
if (window->resizing)
flags |= SURFACE_HINT_RESIZE;
if (window->preferred_format == WINDOW_PREFERRED_FORMAT_RGB565)
flags |= SURFACE_HINT_RGB565;
- if (window->resize_edges & WINDOW_RESIZING_LEFT)
- dx = surface->server_allocation.width -
- surface->allocation.width;
-
- if (window->resize_edges & WINDOW_RESIZING_TOP)
- dy = surface->server_allocation.height -
- surface->allocation.height;
-
- window->resize_edges = 0;
-
- surface_create_surface(surface, dx, dy, flags);
+ surface_create_surface(surface, flags);
}
int
if (window->frame)
window_frame_destroy(window->frame);
- if (window->shell_surface)
- wl_shell_surface_destroy(window->shell_surface);
+ if (window->xdg_surface)
+ xdg_surface_destroy(window->xdg_surface);
+ if (window->xdg_popup)
+ xdg_popup_destroy(window->xdg_popup);
surface_destroy(window->main_surface);
widget->tooltip = NULL;
widget->tooltip_count = 0;
widget->default_cursor = CURSOR_LEFT_PTR;
+ widget->use_cairo = 1;
return widget;
}
if (surface->widget == widget && surface->subsurface)
surface_destroy(widget->surface);
- if (widget->tooltip) {
- free(widget->tooltip);
- widget->tooltip = NULL;
- }
+ if (widget->tooltip)
+ widget_destroy_tooltip(widget);
wl_list_for_each(input, &display->input_list, link) {
if (input->focus_widget == widget)
struct surface *surface = widget->surface;
struct window *window = widget->window;
+ assert(widget->use_cairo);
+
if (!surface->cairo_surface) {
if (surface == window->main_surface)
window_create_main_surface(window);
else
- surface_create_surface(surface, 0, 0, 0);
+ surface_create_surface(surface, 0);
}
return surface->cairo_surface;
return widget->surface->surface;
}
+struct wl_subsurface *
+widget_get_wl_subsurface(struct widget *widget)
+{
+ return widget->surface->subsurface;
+}
+
uint32_t
widget_get_last_time(struct widget *widget)
{
window_schedule_redraw_task(widget->window);
}
+void
+widget_set_use_cairo(struct widget *widget,
+ int use_cairo)
+{
+ widget->use_cairo = use_cairo;
+}
+
cairo_surface_t *
window_get_surface(struct window *window)
{
return window->main_surface->surface;
}
-struct wl_shell_surface *
-window_get_wl_shell_surface(struct window *window)
-{
- return window->shell_surface;
-}
-
static void
tooltip_redraw_handler(struct widget *widget, void *data)
{
int32_t width, height;
cr = widget_cairo_create(widget);
+ cairo_translate(cr, widget->allocation.x, widget->allocation.y);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.0);
cairo_paint(cr);
}
static cairo_text_extents_t
-get_text_extents(struct tooltip *tooltip)
+get_text_extents(struct display *display, struct tooltip *tooltip)
{
cairo_t *cr;
cairo_text_extents_t extents;
* created yet, and parent does not have a valid surface
* outside repaint, either.
*/
- cr = cairo_create(tooltip->window->display->dummy_surface);
+ cr = cairo_create(display->dummy_surface);
cairo_text_extents(cr, tooltip->entry, &extents);
cairo_destroy(cr);
{
struct widget *parent = tooltip->parent;
struct display *display = parent->window->display;
- struct window *window;
const int offset_y = 27;
const int margin = 3;
cairo_text_extents_t extents;
if (tooltip->widget)
return 0;
- window = window_create_transient(display, parent->window, tooltip->x,
- tooltip->y + offset_y,
- WL_SHELL_SURFACE_TRANSIENT_INACTIVE);
- if (!window)
- return -1;
-
- tooltip->window = window;
- tooltip->widget = window_add_widget(tooltip->window, tooltip);
+ tooltip->widget = window_add_subsurface(parent->window, tooltip, SUBSURFACE_DESYNCHRONIZED);
- extents = get_text_extents(tooltip);
+ extents = get_text_extents(display, tooltip);
widget_set_redraw_handler(tooltip->widget, tooltip_redraw_handler);
- window_schedule_resize(window, extents.width + 20, 20 + margin * 2);
+ widget_set_allocation(tooltip->widget,
+ tooltip->x, tooltip->y + offset_y,
+ extents.width + 20, 20 + margin * 2);
return 0;
}
if (tooltip->widget) {
widget_destroy(tooltip->widget);
- window_destroy(tooltip->window);
tooltip->widget = NULL;
- tooltip->window = NULL;
}
close(tooltip->tooltip_fd);
parent->tooltip = tooltip;
tooltip->parent = parent;
tooltip->widget = NULL;
- tooltip->window = NULL;
tooltip->x = x;
tooltip->y = y;
tooltip->entry = strdup(entry);
struct rectangle input;
struct rectangle opaque;
- if (widget->window->type == TYPE_FULLSCREEN) {
+ if (widget->window->fullscreen) {
interior.x = 0;
interior.y = 0;
interior.width = width;
interior.height = height;
} else {
- if (widget->window->type == TYPE_MAXIMIZED) {
- frame_set_flag(frame->frame, FRAME_FLAG_MAXIMIZED);
- } else {
- frame_unset_flag(frame->frame, FRAME_FLAG_MAXIMIZED);
- }
-
frame_resize(frame->frame, width, height);
frame_interior(frame->frame, &interior.x, &interior.y,
&interior.width, &interior.height);
child->resize_handler(child, interior.width, interior.height,
child->user_data);
- if (widget->window->type == TYPE_FULLSCREEN) {
+ if (widget->window->fullscreen) {
width = child->allocation.width;
height = child->allocation.height;
} else {
widget->surface->input_region =
wl_compositor_create_region(widget->window->display->compositor);
- if (widget->window->type != TYPE_FULLSCREEN) {
+ if (!widget->window->fullscreen) {
frame_input_rect(frame->frame, &input.x, &input.y,
&input.width, &input.height);
wl_region_add(widget->surface->input_region,
widget_set_allocation(widget, 0, 0, width, height);
if (child->opaque) {
- if (widget->window->type != TYPE_FULLSCREEN) {
+ if (!widget->window->fullscreen) {
frame_opaque_rect(frame->frame, &opaque.x, &opaque.y,
&opaque.width, &opaque.height);
struct window_frame *frame = data;
struct window *window = widget->window;
- if (window->type == TYPE_FULLSCREEN)
+ if (window->fullscreen)
return;
- if (window->focus_count) {
- frame_set_flag(frame->frame, FRAME_FLAG_ACTIVE);
- } else {
- frame_unset_flag(frame->frame, FRAME_FLAG_ACTIVE);
- }
-
cr = widget_cairo_create(widget);
frame_repaint(frame->frame, cr);
{
struct window *window = frame->widget->window;
- if (window->type != TYPE_TOPLEVEL)
+ if (window->custom)
return CURSOR_LEFT_PTR;
switch (location) {
}
static void
-frame_menu_func(struct window *window,
- struct input *input, int index, void *data)
+frame_menu_func(void *data, struct input *input, int index)
{
+ struct window *window = data;
struct display *display;
switch (index) {
case 0: /* close */
- if (window->close_handler)
- window->close_handler(window->parent,
- window->user_data);
- else
- display_exit(window->display);
+ window_close(window);
break;
case 1: /* move to workspace above */
display = window->display;
if (status & FRAME_STATUS_REPAINT)
widget_schedule_redraw(frame->widget);
- if (status & FRAME_STATUS_MINIMIZE)
- fprintf(stderr,"Minimize stub\n");
+ if (status & FRAME_STATUS_MINIMIZE) {
+ window_set_minimized(window);
+ frame_status_clear(frame->frame, FRAME_STATUS_MINIMIZE);
+ }
if (status & FRAME_STATUS_MENU) {
window_show_frame_menu(window, input, time);
}
if (status & FRAME_STATUS_MAXIMIZE) {
- window_set_maximized(window, window->type != TYPE_MAXIMIZED);
+ window_set_maximized(window, !window->maximized);
frame_status_clear(frame->frame, FRAME_STATUS_MAXIMIZE);
}
if (status & FRAME_STATUS_CLOSE) {
- if (window->close_handler)
- window->close_handler(window->parent,
- window->user_data);
- else
- display_exit(window->display);
+ window_close(window);
return;
}
- if ((status & FRAME_STATUS_MOVE) && window->shell_surface) {
+ if ((status & FRAME_STATUS_MOVE) && window->xdg_surface) {
input_ungrab(input);
- wl_shell_surface_move(window->shell_surface,
- input_get_seat(input),
- window->display->serial);
+ xdg_surface_move(window->xdg_surface,
+ input_get_seat(input),
+ window->display->serial);
frame_status_clear(frame->frame, FRAME_STATUS_MOVE);
}
- if ((status & FRAME_STATUS_RESIZE) && window->shell_surface) {
+ if ((status & FRAME_STATUS_RESIZE) && window->xdg_surface) {
input_ungrab(input);
- window->resizing = 1;
- wl_shell_surface_resize(window->shell_surface,
- input_get_seat(input),
- window->display->serial,
- location);
+ xdg_surface_resize(window->xdg_surface,
+ input_get_seat(input),
+ window->display->serial,
+ location);
frame_status_clear(frame->frame, FRAME_STATUS_RESIZE);
}
}
+#define DOUBLE_CLICK_PERIOD 250
static void
frame_button_handler(struct widget *widget,
struct input *input, uint32_t time,
struct window_frame *frame = data;
enum theme_location location;
- location = frame_pointer_button(frame->frame, input, button, state);
+ frame->double_click = 0;
+ if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
+ if (time - frame->last_time <= DOUBLE_CLICK_PERIOD) {
+ frame->double_click = 1;
+ frame->did_double = 1;
+ } else
+ frame->did_double = 0;
+
+ frame->last_time = time;
+ } else if (frame->did_double == 1) {
+ frame->double_click = 1;
+ frame->did_double = 0;
+ }
+
+ if (frame->double_click)
+ location = frame_double_click(frame->frame, input,
+ button, state);
+ else
+ location = frame_pointer_button(frame->frame, input,
+ button, state);
+
frame_handle_status(frame, input, time, location);
}
window_frame_create(struct window *window, void *data)
{
struct window_frame *frame;
+ uint32_t buttons;
+
+ if (window->custom) {
+ buttons = FRAME_BUTTON_NONE;
+ } else {
+ buttons = FRAME_BUTTON_ALL;
+ }
frame = xzalloc(sizeof *frame);
frame->frame = frame_create(window->display->theme, 0, 0,
- FRAME_BUTTON_ALL, window->title);
+ buttons, window->title);
frame->widget = window_add_widget(window, frame);
frame->child = widget_add_widget(frame->widget, data);
struct theme *t = display->theme;
int decoration_width, decoration_height;
int width, height;
- int margin = widget->window->type == TYPE_MAXIMIZED ? 0 : t->margin;
+ int margin = widget->window->maximized ? 0 : t->margin;
- if (widget->window->type != TYPE_FULLSCREEN) {
+ if (!widget->window->fullscreen) {
decoration_width = (t->width + margin) * 2;
decoration_height = t->width +
t->titlebar_height + margin * 2;
}
void
+touch_grab(struct input *input, int32_t touch_id)
+{
+ input->touch_grab = 1;
+ input->touch_grab_id = touch_id;
+}
+
+void
+touch_ungrab(struct input *input)
+{
+ struct touch_point *tp, *tmp;
+
+ input->touch_grab = 0;
+
+ wl_list_for_each_safe(tp, tmp,
+ &input->touch_point_list, link) {
+ if (tp->id != input->touch_grab_id)
+ continue;
+ wl_list_remove(&tp->link);
+ free(tp);
+
+ return;
+ }
+}
+
+void
input_grab(struct input *input, struct widget *widget, uint32_t button)
{
input->grab = widget;
input->grab_button = button;
+
+ input_set_focus_widget(input, widget, input->sx, input->sy);
}
void
return;
}
+ window = wl_surface_get_user_data(surface);
+ if (surface != window->main_surface->surface) {
+ DBG("Ignoring input event from subsurface %p\n", surface);
+ return;
+ }
+
input->display->serial = serial;
input->pointer_enter_serial = serial;
- input->pointer_focus = wl_surface_get_user_data(surface);
- window = input->pointer_focus;
-
- if (window->resizing) {
- window->resizing = 0;
- /* Schedule a redraw to free the pool */
- window_schedule_redraw(window);
- }
+ input->pointer_focus = window;
input->sx = sx;
input->sy = sy;
float sx = wl_fixed_to_double(sx_w);
float sy = wl_fixed_to_double(sy_w);
- input->sx = sx;
- input->sy = sy;
-
if (!window)
return;
+ input->sx = sx;
+ input->sy = sy;
+
/* when making the window smaller - e.g. after a unmaximise we might
* still have a pending motion event that the compositor has picked
* based on the old surface dimensions
if (!window)
return;
- window->focus_count--;
if (window->keyboard_focus_handler)
(*window->keyboard_focus_handler)(window, NULL,
window->user_data);
return;
}
- keymap = xkb_map_new_from_string(input->display->xkb_context,
- map_str,
- XKB_KEYMAP_FORMAT_TEXT_V1,
- 0);
+ keymap = xkb_keymap_new_from_string(input->display->xkb_context,
+ map_str,
+ XKB_KEYMAP_FORMAT_TEXT_V1,
+ 0);
munmap(map_str, size);
close(fd);
state = xkb_state_new(keymap);
if (!state) {
fprintf(stderr, "failed to create XKB state\n");
- xkb_map_unref(keymap);
+ xkb_keymap_unref(keymap);
return;
}
input->xkb.state = state;
input->xkb.control_mask =
- 1 << xkb_map_mod_get_index(input->xkb.keymap, "Control");
+ 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Control");
input->xkb.alt_mask =
- 1 << xkb_map_mod_get_index(input->xkb.keymap, "Mod1");
+ 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Mod1");
input->xkb.shift_mask =
- 1 << xkb_map_mod_get_index(input->xkb.keymap, "Shift");
+ 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Shift");
}
static void
input->keyboard_focus = wl_surface_get_user_data(surface);
window = input->keyboard_focus;
- window->focus_count++;
if (window->keyboard_focus_handler)
(*window->keyboard_focus_handler)(window,
input, window->user_data);
if (!window || !input->xkb.state)
return;
- num_syms = xkb_key_get_syms(input->xkb.state, code, &syms);
+ /* We only use input grabs for pointer events for now, so just
+ * ignore key presses if a grab is active. We expand the key
+ * event delivery mechanism to route events to widgets to
+ * properly handle key grabs. In the meantime, this prevents
+ * key event devlivery while a grab is active. */
+ if (input->grab && input->grab_button == 0)
+ return;
+
+ num_syms = xkb_state_key_get_syms(input->xkb.state, code, &syms);
sym = XKB_KEY_NoSymbol;
if (num_syms == 1)
sym = syms[0];
+
if (sym == XKB_KEY_F5 && input->modifiers == MOD_ALT_MASK) {
if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
- window_set_maximized(window,
- window->type != TYPE_MAXIMIZED);
+ window_set_maximized(window, !window->maximized);
} else if (sym == XKB_KEY_F11 &&
window->fullscreen_handler &&
state == WL_KEYBOARD_KEY_STATE_PRESSED) {
} else if (sym == XKB_KEY_F4 &&
input->modifiers == MOD_ALT_MASK &&
state == WL_KEYBOARD_KEY_STATE_PRESSED) {
- if (window->close_handler)
- window->close_handler(window->parent,
- window->user_data);
- else
- display_exit(window->display);
+ window_close(window);
} else if (window->key_handler) {
(*window->key_handler)(window, input, time, key,
sym, state, window->user_data);
its.it_value.tv_sec = 0;
its.it_value.tv_nsec = 0;
timerfd_settime(input->repeat_timer_fd, 0, &its, NULL);
- } else if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
+ } else if (state == WL_KEYBOARD_KEY_STATE_PRESSED &&
+ xkb_keymap_key_repeats(input->xkb.keymap, code)) {
input->repeat_sym = sym;
input->repeat_key = key;
input->repeat_time = time;
- its.it_interval.tv_sec = 0;
- its.it_interval.tv_nsec = 25 * 1000 * 1000;
- its.it_value.tv_sec = 0;
- its.it_value.tv_nsec = 400 * 1000 * 1000;
+ its.it_interval.tv_sec = input->repeat_rate_sec;
+ its.it_interval.tv_nsec = input->repeat_rate_nsec;
+ its.it_value.tv_sec = input->repeat_delay_sec;
+ its.it_value.tv_nsec = input->repeat_delay_nsec;
timerfd_settime(input->repeat_timer_fd, 0, &its, NULL);
}
}
xkb_state_update_mask(input->xkb.state, mods_depressed, mods_latched,
mods_locked, 0, 0, group);
mask = xkb_state_serialize_mods(input->xkb.state,
- XKB_STATE_DEPRESSED |
- XKB_STATE_LATCHED);
+ XKB_STATE_MODS_DEPRESSED |
+ XKB_STATE_MODS_LATCHED);
input->modifiers = 0;
if (mask & input->xkb.control_mask)
input->modifiers |= MOD_CONTROL_MASK;
input->modifiers |= MOD_SHIFT_MASK;
}
+static void
+set_repeat_info(struct input *input, int32_t rate, int32_t delay)
+{
+ input->repeat_rate_sec = input->repeat_rate_nsec = 0;
+ input->repeat_delay_sec = input->repeat_delay_nsec = 0;
+
+ /* a rate of zero disables any repeating, regardless of the delay's
+ * value */
+ if (rate == 0)
+ return;
+
+ if (rate == 1)
+ input->repeat_rate_sec = 1;
+ else
+ input->repeat_rate_nsec = 1000000000 / rate;
+
+ input->repeat_delay_sec = delay / 1000;
+ delay -= (input->repeat_delay_sec * 1000);
+ input->repeat_delay_nsec = delay * 1000 * 1000;
+}
+
+static void
+keyboard_handle_repeat_info(void *data, struct wl_keyboard *keyboard,
+ int32_t rate, int32_t delay)
+{
+ struct input *input = data;
+
+ set_repeat_info(input, rate, delay);
+}
+
static const struct wl_keyboard_listener keyboard_listener = {
keyboard_handle_keymap,
keyboard_handle_enter,
keyboard_handle_leave,
keyboard_handle_key,
keyboard_handle_modifiers,
+ keyboard_handle_repeat_info
+
};
static void
return;
}
- widget = window_find_widget(input->touch_focus,
- wl_fixed_to_double(x_w),
- wl_fixed_to_double(y_w));
+ if (surface != input->touch_focus->main_surface->surface) {
+ DBG("Ignoring input event from subsurface %p\n", surface);
+ input->touch_focus = NULL;
+ return;
+ }
+
+ if (input->grab)
+ widget = input->grab;
+ else
+ widget = window_find_widget(input->touch_focus,
+ wl_fixed_to_double(x_w),
+ wl_fixed_to_double(y_w));
if (widget) {
struct touch_point *tp = xmalloc(sizeof *tp);
if (tp) {
tp->id = id;
tp->widget = widget;
+ tp->x = sx;
+ tp->y = sy;
wl_list_insert(&input->touch_point_list, &tp->link);
if (widget->touch_down_handler)
if (tp->id != id)
continue;
+ tp->x = sx;
+ tp->y = sy;
if (tp->widget->touch_motion_handler)
(*tp->widget->touch_motion_handler)(tp->widget, input, time,
id, sx, sy,
if (tp->widget->touch_frame_handler)
(*tp->widget->touch_frame_handler)(tp->widget, input,
tp->widget->user_data);
-
- wl_list_remove(&tp->link);
- free(tp);
}
}
*y = input->sy;
}
+int
+input_get_touch(struct input *input, int32_t id, float *x, float *y)
+{
+ struct touch_point *tp;
+
+ wl_list_for_each(tp, &input->touch_point_list, link) {
+ if (tp->id != id)
+ continue;
+
+ *x = tp->x;
+ *y = tp->y;
+ return 0;
+ }
+
+ return -1;
+}
+
struct display *
input_get_display(struct input *input)
{
float y = wl_fixed_to_double(y_w);
char **p;
- input->pointer_enter_serial = serial;
window = wl_surface_get_user_data(surface);
- input->pointer_focus = window;
+ input->drag_enter_serial = serial;
+ input->drag_focus = window,
+ input->drag_x = x;
+ input->drag_y = y;
+
+ if (!input->touch_grab)
+ input->pointer_enter_serial = serial;
if (offer) {
input->drag_offer = wl_data_offer_get_user_data(offer);
types_data = NULL;
}
- window = input->pointer_focus;
if (window->data_handler)
window->data_handler(window, input, x, y, types_data,
window->user_data);
uint32_t time, wl_fixed_t x_w, wl_fixed_t y_w)
{
struct input *input = data;
- struct window *window = input->pointer_focus;
+ struct window *window = input->drag_focus;
float x = wl_fixed_to_double(x_w);
float y = wl_fixed_to_double(y_w);
void *types_data;
- input->sx = x;
- input->sy = y;
+ input->drag_x = x;
+ input->drag_y = y;
if (input->drag_offer)
types_data = input->drag_offer->types.data;
data_device_drop(void *data, struct wl_data_device *data_device)
{
struct input *input = data;
- struct window *window = input->pointer_focus;
+ struct window *window = input->drag_focus;
+ float x, y;
+
+ x = input->drag_x;
+ y = input->drag_y;
if (window->drop_handler)
window->drop_handler(window, input,
- input->sx, input->sy, window->user_data);
+ x, y, window->user_data);
+
+ if (input->touch_grab)
+ touch_ungrab(input);
}
static void
if (!buffer)
return;
- wl_pointer_set_cursor(input->pointer, input->pointer_enter_serial,
- input->pointer_surface,
- image->hotspot_x, image->hotspot_y);
wl_surface_attach(input->pointer_surface, buffer, 0, 0);
wl_surface_damage(input->pointer_surface, 0, 0,
image->width, image->height);
wl_surface_commit(input->pointer_surface);
+ wl_pointer_set_cursor(input->pointer, input->pointer_enter_serial,
+ input->pointer_surface,
+ image->hotspot_x, image->hotspot_y);
}
static const struct wl_callback_listener pointer_surface_listener;
input_set_selection(struct input *input,
struct wl_data_source *source, uint32_t time)
{
- wl_data_device_set_selection(input->data_device, source, time);
+ if (input->data_device)
+ wl_data_device_set_selection(input->data_device, source, time);
}
void
input_accept(struct input *input, const char *type)
{
wl_data_offer_accept(input->drag_offer->offer,
- input->pointer_enter_serial, type);
+ input->drag_enter_serial, type);
}
static void
data_func_t func, void *data)
{
data_offer_receive_data(input->drag_offer, mime_type, func, data);
- input->drag_offer->x = input->sx;
- input->drag_offer->y = input->sy;
+ input->drag_offer->x = input->drag_x;
+ input->drag_offer->y = input->drag_y;
}
int
void
window_move(struct window *window, struct input *input, uint32_t serial)
{
- if (!window->shell_surface)
- return;
-
- wl_shell_surface_move(window->shell_surface, input->seat, serial);
-}
-
-void
-window_touch_move(struct window *window, struct input *input, uint32_t serial)
-{
- if (!window->shell_surface)
+ if (!window->xdg_surface)
return;
- wl_shell_surface_move(window->shell_surface, input->seat,
- window->display->serial);
+ xdg_surface_move(window->xdg_surface, input->seat, serial);
}
static void
}
static void
-idle_resize(struct window *window)
+window_do_resize(struct window *window)
{
struct surface *surface;
- window->resize_needed = 0;
- window->redraw_needed = 1;
-
- DBG("from %dx%d to %dx%d\n",
- window->main_surface->server_allocation.width,
- window->main_surface->server_allocation.height,
- window->pending_allocation.width,
- window->pending_allocation.height);
-
- hack_prevent_EGL_sub_surface_deadlock(window);
-
widget_set_allocation(window->main_surface->widget,
window->pending_allocation.x,
window->pending_allocation.y,
surface_set_synchronized(surface);
surface_resize(surface);
}
+
+ if (!window->fullscreen && !window->maximized)
+ window->saved_allocation = window->pending_allocation;
+}
+
+static void
+idle_resize(struct window *window)
+{
+ window->resize_needed = 0;
+ window->redraw_needed = 1;
+
+ DBG("from %dx%d to %dx%d\n",
+ window->main_surface->server_allocation.width,
+ window->main_surface->server_allocation.height,
+ window->pending_allocation.width,
+ window->pending_allocation.height);
+
+ hack_prevent_EGL_sub_surface_deadlock(window);
+
+ window_do_resize(window);
+}
+
+static void
+undo_resize(struct window *window)
+{
+ window->pending_allocation.width =
+ window->main_surface->server_allocation.width;
+ window->pending_allocation.height =
+ window->main_surface->server_allocation.height;
+
+ DBG("back to %dx%d\n",
+ window->main_surface->server_allocation.width,
+ window->main_surface->server_allocation.height);
+
+ window_do_resize(window);
+
+ if (window->pending_allocation.width == 0 &&
+ window->pending_allocation.height == 0) {
+ fprintf(stderr, "Error: Could not draw a surface, "
+ "most likely due to insufficient disk space in "
+ "%s (XDG_RUNTIME_DIR).\n", getenv("XDG_RUNTIME_DIR"));
+ exit(EXIT_FAILURE);
+ }
}
void
window_schedule_resize(widget->window, width, height);
}
+static int
+window_get_shadow_margin(struct window *window)
+{
+ if (window->frame && !window->fullscreen)
+ return frame_get_shadow_margin(window->frame->frame);
+ else
+ return 0;
+}
+
static void
-handle_ping(void *data, struct wl_shell_surface *shell_surface,
- uint32_t serial)
+handle_surface_configure(void *data, struct xdg_surface *xdg_surface,
+ int32_t width, int32_t height,
+ struct wl_array *states, uint32_t serial)
{
- wl_shell_surface_pong(shell_surface, serial);
+ struct window *window = data;
+ uint32_t *p;
+
+ window->maximized = 0;
+ window->fullscreen = 0;
+ window->resizing = 0;
+ window->focused = 0;
+
+ wl_array_for_each(p, states) {
+ uint32_t state = *p;
+ switch (state) {
+ case XDG_SURFACE_STATE_MAXIMIZED:
+ window->maximized = 1;
+ break;
+ case XDG_SURFACE_STATE_FULLSCREEN:
+ window->fullscreen = 1;
+ break;
+ case XDG_SURFACE_STATE_RESIZING:
+ window->resizing = 1;
+ break;
+ case XDG_SURFACE_STATE_ACTIVATED:
+ window->focused = 1;
+ break;
+ default:
+ /* Unknown state */
+ break;
+ }
+ }
+
+ if (window->frame) {
+ if (window->maximized) {
+ frame_set_flag(window->frame->frame, FRAME_FLAG_MAXIMIZED);
+ } else {
+ frame_unset_flag(window->frame->frame, FRAME_FLAG_MAXIMIZED);
+ }
+
+ if (window->focused) {
+ frame_set_flag(window->frame->frame, FRAME_FLAG_ACTIVE);
+ } else {
+ frame_unset_flag(window->frame->frame, FRAME_FLAG_ACTIVE);
+ }
+ }
+
+ if (width > 0 && height > 0) {
+ /* The width / height params are for window geometry,
+ * but window_schedule_resize takes allocation. Add
+ * on the shadow margin to get the difference. */
+ int margin = window_get_shadow_margin(window);
+
+ window_schedule_resize(window,
+ width + margin * 2,
+ height + margin * 2);
+ } else {
+ window_schedule_resize(window,
+ window->saved_allocation.width,
+ window->saved_allocation.height);
+ }
+
+ xdg_surface_ack_configure(window->xdg_surface, serial);
+
+ if (window->state_changed_handler)
+ window->state_changed_handler(window, window->user_data);
}
static void
-handle_configure(void *data, struct wl_shell_surface *shell_surface,
- uint32_t edges, int32_t width, int32_t height)
+handle_surface_delete(void *data, struct xdg_surface *xdg_surface)
{
struct window *window = data;
+ window_close(window);
+}
+
+static const struct xdg_surface_listener xdg_surface_listener = {
+ handle_surface_configure,
+ handle_surface_delete,
+};
+
+static void
+window_sync_parent(struct window *window)
+{
+ struct wl_surface *parent_surface;
+
+ if (!window->xdg_surface)
+ return;
+
+ if (window->parent)
+ parent_surface = window->parent->main_surface->surface;
+ else
+ parent_surface = NULL;
+
+ if (parent_surface == window->last_parent_surface)
+ return;
- window->resize_edges = edges;
- window_schedule_resize(window, width, height);
+ xdg_surface_set_parent(window->xdg_surface, parent_surface);
+ window->last_parent_surface = parent_surface;
}
static void
-menu_destroy(struct menu *menu)
+window_get_geometry(struct window *window, struct rectangle *geometry)
+{
+ if (window->frame && !window->fullscreen)
+ frame_input_rect(window->frame->frame,
+ &geometry->x,
+ &geometry->y,
+ &geometry->width,
+ &geometry->height);
+ else
+ window_get_allocation(window, geometry);
+}
+
+static void
+window_sync_geometry(struct window *window)
{
- widget_destroy(menu->widget);
- window_destroy(menu->window);
- frame_destroy(menu->frame);
- free(menu);
+ struct rectangle geometry;
+
+ if (!window->xdg_surface)
+ return;
+
+ window_get_geometry(window, &geometry);
+ if (geometry.x == window->last_geometry.x &&
+ geometry.y == window->last_geometry.y &&
+ geometry.width == window->last_geometry.width &&
+ geometry.height == window->last_geometry.height)
+ return;
+
+ xdg_surface_set_window_geometry(window->xdg_surface,
+ geometry.x,
+ geometry.y,
+ geometry.width,
+ geometry.height);
+ window->last_geometry = geometry;
}
static void
-handle_popup_done(void *data, struct wl_shell_surface *shell_surface)
+window_flush(struct window *window)
{
- struct window *window = data;
- struct menu *menu = window->main_surface->widget->user_data;
+ struct surface *surface;
- /* FIXME: Need more context in this event, at least the input
- * device. Or just use wl_callback. And this really needs to
- * be a window vfunc that the menu can set. And we need the
- * time. */
+ if (!window->custom) {
+ if (window->xdg_surface) {
+ window_sync_parent(window);
+ window_sync_geometry(window);
+ }
+ }
- input_ungrab(menu->input);
- menu_destroy(menu);
+ wl_list_for_each(surface, &window->subsurface_list, link) {
+ if (surface == window->main_surface)
+ continue;
+
+ surface_flush(surface);
+ }
+
+ surface_flush(window->main_surface);
}
-static const struct wl_shell_surface_listener shell_surface_listener = {
- handle_ping,
- handle_configure,
- handle_popup_done
-};
+static void
+menu_destroy(struct menu *menu)
+{
+ widget_destroy(menu->widget);
+ window_destroy(menu->window);
+ frame_destroy(menu->frame);
+ free(menu);
+}
void
window_get_allocation(struct window *window,
frame_callback
};
-static void
+static int
surface_redraw(struct surface *surface)
{
DBG_OBJ(surface->surface, "begin\n");
if (!surface->window->redraw_needed && !surface->redraw_needed)
- return;
+ return 0;
/* Whole-window redraw forces a redraw even if the previous has
* not yet hit the screen.
*/
if (surface->frame_cb) {
if (!surface->window->redraw_needed)
- return;
+ return 0;
DBG_OBJ(surface->frame_cb, "cancelled\n");
wl_callback_destroy(surface->frame_cb);
}
+ if (surface->widget->use_cairo &&
+ !widget_get_cairo_surface(surface->widget)) {
+ DBG_OBJ(surface->surface, "cancelled due buffer failure\n");
+ return -1;
+ }
+
surface->frame_cb = wl_surface_frame(surface->surface);
wl_callback_add_listener(surface->frame_cb, &listener, surface);
DBG_OBJ(surface->frame_cb, "new\n");
DBG_OBJ(surface->surface, "-> widget_redraw\n");
widget_redraw(surface->widget);
DBG_OBJ(surface->surface, "done\n");
+ return 0;
}
static void
{
struct window *window = container_of(task, struct window, redraw_task);
struct surface *surface;
+ int failed = 0;
+ int resized = 0;
DBG(" --------- \n");
}
idle_resize(window);
+ resized = 1;
}
- wl_list_for_each(surface, &window->subsurface_list, link)
- surface_redraw(surface);
+ if (surface_redraw(window->main_surface) < 0) {
+ /*
+ * Only main_surface failure will cause us to undo the resize.
+ * If sub-surfaces fail, they will just be broken with old
+ * content.
+ */
+ failed = 1;
+ } else {
+ wl_list_for_each(surface, &window->subsurface_list, link) {
+ if (surface == window->main_surface)
+ continue;
+
+ surface_redraw(surface);
+ }
+ }
window->redraw_needed = 0;
window_flush(window);
wl_list_for_each(surface, &window->subsurface_list, link)
surface_set_synchronized_default(surface);
+
+ if (resized && failed) {
+ /* Restore widget tree to correspond to what is on screen. */
+ undo_resize(window);
+ }
}
static void
window_schedule_redraw_task(struct window *window)
{
- if (window->configure_requests)
- return;
if (!window->redraw_task_scheduled) {
window->redraw_task.run = idle_redraw;
display_defer(window->display, &window->redraw_task);
int
window_is_fullscreen(struct window *window)
{
- return window->type == TYPE_FULLSCREEN;
+ return window->fullscreen;
}
-static void
-configure_request_completed(void *data, struct wl_callback *callback, uint32_t time)
+void
+window_set_fullscreen(struct window *window, int fullscreen)
{
- struct window *window = data;
+ if (!window->xdg_surface)
+ return;
- wl_callback_destroy(callback);
- window->configure_requests--;
+ if (window->fullscreen == fullscreen)
+ return;
- if (!window->configure_requests)
- window_schedule_redraw(window);
+ if (fullscreen)
+ xdg_surface_set_fullscreen(window->xdg_surface, NULL);
+ else
+ xdg_surface_unset_fullscreen(window->xdg_surface);
}
-static struct wl_callback_listener configure_request_listener = {
- configure_request_completed,
-};
-
-static void
-window_defer_redraw_until_configure(struct window* window)
+int
+window_is_maximized(struct window *window)
{
- struct wl_callback *callback;
-
- if (window->redraw_task_scheduled) {
- wl_list_remove(&window->redraw_task.link);
- window->redraw_task_scheduled = 0;
- }
-
- callback = wl_display_sync(window->display->display);
- wl_callback_add_listener(callback, &configure_request_listener, window);
- window->configure_requests++;
+ return window->maximized;
}
void
-window_set_fullscreen(struct window *window, int fullscreen)
+window_set_maximized(struct window *window, int maximized)
{
- if (!window->display->shell)
+ if (!window->xdg_surface)
return;
- if ((window->type == TYPE_FULLSCREEN) == fullscreen)
+ if (window->maximized == maximized)
return;
- if (fullscreen) {
- window->saved_type = window->type;
- if (window->type == TYPE_TOPLEVEL) {
- window->saved_allocation = window->main_surface->allocation;
- }
- window->type = TYPE_FULLSCREEN;
- wl_shell_surface_set_fullscreen(window->shell_surface,
- window->fullscreen_method,
- 0, NULL);
- window_defer_redraw_until_configure (window);
- } else {
- if (window->saved_type == TYPE_MAXIMIZED) {
- window_set_maximized(window, 1);
- } else {
- window->type = TYPE_TOPLEVEL;
- wl_shell_surface_set_toplevel(window->shell_surface);
- window_schedule_resize(window,
- window->saved_allocation.width,
- window->saved_allocation.height);
- }
-
- }
-}
-
-void
-window_set_fullscreen_method(struct window *window,
- enum wl_shell_surface_fullscreen_method method)
-{
- window->fullscreen_method = method;
+ if (maximized)
+ xdg_surface_set_maximized(window->xdg_surface);
+ else
+ xdg_surface_unset_maximized(window->xdg_surface);
}
int
-window_is_maximized(struct window *window)
+window_is_resizing(struct window *window)
{
- return window->type == TYPE_MAXIMIZED;
+ return window->resizing;
}
void
-window_set_maximized(struct window *window, int maximized)
+window_set_minimized(struct window *window)
{
- if (!window->display->shell)
- return;
-
- if ((window->type == TYPE_MAXIMIZED) == maximized)
+ if (!window->xdg_surface)
return;
- if (window->type == TYPE_TOPLEVEL) {
- window->saved_allocation = window->main_surface->allocation;
- wl_shell_surface_set_maximized(window->shell_surface, NULL);
- window->type = TYPE_MAXIMIZED;
- window_defer_redraw_until_configure(window);
- } else if (window->type == TYPE_FULLSCREEN) {
- wl_shell_surface_set_maximized(window->shell_surface, NULL);
- window->type = TYPE_MAXIMIZED;
- window_defer_redraw_until_configure(window);
- } else {
- wl_shell_surface_set_toplevel(window->shell_surface);
- window->type = TYPE_TOPLEVEL;
- window_schedule_resize(window,
- window->saved_allocation.width,
- window->saved_allocation.height);
- }
+ xdg_surface_set_minimized(window->xdg_surface);
}
void
}
void
+window_set_state_changed_handler(struct window *window,
+ window_state_changed_handler_t handler)
+{
+ window->state_changed_handler = handler;
+}
+
+void
window_set_title(struct window *window, const char *title)
{
free(window->title);
frame_set_title(window->frame->frame, title);
widget_schedule_redraw(window->frame->widget);
}
- if (window->shell_surface)
- wl_shell_surface_set_title(window->shell_surface, title);
+ if (window->xdg_surface)
+ xdg_surface_set_title(window->xdg_surface, title);
}
const char *
return surface;
}
+static enum window_buffer_type
+get_preferred_buffer_type(struct display *display)
+{
+#ifdef HAVE_CAIRO_EGL
+ if (display->argb_device && !getenv("TOYTOOLKIT_NO_EGL"))
+ return WINDOW_BUFFER_TYPE_EGL_WINDOW;
+#endif
+
+ return WINDOW_BUFFER_TYPE_SHM;
+}
+
static struct window *
-window_create_internal(struct display *display,
- struct window *parent, int type)
+window_create_internal(struct display *display, int custom)
{
struct window *window;
struct surface *surface;
window = xzalloc(sizeof *window);
wl_list_init(&window->subsurface_list);
window->display = display;
- window->parent = parent;
surface = surface_create(window);
window->main_surface = surface;
- if (type != TYPE_CUSTOM && display->shell) {
- window->shell_surface =
- wl_shell_get_shell_surface(display->shell,
- surface->surface);
- fail_on_null(window->shell_surface);
- }
+ assert(custom || display->xdg_shell);
- window->type = type;
- window->fullscreen_method = WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT;
- window->configure_requests = 0;
+ window->custom = custom;
window->preferred_format = WINDOW_PREFERRED_FORMAT_NONE;
- if (display->argb_device)
-#ifdef HAVE_CAIRO_EGL
- surface->buffer_type = WINDOW_BUFFER_TYPE_EGL_WINDOW;
-#else
- surface->buffer_type = WINDOW_BUFFER_TYPE_SHM;
-#endif
- else
- surface->buffer_type = WINDOW_BUFFER_TYPE_SHM;
+ surface->buffer_type = get_preferred_buffer_type(display);
wl_surface_set_user_data(surface->surface, window);
wl_list_insert(display->window_list.prev, &window->link);
wl_list_init(&window->redraw_task.link);
- if (window->shell_surface) {
- wl_shell_surface_set_user_data(window->shell_surface, window);
- wl_shell_surface_add_listener(window->shell_surface,
- &shell_surface_listener, window);
- }
-
wl_list_init (&window->window_output_list);
return window;
struct window *
window_create(struct display *display)
{
- return window_create_internal(display, NULL, TYPE_NONE);
+ struct window *window;
+
+ window = window_create_internal(display, 0);
+
+ window->xdg_surface =
+ xdg_shell_get_xdg_surface(window->display->xdg_shell,
+ window->main_surface->surface);
+ fail_on_null(window->xdg_surface);
+
+ xdg_surface_set_user_data(window->xdg_surface, window);
+ xdg_surface_add_listener(window->xdg_surface,
+ &xdg_surface_listener, window);
+
+ return window;
}
struct window *
window_create_custom(struct display *display)
{
- return window_create_internal(display, NULL, TYPE_CUSTOM);
+ return window_create_internal(display, 1);
}
-struct window *
-window_create_transient(struct display *display, struct window *parent,
- int32_t x, int32_t y, uint32_t flags)
+void
+window_set_parent(struct window *window,
+ struct window *parent_window)
{
- struct window *window;
-
- window = window_create_internal(parent->display,
- parent, TYPE_TRANSIENT);
-
- window->x = x;
- window->y = y;
-
- if (display->shell)
- wl_shell_surface_set_transient(
- window->shell_surface,
- window->parent->main_surface->surface,
- window->x, window->y, flags);
+ window->parent = parent_window;
+ window_sync_parent(window);
+}
- return window;
+struct window *
+window_get_parent(struct window *window)
+{
+ return window->parent;
}
static void
(menu->release_count > 0 || time - menu->time > 500)) {
/* Either relase after press-drag-release or
* click-motion-click. */
- menu->func(menu->window->parent, input,
- menu->current, menu->window->parent->user_data);
+ menu->func(menu->user_data, input, menu->current);
input_ungrab(input);
menu_destroy(menu);
} else if (state == WL_POINTER_BUTTON_STATE_RELEASED) {
}
static void
+menu_touch_up_handler(struct widget *widget,
+ struct input *input,
+ uint32_t serial,
+ uint32_t time,
+ int32_t id,
+ void *data)
+{
+ struct menu *menu = data;
+
+ input_ungrab(input);
+ menu_destroy(menu);
+}
+
+static void
menu_redraw_handler(struct widget *widget, void *data)
{
cairo_t *cr;
cairo_destroy(cr);
}
-void
-window_show_menu(struct display *display,
- struct input *input, uint32_t time, struct window *parent,
- int32_t x, int32_t y,
- menu_func_t func, const char **entries, int count)
+static void
+handle_popup_popup_done(void *data, struct xdg_popup *xdg_popup, uint32_t serial)
+{
+ struct window *window = data;
+ struct menu *menu = window->main_surface->widget->user_data;
+
+ input_ungrab(menu->input);
+ menu_destroy(menu);
+}
+
+static const struct xdg_popup_listener xdg_popup_listener = {
+ handle_popup_popup_done,
+};
+
+static struct menu *
+create_menu(struct display *display,
+ struct input *input, uint32_t time,
+ menu_func_t func, const char **entries, int count,
+ void *user_data)
{
struct window *window;
struct menu *menu;
- int32_t ix, iy;
menu = malloc(sizeof *menu);
if (!menu)
- return;
+ return NULL;
- window = window_create_internal(parent->display, parent, TYPE_MENU);
+ window = window_create_internal(display, 0);
if (!window) {
free(menu);
- return;
+ return NULL;
}
menu->window = window;
+ menu->user_data = user_data;
menu->widget = window_add_widget(menu->window, menu);
- window_set_buffer_scale (menu->window, window_get_buffer_scale (parent));
- window_set_buffer_transform (menu->window, window_get_buffer_transform (parent));
menu->frame = frame_create(window->display->theme, 0, 0,
FRAME_BUTTON_NONE, NULL);
+ fail_on_null(menu->frame);
menu->entries = entries;
menu->count = count;
menu->release_count = 0;
menu->time = time;
menu->func = func;
menu->input = input;
- window->type = TYPE_MENU;
- window->x = x;
- window->y = y;
input_ungrab(input);
widget_set_leave_handler(menu->widget, menu_leave_handler);
widget_set_motion_handler(menu->widget, menu_motion_handler);
widget_set_button_handler(menu->widget, menu_button_handler);
+ widget_set_touch_up_handler(menu->widget, menu_touch_up_handler);
input_grab(input, menu->widget, 0);
frame_resize_inside(menu->frame, 200, count * 20);
window_schedule_resize(window, frame_width(menu->frame),
frame_height(menu->frame));
+ return menu;
+}
+
+struct window *
+window_create_menu(struct display *display,
+ struct input *input, uint32_t time,
+ menu_func_t func, const char **entries, int count,
+ void *user_data)
+{
+ struct menu *menu;
+ menu = create_menu(display, input, time, func, entries, count, user_data);
+
+ if (menu == NULL)
+ return NULL;
+
+ return menu->window;
+}
+
+void
+window_show_menu(struct display *display,
+ struct input *input, uint32_t time, struct window *parent,
+ int32_t x, int32_t y,
+ menu_func_t func, const char **entries, int count)
+{
+ struct menu *menu;
+ struct window *window;
+ int32_t ix, iy;
+
+ menu = create_menu(display, input, time, func, entries, count, parent);
+
+ if (menu == NULL)
+ return;
+
+ window = menu->window;
+
+ window_set_buffer_scale (menu->window, window_get_buffer_scale (parent));
+ window_set_buffer_transform (menu->window, window_get_buffer_transform (parent));
+
+ window->x = x;
+ window->y = y;
+
frame_interior(menu->frame, &ix, &iy, NULL, NULL);
- wl_shell_surface_set_popup(window->shell_surface, input->seat,
- display_get_serial(window->display),
- window->parent->main_surface->surface,
- window->x - ix, window->y - iy, 0);
+
+ window->xdg_popup = xdg_shell_get_xdg_popup(display->xdg_shell,
+ window->main_surface->surface,
+ parent->main_surface->surface,
+ input->seat,
+ display_get_serial(window->display),
+ window->x - ix,
+ window->y - iy,
+ 0);
+ fail_on_null(window->xdg_popup);
+
+ xdg_popup_set_user_data(window->xdg_popup, window);
+ xdg_popup_add_listener(window->xdg_popup,
+ &xdg_popup_listener, window);
}
void
window->main_surface->buffer_type = type;
}
+enum window_buffer_type
+window_get_buffer_type(struct window *window)
+{
+ return window->main_surface->buffer_type;
+}
+
void
window_set_preferred_format(struct window *window,
enum preferred_format format)
struct wl_subcompositor *subcompo = window->display->subcompositor;
surface = surface_create(window);
+ surface->buffer_type = window_get_buffer_type(window);
widget = widget_create(window, surface, data);
wl_list_init(&widget->link);
surface->widget = widget;
assert(!"bad enum subsurface_mode");
}
+ window->resize_needed = 1;
+ window_schedule_redraw(window);
+
return widget;
}
output->allocation.x = x;
output->allocation.y = y;
output->transform = transform;
+
+ if (output->make)
+ free(output->make);
+ output->make = strdup(make);
+
+ if (output->model)
+ free(output->model);
+ output->model = strdup(model);
}
static void
return output->scale;
}
+const char *
+output_get_make(struct output *output)
+{
+ return output->make;
+}
+
+const char *
+output_get_model(struct output *output)
+{
+ return output->model;
+}
+
static void
fini_xkb(struct input *input)
{
xkb_state_unref(input->xkb.state);
- xkb_map_unref(input->xkb.keymap);
+ xkb_keymap_unref(input->xkb.keymap);
}
#define MIN(a,b) ((a) < (b) ? a : b)
input = xzalloc(sizeof *input);
input->display = d;
input->seat = wl_registry_bind(d->registry, id, &wl_seat_interface,
- MIN(d->seat_version, 3));
+ MIN(d->seat_version, 4));
input->touch_focus = NULL;
input->pointer_focus = NULL;
input->keyboard_focus = NULL;
wl_seat_add_listener(input->seat, &seat_listener, input);
wl_seat_set_user_data(input->seat, input);
- input->data_device =
- wl_data_device_manager_get_data_device(d->data_device_manager,
- input->seat);
- wl_data_device_add_listener(input->data_device, &data_device_listener,
- input);
+ if (d->data_device_manager) {
+ input->data_device =
+ wl_data_device_manager_get_data_device(d->data_device_manager,
+ input->seat);
+ wl_data_device_add_listener(input->data_device,
+ &data_device_listener,
+ input);
+ }
input->pointer_surface = wl_compositor_create_surface(d->compositor);
+ set_repeat_info(input, 40, 400);
+
input->repeat_timer_fd = timerfd_create(CLOCK_MONOTONIC,
TFD_CLOEXEC | TFD_NONBLOCK);
input->repeat_task.run = keyboard_repeat_func;
if (input->selection_offer)
data_offer_destroy(input->selection_offer);
- wl_data_device_destroy(input->data_device);
+ if (input->data_device)
+ wl_data_device_destroy(input->data_device);
if (input->display->seat_version >= 3) {
if (input->pointer)
};
static void
+xdg_shell_ping(void *data, struct xdg_shell *shell, uint32_t serial)
+{
+ xdg_shell_pong(shell, serial);
+}
+
+static const struct xdg_shell_listener xdg_shell_listener = {
+ xdg_shell_ping,
+};
+
+#define XDG_VERSION 4 /* The version of xdg-shell that we implement */
+#ifdef static_assert
+static_assert(XDG_VERSION == XDG_SHELL_VERSION_CURRENT,
+ "Interface version doesn't match implementation version");
+#endif
+
+static void
registry_handle_global(void *data, struct wl_registry *registry, uint32_t id,
const char *interface, uint32_t version)
{
} else if (strcmp(interface, "wl_seat") == 0) {
d->seat_version = version;
display_add_input(d, id);
- } else if (strcmp(interface, "wl_shell") == 0) {
- d->shell = wl_registry_bind(registry,
- id, &wl_shell_interface, 1);
} else if (strcmp(interface, "wl_shm") == 0) {
d->shm = wl_registry_bind(registry, id, &wl_shm_interface, 1);
wl_shm_add_listener(d->shm, &shm_listener, d);
d->data_device_manager =
wl_registry_bind(registry, id,
&wl_data_device_manager_interface, 1);
+ } else if (strcmp(interface, "xdg_shell") == 0) {
+ d->xdg_shell = wl_registry_bind(registry, id,
+ &xdg_shell_interface, 1);
+ xdg_shell_use_unstable_version(d->xdg_shell, XDG_VERSION);
+ xdg_shell_add_listener(d->xdg_shell, &xdg_shell_listener, d);
} else if (strcmp(interface, "text_cursor_position") == 0) {
d->text_cursor_position =
wl_registry_bind(registry, id,
if (display->subcompositor)
wl_subcompositor_destroy(display->subcompositor);
- if (display->shell)
- wl_shell_destroy(display->shell);
+ if (display->xdg_shell)
+ xdg_shell_destroy(display->xdg_shell);
if (display->shm)
wl_shm_destroy(display->shm);
struct wl_data_source *
display_create_data_source(struct display *display)
{
- return wl_data_device_manager_create_data_source(display->data_device_manager);
+ if (display->data_device_manager)
+ return wl_data_device_manager_create_data_source(display->data_device_manager);
+ else
+ return NULL;
}
EGLConfig
return d->argb_config;
}
-struct wl_shell *
-display_get_shell(struct display *display)
-{
- return display->shell;
-}
-
int
display_acquire_window_surface(struct display *display,
struct window *window,
{
return fail_on_null(strdup(s));
}
+
+void *
+xrealloc(char *p, size_t s)
+{
+ return fail_on_null(realloc(p, s));
+}
projects / platform / upstream / weston.git / blobdiff