2010-06-14 19:54:00 +04:00
|
|
|
/*
|
Change remaining GPLv2 headers to MIT
The files in question are copyright Benjamin Franzke (who agrees),
Intel Corporation, Red Hat and myself. On behalf of Red Hat,
Richard Fontana says:
"Therefore, to the extent that Red Hat, Inc. has any copyright
interest in the files you cited as of this date (compositor-drm.c,
compositor.c, compositor.h, screenshooter.c in
http://cgit.freedesktop.org/wayland/wayland-demos/tree/compositor),
Red Hat hereby elects to apply the CC0 1.0 Universal Public Domain
Dedication to such copyrighted material. See:
http://creativecommons.org/publicdomain/zero/1.0/legalcode .
Thanks,
Richard E. Fontana
Open Source Licensing and Patent Counsel
Red Hat, Inc."
2011-09-15 23:43:14 +04:00
|
|
|
* Copyright © 2008-2011 Kristian Høgsberg
|
|
|
|
* Copyright © 2010-2011 Intel Corporation
|
2010-06-14 19:54:00 +04:00
|
|
|
*
|
Change remaining GPLv2 headers to MIT
The files in question are copyright Benjamin Franzke (who agrees),
Intel Corporation, Red Hat and myself. On behalf of Red Hat,
Richard Fontana says:
"Therefore, to the extent that Red Hat, Inc. has any copyright
interest in the files you cited as of this date (compositor-drm.c,
compositor.c, compositor.h, screenshooter.c in
http://cgit.freedesktop.org/wayland/wayland-demos/tree/compositor),
Red Hat hereby elects to apply the CC0 1.0 Universal Public Domain
Dedication to such copyrighted material. See:
http://creativecommons.org/publicdomain/zero/1.0/legalcode .
Thanks,
Richard E. Fontana
Open Source Licensing and Patent Counsel
Red Hat, Inc."
2011-09-15 23:43:14 +04:00
|
|
|
* Permission to use, copy, modify, distribute, and sell this software and
|
|
|
|
* its documentation for any purpose is hereby granted without fee, provided
|
|
|
|
* that the above copyright notice appear in all copies and that both that
|
|
|
|
* copyright notice and this permission notice appear in supporting
|
|
|
|
* documentation, and that the name of the copyright holders not be used in
|
|
|
|
* advertising or publicity pertaining to distribution of the software
|
|
|
|
* without specific, written prior permission. The copyright holders make
|
|
|
|
* no representations about the suitability of this software for any
|
|
|
|
* purpose. It is provided "as is" without express or implied warranty.
|
2010-06-14 19:54:00 +04:00
|
|
|
*
|
Change remaining GPLv2 headers to MIT
The files in question are copyright Benjamin Franzke (who agrees),
Intel Corporation, Red Hat and myself. On behalf of Red Hat,
Richard Fontana says:
"Therefore, to the extent that Red Hat, Inc. has any copyright
interest in the files you cited as of this date (compositor-drm.c,
compositor.c, compositor.h, screenshooter.c in
http://cgit.freedesktop.org/wayland/wayland-demos/tree/compositor),
Red Hat hereby elects to apply the CC0 1.0 Universal Public Domain
Dedication to such copyrighted material. See:
http://creativecommons.org/publicdomain/zero/1.0/legalcode .
Thanks,
Richard E. Fontana
Open Source Licensing and Patent Counsel
Red Hat, Inc."
2011-09-15 23:43:14 +04:00
|
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
|
|
|
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
|
|
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
|
|
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
|
|
|
|
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
|
|
|
|
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
|
|
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
2010-06-14 19:54:00 +04:00
|
|
|
*/
|
|
|
|
|
2010-10-29 11:20:18 +04:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sys/time.h>
|
2010-06-14 20:53:43 +04:00
|
|
|
#include <linux/input.h>
|
2010-06-14 19:54:00 +04:00
|
|
|
|
|
|
|
#include <xcb/xcb.h>
|
2012-06-22 16:21:35 +04:00
|
|
|
#ifdef HAVE_XCB_XKB
|
|
|
|
#include <xcb/xkb.h>
|
|
|
|
#endif
|
|
|
|
|
2011-02-20 21:58:42 +03:00
|
|
|
#include <X11/Xlib.h>
|
|
|
|
#include <X11/Xlib-xcb.h>
|
|
|
|
|
2012-06-01 15:14:02 +04:00
|
|
|
#include <xkbcommon/xkbcommon.h>
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
#include <GLES2/gl2.h>
|
|
|
|
#include <EGL/egl.h>
|
|
|
|
|
|
|
|
#include "compositor.h"
|
2012-03-12 09:05:25 +04:00
|
|
|
#include "../shared/config-parser.h"
|
2012-06-07 20:01:59 +04:00
|
|
|
#include "log.h"
|
2010-06-14 19:54:00 +04:00
|
|
|
|
|
|
|
struct x11_compositor {
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
struct weston_compositor base;
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2012-03-29 06:53:49 +04:00
|
|
|
EGLSurface dummy_pbuffer;
|
|
|
|
|
2011-02-20 21:58:42 +03:00
|
|
|
Display *dpy;
|
2010-06-14 19:54:00 +04:00
|
|
|
xcb_connection_t *conn;
|
|
|
|
xcb_screen_t *screen;
|
|
|
|
xcb_cursor_t null_cursor;
|
2011-01-27 19:57:19 +03:00
|
|
|
struct wl_array keys;
|
2010-06-14 19:54:00 +04:00
|
|
|
struct wl_event_source *xcb_source;
|
2012-06-01 15:14:02 +04:00
|
|
|
struct xkb_keymap *xkb_keymap;
|
2012-06-22 16:21:35 +04:00
|
|
|
unsigned int has_xkb;
|
|
|
|
uint8_t xkb_event_base;
|
2010-06-14 19:54:00 +04:00
|
|
|
struct {
|
|
|
|
xcb_atom_t wm_protocols;
|
|
|
|
xcb_atom_t wm_normal_hints;
|
|
|
|
xcb_atom_t wm_size_hints;
|
|
|
|
xcb_atom_t wm_delete_window;
|
2011-01-26 22:02:31 +03:00
|
|
|
xcb_atom_t wm_class;
|
2010-06-14 19:54:00 +04:00
|
|
|
xcb_atom_t net_wm_name;
|
2011-01-26 22:37:07 +03:00
|
|
|
xcb_atom_t net_wm_icon;
|
2011-06-18 12:20:54 +04:00
|
|
|
xcb_atom_t net_wm_state;
|
|
|
|
xcb_atom_t net_wm_state_fullscreen;
|
2011-01-26 22:02:31 +03:00
|
|
|
xcb_atom_t string;
|
2010-06-14 19:54:00 +04:00
|
|
|
xcb_atom_t utf8_string;
|
2011-01-26 22:37:07 +03:00
|
|
|
xcb_atom_t cardinal;
|
2012-05-01 23:37:10 +04:00
|
|
|
xcb_atom_t xkb_names;
|
2010-06-14 19:54:00 +04:00
|
|
|
} atom;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct x11_output {
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
struct weston_output base;
|
2010-06-14 19:54:00 +04:00
|
|
|
|
|
|
|
xcb_window_t window;
|
2011-03-02 12:07:59 +03:00
|
|
|
EGLSurface egl_surface;
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
struct weston_mode mode;
|
2011-10-29 22:39:13 +04:00
|
|
|
struct wl_event_source *finish_frame_timer;
|
2010-06-14 19:54:00 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct x11_input {
|
2012-05-16 21:45:18 +04:00
|
|
|
struct weston_seat base;
|
2010-06-14 19:54:00 +04:00
|
|
|
};
|
|
|
|
|
2012-06-01 15:14:02 +04:00
|
|
|
static struct xkb_keymap *
|
|
|
|
x11_compositor_get_keymap(struct x11_compositor *c)
|
|
|
|
{
|
|
|
|
xcb_get_property_cookie_t cookie;
|
|
|
|
xcb_get_property_reply_t *reply;
|
|
|
|
xcb_generic_error_t *error;
|
|
|
|
struct xkb_rule_names names;
|
|
|
|
struct xkb_keymap *ret;
|
|
|
|
const char *value_all, *value_part;
|
|
|
|
int length_all, length_part;
|
|
|
|
|
|
|
|
memset(&names, 0, sizeof(names));
|
|
|
|
|
|
|
|
cookie = xcb_get_property(c->conn, 0, c->screen->root,
|
|
|
|
c->atom.xkb_names, c->atom.string, 0, 1024);
|
|
|
|
reply = xcb_get_property_reply(c->conn, cookie, &error);
|
|
|
|
if (reply == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
value_all = xcb_get_property_value(reply);
|
|
|
|
length_all = xcb_get_property_value_length(reply);
|
|
|
|
value_part = value_all;
|
|
|
|
|
|
|
|
#define copy_prop_value(to) \
|
|
|
|
length_part = strlen(value_part); \
|
|
|
|
if (value_part + length_part < (value_all + length_all) && \
|
|
|
|
length_part > 0) \
|
|
|
|
names.to = value_part; \
|
|
|
|
value_part += length_part + 1;
|
|
|
|
|
|
|
|
copy_prop_value(rules);
|
|
|
|
copy_prop_value(model);
|
|
|
|
copy_prop_value(layout);
|
|
|
|
copy_prop_value(variant);
|
|
|
|
copy_prop_value(options);
|
|
|
|
#undef copy_prop_value
|
|
|
|
|
|
|
|
ret = xkb_map_new_from_names(c->base.xkb_context, &names, 0);
|
|
|
|
|
|
|
|
free(reply);
|
|
|
|
return ret;
|
|
|
|
}
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2012-06-22 16:21:35 +04:00
|
|
|
static void
|
|
|
|
x11_compositor_setup_xkb(struct x11_compositor *c)
|
|
|
|
{
|
|
|
|
#ifndef HAVE_XCB_XKB
|
|
|
|
weston_log("XCB-XKB not available during build\n");
|
|
|
|
c->has_xkb = 0;
|
|
|
|
c->xkb_event_base = 0;
|
|
|
|
return;
|
|
|
|
#else
|
|
|
|
const xcb_query_extension_reply_t *ext;
|
2012-06-22 16:21:36 +04:00
|
|
|
xcb_generic_error_t *error;
|
2012-06-22 16:21:39 +04:00
|
|
|
xcb_void_cookie_t select;
|
2012-06-22 16:21:36 +04:00
|
|
|
xcb_xkb_per_client_flags_cookie_t pcf;
|
|
|
|
xcb_xkb_per_client_flags_reply_t *pcf_reply;
|
2012-06-22 16:21:35 +04:00
|
|
|
|
|
|
|
c->has_xkb = 0;
|
|
|
|
c->xkb_event_base = 0;
|
|
|
|
|
|
|
|
ext = xcb_get_extension_data(c->conn, &xcb_xkb_id);
|
|
|
|
if (!ext) {
|
|
|
|
weston_log("XKB extension not available on host X11 server\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
c->xkb_event_base = ext->first_event;
|
|
|
|
|
2012-06-22 16:21:39 +04:00
|
|
|
select = xcb_xkb_select_events(c->conn,
|
|
|
|
XCB_XKB_ID_USE_CORE_KBD,
|
|
|
|
XCB_XKB_EVENT_TYPE_STATE_NOTIFY,
|
|
|
|
0,
|
|
|
|
XCB_XKB_EVENT_TYPE_STATE_NOTIFY,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
NULL);
|
|
|
|
error = xcb_request_check(c->conn, select);
|
|
|
|
if (error) {
|
|
|
|
weston_log("error: failed to select for XKB state events\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-06-22 16:21:36 +04:00
|
|
|
pcf = xcb_xkb_per_client_flags(c->conn,
|
|
|
|
XCB_XKB_ID_USE_CORE_KBD,
|
|
|
|
XCB_XKB_PER_CLIENT_FLAG_DETECTABLE_AUTO_REPEAT,
|
|
|
|
XCB_XKB_PER_CLIENT_FLAG_DETECTABLE_AUTO_REPEAT,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
0);
|
|
|
|
pcf_reply = xcb_xkb_per_client_flags_reply(c->conn, pcf, &error);
|
|
|
|
free(pcf_reply);
|
|
|
|
if (error) {
|
|
|
|
weston_log("failed to set XKB per-client flags, not using "
|
|
|
|
"detectable repeat\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-06-22 16:21:35 +04:00
|
|
|
c->has_xkb = 1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-11-23 05:24:39 +03:00
|
|
|
static int
|
2012-06-07 16:07:05 +04:00
|
|
|
x11_input_create(struct x11_compositor *c, int no_input)
|
2010-06-14 19:54:00 +04:00
|
|
|
{
|
|
|
|
struct x11_input *input;
|
2012-06-01 15:14:02 +04:00
|
|
|
struct xkb_keymap *keymap;
|
2010-06-14 19:54:00 +04:00
|
|
|
|
|
|
|
input = malloc(sizeof *input);
|
|
|
|
if (input == NULL)
|
2010-11-23 05:24:39 +03:00
|
|
|
return -1;
|
2010-06-14 19:54:00 +04:00
|
|
|
|
|
|
|
memset(input, 0, sizeof *input);
|
2012-05-16 21:45:18 +04:00
|
|
|
weston_seat_init(&input->base, &c->base);
|
2012-06-07 16:07:05 +04:00
|
|
|
c->base.seat = &input->base;
|
|
|
|
|
|
|
|
if (no_input)
|
|
|
|
return 0;
|
|
|
|
|
2012-05-30 19:32:02 +04:00
|
|
|
weston_seat_init_pointer(&input->base);
|
2012-06-01 15:14:02 +04:00
|
|
|
|
2012-06-22 16:21:35 +04:00
|
|
|
x11_compositor_setup_xkb(c);
|
|
|
|
|
2012-06-01 15:14:02 +04:00
|
|
|
keymap = x11_compositor_get_keymap(c);
|
|
|
|
weston_seat_init_keyboard(&input->base, keymap);
|
|
|
|
if (keymap)
|
|
|
|
xkb_map_unref(keymap);
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2010-11-23 05:24:39 +03:00
|
|
|
return 0;
|
2010-06-14 19:54:00 +04:00
|
|
|
}
|
|
|
|
|
2012-01-03 13:58:34 +04:00
|
|
|
static void
|
|
|
|
x11_input_destroy(struct x11_compositor *compositor)
|
|
|
|
{
|
2012-05-16 21:45:18 +04:00
|
|
|
struct x11_input *input = container_of(compositor->base.seat,
|
2012-01-03 13:58:34 +04:00
|
|
|
struct x11_input,
|
2012-05-16 21:45:18 +04:00
|
|
|
base);
|
2012-01-03 13:58:34 +04:00
|
|
|
|
2012-05-16 21:45:18 +04:00
|
|
|
weston_seat_release(&input->base);
|
2012-01-03 13:58:34 +04:00
|
|
|
free(input);
|
|
|
|
}
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
static int
|
|
|
|
x11_compositor_init_egl(struct x11_compositor *c)
|
|
|
|
{
|
2010-07-29 06:52:28 +04:00
|
|
|
EGLint major, minor;
|
2011-03-02 12:07:59 +03:00
|
|
|
EGLint n;
|
|
|
|
EGLint config_attribs[] = {
|
|
|
|
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
|
|
|
|
EGL_RED_SIZE, 1,
|
|
|
|
EGL_GREEN_SIZE, 1,
|
|
|
|
EGL_BLUE_SIZE, 1,
|
|
|
|
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
|
|
|
|
EGL_NONE
|
|
|
|
};
|
2010-07-29 07:47:54 +04:00
|
|
|
static const EGLint context_attribs[] = {
|
|
|
|
EGL_CONTEXT_CLIENT_VERSION, 2,
|
|
|
|
EGL_NONE
|
|
|
|
};
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2012-03-29 06:53:49 +04:00
|
|
|
static const EGLint pbuffer_attribs[] = {
|
|
|
|
EGL_WIDTH, 10,
|
|
|
|
EGL_HEIGHT, 10,
|
|
|
|
EGL_NONE
|
|
|
|
};
|
|
|
|
|
2012-06-18 23:13:51 +04:00
|
|
|
c->base.egl_display = eglGetDisplay(c->dpy);
|
|
|
|
if (c->base.egl_display == NULL) {
|
2012-06-07 20:01:59 +04:00
|
|
|
weston_log("failed to create display\n");
|
2010-06-14 19:54:00 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-06-18 23:13:51 +04:00
|
|
|
if (!eglInitialize(c->base.egl_display, &major, &minor)) {
|
2012-06-07 20:01:59 +04:00
|
|
|
weston_log("failed to initialize display\n");
|
2010-06-14 19:54:00 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-11-23 05:24:39 +03:00
|
|
|
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
|
2012-06-07 20:01:59 +04:00
|
|
|
weston_log("failed to bind EGL_OPENGL_ES_API\n");
|
2010-11-23 05:24:39 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2012-06-18 23:13:51 +04:00
|
|
|
if (!eglChooseConfig(c->base.egl_display, config_attribs,
|
|
|
|
&c->base.egl_config, 1, &n) || n == 0) {
|
2012-06-07 20:01:59 +04:00
|
|
|
weston_log("failed to choose config: %d\n", n);
|
2011-03-02 12:07:59 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2010-11-23 05:24:39 +03:00
|
|
|
|
2012-06-18 23:13:51 +04:00
|
|
|
c->base.egl_context =
|
|
|
|
eglCreateContext(c->base.egl_display, c->base.egl_config,
|
|
|
|
EGL_NO_CONTEXT, context_attribs);
|
|
|
|
if (c->base.egl_context == NULL) {
|
2012-06-07 20:01:59 +04:00
|
|
|
weston_log("failed to create context\n");
|
2010-06-14 19:54:00 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-06-18 23:13:51 +04:00
|
|
|
c->dummy_pbuffer = eglCreatePbufferSurface(c->base.egl_display,
|
|
|
|
c->base.egl_config,
|
2012-03-29 06:53:49 +04:00
|
|
|
pbuffer_attribs);
|
2012-05-17 17:40:23 +04:00
|
|
|
if (c->dummy_pbuffer == NULL) {
|
2012-06-07 20:01:59 +04:00
|
|
|
weston_log("failed to create dummy pbuffer\n");
|
2012-03-29 06:53:49 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-06-18 23:13:51 +04:00
|
|
|
if (!eglMakeCurrent(c->base.egl_display, c->dummy_pbuffer,
|
|
|
|
c->dummy_pbuffer, c->base.egl_context)) {
|
2012-06-07 20:01:59 +04:00
|
|
|
weston_log("failed to make context current\n");
|
2010-06-14 19:54:00 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-03 13:58:34 +04:00
|
|
|
static void
|
|
|
|
x11_compositor_fini_egl(struct x11_compositor *compositor)
|
|
|
|
{
|
2012-06-18 23:13:51 +04:00
|
|
|
eglMakeCurrent(compositor->base.egl_display,
|
2012-01-03 13:58:34 +04:00
|
|
|
EGL_NO_SURFACE, EGL_NO_SURFACE,
|
|
|
|
EGL_NO_CONTEXT);
|
|
|
|
|
2012-06-18 23:13:51 +04:00
|
|
|
eglTerminate(compositor->base.egl_display);
|
2012-01-03 13:58:34 +04:00
|
|
|
eglReleaseThread();
|
|
|
|
}
|
|
|
|
|
2012-01-26 08:47:45 +04:00
|
|
|
static void
|
2012-02-29 07:31:58 +04:00
|
|
|
x11_output_repaint(struct weston_output *output_base,
|
|
|
|
pixman_region32_t *damage)
|
2011-03-11 18:39:20 +03:00
|
|
|
{
|
2012-01-26 08:47:45 +04:00
|
|
|
struct x11_output *output = (struct x11_output *)output_base;
|
|
|
|
struct x11_compositor *compositor =
|
|
|
|
(struct x11_compositor *)output->base.compositor;
|
|
|
|
struct weston_surface *surface;
|
2011-03-11 18:39:20 +03:00
|
|
|
|
2012-06-18 23:13:51 +04:00
|
|
|
if (!eglMakeCurrent(compositor->base.egl_display, output->egl_surface,
|
|
|
|
output->egl_surface,
|
|
|
|
compositor->base.egl_context)) {
|
2012-06-07 20:01:59 +04:00
|
|
|
weston_log("failed to make current\n");
|
2012-01-26 08:47:45 +04:00
|
|
|
return;
|
2011-03-11 18:39:20 +03:00
|
|
|
}
|
|
|
|
|
2012-01-26 08:47:45 +04:00
|
|
|
wl_list_for_each_reverse(surface, &compositor->base.surface_list, link)
|
2012-02-29 07:31:58 +04:00
|
|
|
weston_surface_draw(surface, &output->base, damage);
|
2011-03-11 18:39:20 +03:00
|
|
|
|
2012-06-20 08:13:18 +04:00
|
|
|
wl_signal_emit(&output->base.frame_signal, output);
|
2012-04-20 23:37:33 +04:00
|
|
|
|
2012-06-18 23:13:51 +04:00
|
|
|
eglSwapBuffers(compositor->base.egl_display, output->egl_surface);
|
2012-01-26 08:32:28 +04:00
|
|
|
|
2012-01-26 08:47:45 +04:00
|
|
|
wl_event_source_timer_update(output->finish_frame_timer, 10);
|
2012-01-26 08:32:28 +04:00
|
|
|
}
|
|
|
|
|
2011-10-29 22:39:13 +04:00
|
|
|
static int
|
|
|
|
finish_frame_handler(void *data)
|
|
|
|
{
|
|
|
|
struct x11_output *output = data;
|
|
|
|
uint32_t msec;
|
|
|
|
struct timeval tv;
|
|
|
|
|
|
|
|
gettimeofday(&tv, NULL);
|
|
|
|
msec = tv.tv_sec * 1000 + tv.tv_usec / 1000;
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
weston_output_finish_frame(&output->base, msec);
|
2011-10-29 22:39:13 +04:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-08-30 00:52:23 +04:00
|
|
|
static void
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
x11_output_destroy(struct weston_output *output_base)
|
2011-08-30 00:52:23 +04:00
|
|
|
{
|
2012-01-03 13:51:03 +04:00
|
|
|
struct x11_output *output = (struct x11_output *)output_base;
|
|
|
|
struct x11_compositor *compositor =
|
|
|
|
(struct x11_compositor *)output->base.compositor;
|
|
|
|
|
|
|
|
wl_list_remove(&output->base.link);
|
|
|
|
wl_event_source_remove(output->finish_frame_timer);
|
|
|
|
|
2012-06-18 23:13:51 +04:00
|
|
|
eglDestroySurface(compositor->base.egl_display, output->egl_surface);
|
2012-01-03 13:51:03 +04:00
|
|
|
|
|
|
|
xcb_destroy_window(compositor->conn, output->window);
|
|
|
|
|
2012-01-03 20:29:15 +04:00
|
|
|
weston_output_destroy(&output->base);
|
2012-01-03 13:51:03 +04:00
|
|
|
|
|
|
|
free(output);
|
2011-08-30 00:52:23 +04:00
|
|
|
}
|
2011-04-20 13:02:58 +04:00
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
static void
|
|
|
|
x11_output_set_wm_protocols(struct x11_output *output)
|
|
|
|
{
|
|
|
|
xcb_atom_t list[1];
|
|
|
|
struct x11_compositor *c =
|
|
|
|
(struct x11_compositor *) output->base.compositor;
|
|
|
|
|
|
|
|
list[0] = c->atom.wm_delete_window;
|
|
|
|
xcb_change_property (c->conn,
|
|
|
|
XCB_PROP_MODE_REPLACE,
|
|
|
|
output->window,
|
|
|
|
c->atom.wm_protocols,
|
|
|
|
XCB_ATOM_ATOM,
|
|
|
|
32,
|
2011-12-23 22:33:45 +04:00
|
|
|
ARRAY_LENGTH(list),
|
2010-06-14 19:54:00 +04:00
|
|
|
list);
|
|
|
|
}
|
|
|
|
|
2011-06-18 12:20:54 +04:00
|
|
|
static void
|
|
|
|
x11_output_change_state(struct x11_output *output, int add, xcb_atom_t state)
|
|
|
|
{
|
|
|
|
xcb_client_message_event_t event;
|
|
|
|
struct x11_compositor *c =
|
|
|
|
(struct x11_compositor *) output->base.compositor;
|
|
|
|
xcb_screen_iterator_t iter;
|
|
|
|
|
|
|
|
#define _NET_WM_STATE_REMOVE 0 /* remove/unset property */
|
|
|
|
#define _NET_WM_STATE_ADD 1 /* add/set property */
|
|
|
|
#define _NET_WM_STATE_TOGGLE 2 /* toggle property */
|
|
|
|
|
|
|
|
memset(&event, 0, sizeof event);
|
|
|
|
event.response_type = XCB_CLIENT_MESSAGE;
|
|
|
|
event.format = 32;
|
|
|
|
event.window = output->window;
|
|
|
|
event.type = c->atom.net_wm_state;
|
|
|
|
|
|
|
|
event.data.data32[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
|
|
|
|
event.data.data32[1] = state;
|
|
|
|
event.data.data32[2] = 0;
|
|
|
|
event.data.data32[3] = 0;
|
|
|
|
event.data.data32[4] = 0;
|
|
|
|
|
|
|
|
iter = xcb_setup_roots_iterator(xcb_get_setup(c->conn));
|
|
|
|
xcb_send_event(c->conn, 0, iter.data->root,
|
|
|
|
XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
|
|
|
|
XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
|
|
|
|
(void *) &event);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
struct wm_normal_hints {
|
|
|
|
uint32_t flags;
|
|
|
|
uint32_t pad[4];
|
|
|
|
int32_t min_width, min_height;
|
|
|
|
int32_t max_width, max_height;
|
|
|
|
int32_t width_inc, height_inc;
|
|
|
|
int32_t min_aspect_x, min_aspect_y;
|
|
|
|
int32_t max_aspect_x, max_aspect_y;
|
|
|
|
int32_t base_width, base_height;
|
|
|
|
int32_t win_gravity;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define WM_NORMAL_HINTS_MIN_SIZE 16
|
|
|
|
#define WM_NORMAL_HINTS_MAX_SIZE 32
|
|
|
|
|
2011-01-26 22:37:07 +03:00
|
|
|
static void
|
2011-04-23 23:03:15 +04:00
|
|
|
x11_output_set_icon(struct x11_compositor *c,
|
|
|
|
struct x11_output *output, const char *filename)
|
2011-01-26 22:37:07 +03:00
|
|
|
{
|
2012-03-12 09:05:25 +04:00
|
|
|
uint32_t *icon;
|
2011-04-23 23:03:15 +04:00
|
|
|
int32_t width, height;
|
2012-03-12 09:05:25 +04:00
|
|
|
pixman_image_t *image;
|
2011-01-26 22:37:07 +03:00
|
|
|
|
2012-03-12 09:05:25 +04:00
|
|
|
image = load_image(filename);
|
|
|
|
if (!image)
|
2011-01-26 22:37:07 +03:00
|
|
|
return;
|
2012-03-12 09:05:25 +04:00
|
|
|
width = pixman_image_get_width(image);
|
|
|
|
height = pixman_image_get_height(image);
|
2011-01-26 22:37:07 +03:00
|
|
|
icon = malloc(width * height * 4 + 8);
|
|
|
|
if (!icon) {
|
2012-03-12 09:05:25 +04:00
|
|
|
pixman_image_unref(image);
|
2011-01-26 22:37:07 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
icon[0] = width;
|
|
|
|
icon[1] = height;
|
2012-03-12 09:05:25 +04:00
|
|
|
memcpy(icon + 2, pixman_image_get_data(image), width * height * 4);
|
2011-01-26 22:37:07 +03:00
|
|
|
xcb_change_property(c->conn, XCB_PROP_MODE_REPLACE, output->window,
|
|
|
|
c->atom.net_wm_icon, c->atom.cardinal, 32,
|
|
|
|
width * height + 2, icon);
|
|
|
|
free(icon);
|
2012-03-12 09:05:25 +04:00
|
|
|
pixman_image_unref(image);
|
2011-01-26 22:37:07 +03:00
|
|
|
}
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
static int
|
2011-07-21 21:22:13 +04:00
|
|
|
x11_compositor_create_output(struct x11_compositor *c, int x, int y,
|
2012-06-07 16:07:05 +04:00
|
|
|
int width, int height, int fullscreen,
|
|
|
|
int no_input)
|
2010-06-14 19:54:00 +04:00
|
|
|
{
|
2012-01-04 08:24:14 +04:00
|
|
|
static const char name[] = "Weston Compositor";
|
|
|
|
static const char class[] = "weston-1\0Weston Compositor";
|
2010-06-14 19:54:00 +04:00
|
|
|
struct x11_output *output;
|
|
|
|
xcb_screen_iterator_t iter;
|
|
|
|
struct wm_normal_hints normal_hints;
|
2011-10-29 22:39:13 +04:00
|
|
|
struct wl_event_loop *loop;
|
2010-06-14 19:54:00 +04:00
|
|
|
uint32_t mask = XCB_CW_EVENT_MASK | XCB_CW_CURSOR;
|
2012-06-07 16:07:05 +04:00
|
|
|
uint32_t values[2] = {
|
2010-06-14 19:54:00 +04:00
|
|
|
XCB_EVENT_MASK_EXPOSURE |
|
2012-06-07 16:07:05 +04:00
|
|
|
XCB_EVENT_MASK_STRUCTURE_NOTIFY,
|
2010-06-14 19:54:00 +04:00
|
|
|
0
|
|
|
|
};
|
|
|
|
|
2012-06-07 16:07:05 +04:00
|
|
|
if (!no_input)
|
|
|
|
values[0] |=
|
|
|
|
XCB_EVENT_MASK_KEY_PRESS |
|
|
|
|
XCB_EVENT_MASK_KEY_RELEASE |
|
|
|
|
XCB_EVENT_MASK_BUTTON_PRESS |
|
|
|
|
XCB_EVENT_MASK_BUTTON_RELEASE |
|
|
|
|
XCB_EVENT_MASK_POINTER_MOTION |
|
|
|
|
XCB_EVENT_MASK_ENTER_WINDOW |
|
|
|
|
XCB_EVENT_MASK_LEAVE_WINDOW |
|
|
|
|
XCB_EVENT_MASK_KEYMAP_STATE |
|
|
|
|
XCB_EVENT_MASK_FOCUS_CHANGE;
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
output = malloc(sizeof *output);
|
|
|
|
if (output == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
memset(output, 0, sizeof *output);
|
2011-06-21 19:16:58 +04:00
|
|
|
|
|
|
|
output->mode.flags =
|
|
|
|
WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED;
|
|
|
|
output->mode.width = width;
|
|
|
|
output->mode.height = height;
|
2012-05-10 20:23:53 +04:00
|
|
|
output->mode.refresh = 60000;
|
2011-06-21 19:16:58 +04:00
|
|
|
wl_list_init(&output->base.mode_list);
|
|
|
|
wl_list_insert(&output->base.mode_list, &output->mode.link);
|
|
|
|
|
|
|
|
output->base.current = &output->mode;
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
weston_output_init(&output->base, &c->base, x, y, width, height,
|
2011-03-02 12:07:59 +03:00
|
|
|
WL_OUTPUT_FLIPPED);
|
2010-06-14 19:54:00 +04:00
|
|
|
|
|
|
|
values[1] = c->null_cursor;
|
|
|
|
output->window = xcb_generate_id(c->conn);
|
|
|
|
iter = xcb_setup_roots_iterator(xcb_get_setup(c->conn));
|
|
|
|
xcb_create_window(c->conn,
|
|
|
|
XCB_COPY_FROM_PARENT,
|
|
|
|
output->window,
|
|
|
|
iter.data->root,
|
|
|
|
0, 0,
|
|
|
|
width, height,
|
|
|
|
0,
|
|
|
|
XCB_WINDOW_CLASS_INPUT_OUTPUT,
|
|
|
|
iter.data->root_visual,
|
|
|
|
mask, values);
|
|
|
|
|
|
|
|
/* Don't resize me. */
|
|
|
|
memset(&normal_hints, 0, sizeof normal_hints);
|
|
|
|
normal_hints.flags =
|
|
|
|
WM_NORMAL_HINTS_MAX_SIZE | WM_NORMAL_HINTS_MIN_SIZE;
|
|
|
|
normal_hints.min_width = width;
|
|
|
|
normal_hints.min_height = height;
|
|
|
|
normal_hints.max_width = width;
|
|
|
|
normal_hints.max_height = height;
|
|
|
|
xcb_change_property (c->conn, XCB_PROP_MODE_REPLACE, output->window,
|
|
|
|
c->atom.wm_normal_hints,
|
|
|
|
c->atom.wm_size_hints, 32,
|
|
|
|
sizeof normal_hints / 4,
|
|
|
|
(uint8_t *) &normal_hints);
|
|
|
|
|
|
|
|
/* Set window name. Don't bother with non-EWMH WMs. */
|
|
|
|
xcb_change_property(c->conn, XCB_PROP_MODE_REPLACE, output->window,
|
|
|
|
c->atom.net_wm_name, c->atom.utf8_string, 8,
|
|
|
|
strlen(name), name);
|
2011-01-26 22:02:31 +03:00
|
|
|
xcb_change_property(c->conn, XCB_PROP_MODE_REPLACE, output->window,
|
|
|
|
c->atom.wm_class, c->atom.string, 8,
|
|
|
|
sizeof class, class);
|
|
|
|
|
2012-01-04 08:24:14 +04:00
|
|
|
x11_output_set_icon(c, output, DATADIR "/weston/wayland.png");
|
2011-01-26 22:37:07 +03:00
|
|
|
|
2011-01-26 22:02:31 +03:00
|
|
|
xcb_map_window(c->conn, output->window);
|
2010-06-14 19:54:00 +04:00
|
|
|
|
|
|
|
x11_output_set_wm_protocols(output);
|
|
|
|
|
2011-06-18 12:20:54 +04:00
|
|
|
if (fullscreen)
|
|
|
|
x11_output_change_state(output, 1,
|
|
|
|
c->atom.net_wm_state_fullscreen);
|
|
|
|
|
2011-03-02 12:07:59 +03:00
|
|
|
output->egl_surface =
|
2012-06-18 23:13:51 +04:00
|
|
|
eglCreateWindowSurface(c->base.egl_display, c->base.egl_config,
|
2011-03-02 12:07:59 +03:00
|
|
|
output->window, NULL);
|
|
|
|
if (!output->egl_surface) {
|
2012-06-07 20:01:59 +04:00
|
|
|
weston_log("failed to create window surface\n");
|
2010-06-14 19:54:00 +04:00
|
|
|
return -1;
|
2011-03-02 12:07:59 +03:00
|
|
|
}
|
2012-06-18 23:13:51 +04:00
|
|
|
if (!eglMakeCurrent(c->base.egl_display, output->egl_surface,
|
|
|
|
output->egl_surface, c->base.egl_context)) {
|
2012-06-07 20:01:59 +04:00
|
|
|
weston_log("failed to make surface current\n");
|
2010-06-14 19:54:00 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-10-29 22:39:13 +04:00
|
|
|
loop = wl_display_get_event_loop(c->base.wl_display);
|
|
|
|
output->finish_frame_timer =
|
|
|
|
wl_event_loop_add_timer(loop, finish_frame_handler, output);
|
|
|
|
|
2012-04-17 13:20:49 +04:00
|
|
|
output->base.origin = output->base.current;
|
2012-01-26 08:32:28 +04:00
|
|
|
output->base.repaint = x11_output_repaint;
|
2011-08-30 00:52:23 +04:00
|
|
|
output->base.destroy = x11_output_destroy;
|
2012-02-10 01:12:57 +04:00
|
|
|
output->base.assign_planes = NULL;
|
2012-02-29 21:53:50 +04:00
|
|
|
output->base.set_backlight = NULL;
|
|
|
|
output->base.set_dpms = NULL;
|
2012-04-17 13:20:47 +04:00
|
|
|
output->base.switch_mode = NULL;
|
2011-03-11 18:39:20 +03:00
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
wl_list_insert(c->base.output_list.prev, &output->base.link);
|
|
|
|
|
2012-06-09 00:45:33 +04:00
|
|
|
weston_log("x11 output %dx%d, window id %d\n",
|
|
|
|
width, height, output->window);
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct x11_output *
|
|
|
|
x11_compositor_find_output(struct x11_compositor *c, xcb_window_t window)
|
|
|
|
{
|
|
|
|
struct x11_output *output;
|
|
|
|
|
|
|
|
wl_list_for_each(output, &c->base.output_list, base.link) {
|
|
|
|
if (output->window == window)
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-06-22 16:21:39 +04:00
|
|
|
#ifdef HAVE_XCB_XKB
|
|
|
|
static uint32_t
|
|
|
|
get_xkb_mod_mask(struct x11_compositor *c, uint32_t in)
|
|
|
|
{
|
|
|
|
struct weston_xkb_info *info = &c->base.seat->xkb_info;
|
|
|
|
uint32_t ret = 0;
|
|
|
|
|
|
|
|
if ((in & ShiftMask) && info->shift_mod != XKB_MOD_INVALID)
|
|
|
|
ret |= (1 << info->shift_mod);
|
|
|
|
if ((in & LockMask) && info->caps_mod != XKB_MOD_INVALID)
|
|
|
|
ret |= (1 << info->caps_mod);
|
|
|
|
if ((in & ControlMask) && info->ctrl_mod != XKB_MOD_INVALID)
|
|
|
|
ret |= (1 << info->ctrl_mod);
|
|
|
|
if ((in & Mod1Mask) && info->alt_mod != XKB_MOD_INVALID)
|
|
|
|
ret |= (1 << info->alt_mod);
|
|
|
|
if ((in & Mod2Mask) && info->mod2_mod != XKB_MOD_INVALID)
|
|
|
|
ret |= (1 << info->mod2_mod);
|
|
|
|
if ((in & Mod3Mask) && info->mod3_mod != XKB_MOD_INVALID)
|
|
|
|
ret |= (1 << info->mod3_mod);
|
|
|
|
if ((in & Mod4Mask) && info->super_mod != XKB_MOD_INVALID)
|
|
|
|
ret |= (1 << info->super_mod);
|
|
|
|
if ((in & Mod5Mask) && info->mod5_mod != XKB_MOD_INVALID)
|
|
|
|
ret |= (1 << info->mod5_mod);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
update_xkb_state(struct x11_compositor *c, xcb_xkb_state_notify_event_t *state)
|
|
|
|
{
|
|
|
|
struct weston_compositor *ec = &c->base;
|
|
|
|
struct wl_seat *seat = &ec->seat->seat;
|
|
|
|
|
|
|
|
xkb_state_update_mask(c->base.seat->xkb_state.state,
|
|
|
|
get_xkb_mod_mask(c, state->baseMods),
|
|
|
|
get_xkb_mod_mask(c, state->latchedMods),
|
|
|
|
get_xkb_mod_mask(c, state->lockedMods),
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
state->group);
|
|
|
|
|
|
|
|
notify_modifiers(seat, wl_display_next_serial(c->base.wl_display));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-12-08 19:03:17 +04:00
|
|
|
static void
|
|
|
|
x11_compositor_deliver_button_event(struct x11_compositor *c,
|
|
|
|
xcb_generic_event_t *event, int state)
|
|
|
|
{
|
|
|
|
xcb_button_press_event_t *button_event =
|
|
|
|
(xcb_button_press_event_t *) event;
|
2012-05-04 14:21:55 +04:00
|
|
|
uint32_t button;
|
2011-12-08 19:03:17 +04:00
|
|
|
|
|
|
|
switch (button_event->detail) {
|
|
|
|
default:
|
|
|
|
button = button_event->detail + BTN_LEFT - 1;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
button = BTN_MIDDLE;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
button = BTN_RIGHT;
|
|
|
|
break;
|
|
|
|
case 4:
|
2012-03-22 20:47:01 +04:00
|
|
|
if (state)
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_axis(&c->base.seat->seat,
|
2012-03-22 20:47:01 +04:00
|
|
|
weston_compositor_get_time(),
|
2012-05-30 19:31:57 +04:00
|
|
|
WL_POINTER_AXIS_VERTICAL_SCROLL,
|
|
|
|
wl_fixed_from_int(1));
|
2012-03-22 20:47:01 +04:00
|
|
|
return;
|
2011-12-08 19:03:17 +04:00
|
|
|
case 5:
|
2012-03-22 20:47:01 +04:00
|
|
|
if (state)
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_axis(&c->base.seat->seat,
|
2012-03-22 20:47:01 +04:00
|
|
|
weston_compositor_get_time(),
|
2012-05-30 19:31:57 +04:00
|
|
|
WL_POINTER_AXIS_VERTICAL_SCROLL,
|
|
|
|
wl_fixed_from_int(-1));
|
2012-03-22 20:47:01 +04:00
|
|
|
return;
|
2011-12-08 19:03:17 +04:00
|
|
|
case 6:
|
2012-03-22 20:47:01 +04:00
|
|
|
if (state)
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_axis(&c->base.seat->seat,
|
2012-03-22 20:47:01 +04:00
|
|
|
weston_compositor_get_time(),
|
2012-05-30 19:31:57 +04:00
|
|
|
WL_POINTER_AXIS_HORIZONTAL_SCROLL,
|
|
|
|
wl_fixed_from_int(1));
|
2012-03-22 20:47:01 +04:00
|
|
|
return;
|
2011-12-08 19:03:17 +04:00
|
|
|
case 7:
|
2012-03-22 20:47:01 +04:00
|
|
|
if (state)
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_axis(&c->base.seat->seat,
|
2012-03-22 20:47:01 +04:00
|
|
|
weston_compositor_get_time(),
|
2012-05-30 19:31:57 +04:00
|
|
|
WL_POINTER_AXIS_HORIZONTAL_SCROLL,
|
|
|
|
wl_fixed_from_int(-1));
|
2011-12-08 19:03:17 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_button(&c->base.seat->seat,
|
2012-05-30 19:31:51 +04:00
|
|
|
weston_compositor_get_time(), button,
|
|
|
|
state ? WL_POINTER_BUTTON_STATE_PRESSED :
|
|
|
|
WL_POINTER_BUTTON_STATE_RELEASED);
|
2011-12-08 19:03:17 +04:00
|
|
|
}
|
|
|
|
|
2011-04-21 22:51:44 +04:00
|
|
|
static int
|
|
|
|
x11_compositor_next_event(struct x11_compositor *c,
|
2011-04-22 20:18:13 +04:00
|
|
|
xcb_generic_event_t **event, uint32_t mask)
|
2011-04-21 22:51:44 +04:00
|
|
|
{
|
2011-04-22 20:18:13 +04:00
|
|
|
if (mask & WL_EVENT_READABLE) {
|
|
|
|
*event = xcb_poll_for_event(c->conn);
|
2011-04-21 22:51:44 +04:00
|
|
|
} else {
|
2011-04-25 23:41:59 +04:00
|
|
|
#ifdef HAVE_XCB_POLL_FOR_QUEUED_EVENT
|
2011-04-22 20:18:13 +04:00
|
|
|
*event = xcb_poll_for_queued_event(c->conn);
|
2011-04-25 23:41:59 +04:00
|
|
|
#else
|
|
|
|
*event = xcb_poll_for_event(c->conn);
|
|
|
|
#endif
|
2011-04-21 22:51:44 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return *event != NULL;
|
|
|
|
}
|
|
|
|
|
2011-04-22 20:18:13 +04:00
|
|
|
static int
|
2010-06-14 19:54:00 +04:00
|
|
|
x11_compositor_handle_event(int fd, uint32_t mask, void *data)
|
|
|
|
{
|
|
|
|
struct x11_compositor *c = data;
|
|
|
|
struct x11_output *output;
|
2011-04-19 17:23:29 +04:00
|
|
|
xcb_generic_event_t *event, *prev;
|
2010-06-14 19:54:00 +04:00
|
|
|
xcb_client_message_event_t *client_message;
|
|
|
|
xcb_motion_notify_event_t *motion_notify;
|
2011-01-27 04:35:07 +03:00
|
|
|
xcb_enter_notify_event_t *enter_notify;
|
2011-04-19 17:23:29 +04:00
|
|
|
xcb_key_press_event_t *key_press, *key_release;
|
2011-01-27 19:57:19 +03:00
|
|
|
xcb_keymap_notify_event_t *keymap_notify;
|
|
|
|
xcb_focus_in_event_t *focus_in;
|
2012-06-20 08:35:59 +04:00
|
|
|
xcb_expose_event_t *expose;
|
2010-06-14 19:54:00 +04:00
|
|
|
xcb_atom_t atom;
|
2011-01-27 19:57:19 +03:00
|
|
|
uint32_t *k;
|
2012-03-30 19:52:39 +04:00
|
|
|
uint32_t i, set;
|
2012-05-09 20:19:04 +04:00
|
|
|
wl_fixed_t x, y;
|
2012-06-06 01:08:23 +04:00
|
|
|
int count;
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2011-04-19 17:23:29 +04:00
|
|
|
prev = NULL;
|
2012-06-06 01:08:23 +04:00
|
|
|
count = 0;
|
2011-04-22 20:18:13 +04:00
|
|
|
while (x11_compositor_next_event(c, &event, mask)) {
|
2011-04-19 17:23:29 +04:00
|
|
|
switch (prev ? prev->response_type & ~0x80 : 0x80) {
|
|
|
|
case XCB_KEY_RELEASE:
|
2012-06-22 16:21:36 +04:00
|
|
|
/* Suppress key repeat events; this is only used if we
|
|
|
|
* don't have XCB XKB support. */
|
2011-04-19 17:23:29 +04:00
|
|
|
key_release = (xcb_key_press_event_t *) prev;
|
|
|
|
key_press = (xcb_key_press_event_t *) event;
|
|
|
|
if ((event->response_type & ~0x80) == XCB_KEY_PRESS &&
|
2011-08-17 04:25:32 +04:00
|
|
|
key_release->time == key_press->time &&
|
|
|
|
key_release->detail == key_press->detail) {
|
2011-04-19 17:23:29 +04:00
|
|
|
/* Don't deliver the held key release
|
|
|
|
* event or the new key press event. */
|
|
|
|
free(event);
|
|
|
|
free(prev);
|
|
|
|
prev = NULL;
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
/* Deliver the held key release now
|
|
|
|
* and fall through and handle the new
|
2011-04-19 20:38:22 +04:00
|
|
|
* event below. */
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_key(&c->base.seat->seat,
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
weston_compositor_get_time(),
|
2012-05-30 19:31:52 +04:00
|
|
|
key_release->detail - 8,
|
2012-06-22 16:21:37 +04:00
|
|
|
WL_KEYBOARD_KEY_STATE_RELEASED,
|
|
|
|
STATE_UPDATE_AUTOMATIC);
|
2011-04-19 17:23:29 +04:00
|
|
|
free(prev);
|
|
|
|
prev = NULL;
|
|
|
|
break;
|
|
|
|
}
|
2011-04-19 20:38:22 +04:00
|
|
|
|
|
|
|
case XCB_FOCUS_IN:
|
|
|
|
/* assert event is keymap_notify */
|
|
|
|
focus_in = (xcb_focus_in_event_t *) prev;
|
|
|
|
keymap_notify = (xcb_keymap_notify_event_t *) event;
|
|
|
|
c->keys.size = 0;
|
|
|
|
for (i = 0; i < ARRAY_LENGTH(keymap_notify->keys) * 8; i++) {
|
|
|
|
set = keymap_notify->keys[i >> 3] &
|
|
|
|
(1 << (i & 7));
|
|
|
|
if (set) {
|
|
|
|
k = wl_array_add(&c->keys, sizeof *k);
|
|
|
|
*k = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
output = x11_compositor_find_output(c, focus_in->event);
|
2012-06-22 16:21:29 +04:00
|
|
|
/* Unfortunately the state only comes with the enter
|
|
|
|
* event, rather than with the focus event. I'm not
|
|
|
|
* sure of the exact semantics around it and whether
|
|
|
|
* we can ensure that we get both? */
|
|
|
|
notify_keyboard_focus_in(&c->base.seat->seat, &c->keys,
|
|
|
|
STATE_UPDATE_AUTOMATIC);
|
2011-04-19 20:38:22 +04:00
|
|
|
|
|
|
|
free(prev);
|
|
|
|
prev = NULL;
|
|
|
|
break;
|
|
|
|
|
2011-04-19 17:23:29 +04:00
|
|
|
default:
|
|
|
|
/* No previous event held */
|
|
|
|
break;
|
2011-04-15 23:48:07 +04:00
|
|
|
}
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
switch (event->response_type & ~0x80) {
|
|
|
|
case XCB_KEY_PRESS:
|
|
|
|
key_press = (xcb_key_press_event_t *) event;
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_key(&c->base.seat->seat,
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
weston_compositor_get_time(),
|
2012-05-30 19:31:52 +04:00
|
|
|
key_press->detail - 8,
|
2012-06-22 16:21:37 +04:00
|
|
|
WL_KEYBOARD_KEY_STATE_PRESSED,
|
2012-06-22 16:21:39 +04:00
|
|
|
c->has_xkb ? STATE_UPDATE_NONE :
|
|
|
|
STATE_UPDATE_AUTOMATIC);
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
|
|
|
case XCB_KEY_RELEASE:
|
2012-06-22 16:21:36 +04:00
|
|
|
/* If we don't have XKB, we need to use the lame
|
|
|
|
* autorepeat detection above. */
|
|
|
|
if (!c->has_xkb) {
|
|
|
|
prev = event;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
key_release = (xcb_key_press_event_t *) event;
|
|
|
|
notify_key(&c->base.seat->seat,
|
|
|
|
weston_compositor_get_time(),
|
|
|
|
key_release->detail - 8,
|
2012-06-22 16:21:37 +04:00
|
|
|
WL_KEYBOARD_KEY_STATE_RELEASED,
|
2012-06-22 16:21:39 +04:00
|
|
|
STATE_UPDATE_NONE);
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
|
|
|
case XCB_BUTTON_PRESS:
|
2011-12-08 19:03:17 +04:00
|
|
|
x11_compositor_deliver_button_event(c, event, 1);
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
|
|
|
case XCB_BUTTON_RELEASE:
|
2011-12-08 19:03:17 +04:00
|
|
|
x11_compositor_deliver_button_event(c, event, 0);
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
|
|
|
case XCB_MOTION_NOTIFY:
|
|
|
|
motion_notify = (xcb_motion_notify_event_t *) event;
|
2011-07-21 21:22:13 +04:00
|
|
|
output = x11_compositor_find_output(c, motion_notify->event);
|
2012-05-09 20:19:04 +04:00
|
|
|
x = wl_fixed_from_int(output->base.x + motion_notify->event_x);
|
|
|
|
y = wl_fixed_from_int(output->base.y + motion_notify->event_y);
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_motion(&c->base.seat->seat,
|
2012-05-09 20:19:04 +04:00
|
|
|
weston_compositor_get_time(), x, y);
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case XCB_EXPOSE:
|
2012-06-20 08:35:59 +04:00
|
|
|
expose = (xcb_expose_event_t *) event;
|
|
|
|
output = x11_compositor_find_output(c, expose->window);
|
|
|
|
weston_output_schedule_repaint(&output->base);
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
2010-07-07 17:51:11 +04:00
|
|
|
|
|
|
|
case XCB_ENTER_NOTIFY:
|
2011-01-27 04:35:07 +03:00
|
|
|
enter_notify = (xcb_enter_notify_event_t *) event;
|
2011-02-08 19:59:53 +03:00
|
|
|
if (enter_notify->state >= Button1Mask)
|
|
|
|
break;
|
2011-01-27 04:35:07 +03:00
|
|
|
output = x11_compositor_find_output(c, enter_notify->event);
|
2012-05-09 20:19:04 +04:00
|
|
|
x = wl_fixed_from_int(output->base.x + enter_notify->event_x);
|
|
|
|
y = wl_fixed_from_int(output->base.y + enter_notify->event_y);
|
2012-05-31 23:27:47 +04:00
|
|
|
/* XXX notify_modifiers() */
|
2012-05-09 20:19:04 +04:00
|
|
|
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_pointer_focus(&c->base.seat->seat,
|
2012-05-09 20:19:04 +04:00
|
|
|
&output->base, x, y);
|
2010-07-07 17:51:11 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case XCB_LEAVE_NOTIFY:
|
2011-01-27 04:35:07 +03:00
|
|
|
enter_notify = (xcb_enter_notify_event_t *) event;
|
2011-02-08 19:59:53 +03:00
|
|
|
if (enter_notify->state >= Button1Mask)
|
|
|
|
break;
|
2011-07-21 21:22:13 +04:00
|
|
|
output = x11_compositor_find_output(c, enter_notify->event);
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_pointer_focus(&c->base.seat->seat, NULL, 0, 0);
|
2010-07-07 17:51:11 +04:00
|
|
|
break;
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
case XCB_CLIENT_MESSAGE:
|
|
|
|
client_message = (xcb_client_message_event_t *) event;
|
|
|
|
atom = client_message->data.data32[0];
|
|
|
|
if (atom == c->atom.wm_delete_window)
|
2010-12-02 00:43:56 +03:00
|
|
|
wl_display_terminate(c->base.wl_display);
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
|
|
|
|
2011-01-27 19:57:19 +03:00
|
|
|
case XCB_FOCUS_IN:
|
|
|
|
focus_in = (xcb_focus_in_event_t *) event;
|
|
|
|
if (focus_in->mode == XCB_NOTIFY_MODE_WHILE_GRABBED)
|
|
|
|
break;
|
|
|
|
|
2011-04-19 20:38:22 +04:00
|
|
|
prev = event;
|
2011-01-27 19:57:19 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
case XCB_FOCUS_OUT:
|
|
|
|
focus_in = (xcb_focus_in_event_t *) event;
|
2011-12-19 23:36:50 +04:00
|
|
|
if (focus_in->mode == XCB_NOTIFY_MODE_WHILE_GRABBED ||
|
|
|
|
focus_in->mode == XCB_NOTIFY_MODE_UNGRAB)
|
2011-01-27 19:57:19 +03:00
|
|
|
break;
|
2012-06-22 16:21:29 +04:00
|
|
|
notify_keyboard_focus_out(&c->base.seat->seat);
|
2011-01-27 19:57:19 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-06-22 16:21:39 +04:00
|
|
|
#ifdef HAVE_XCB_XKB
|
|
|
|
if (c->has_xkb &&
|
|
|
|
(event->response_type & ~0x80) == c->xkb_event_base) {
|
|
|
|
xcb_xkb_state_notify_event_t *state =
|
|
|
|
(xcb_xkb_state_notify_event_t *) event;
|
|
|
|
if (state->xkbType == XCB_XKB_STATE_NOTIFY)
|
|
|
|
update_xkb_state(c, state);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-06-06 01:08:23 +04:00
|
|
|
count++;
|
2011-04-19 17:23:29 +04:00
|
|
|
if (prev != event)
|
2011-04-15 23:48:07 +04:00
|
|
|
free (event);
|
|
|
|
}
|
|
|
|
|
2011-04-19 17:23:29 +04:00
|
|
|
switch (prev ? prev->response_type & ~0x80 : 0x80) {
|
|
|
|
case XCB_KEY_RELEASE:
|
|
|
|
key_release = (xcb_key_press_event_t *) prev;
|
2012-05-16 21:45:18 +04:00
|
|
|
notify_key(&c->base.seat->seat,
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
weston_compositor_get_time(),
|
2012-05-30 19:31:52 +04:00
|
|
|
key_release->detail - 8,
|
2012-06-22 16:21:37 +04:00
|
|
|
WL_KEYBOARD_KEY_STATE_RELEASED,
|
|
|
|
STATE_UPDATE_AUTOMATIC);
|
2011-04-19 17:23:29 +04:00
|
|
|
free(prev);
|
|
|
|
prev = NULL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2011-01-27 19:57:19 +03:00
|
|
|
}
|
2011-04-21 22:51:44 +04:00
|
|
|
|
2012-06-06 01:08:23 +04:00
|
|
|
return count;
|
2011-04-21 22:51:44 +04:00
|
|
|
}
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
#define F(field) offsetof(struct x11_compositor, field)
|
|
|
|
|
|
|
|
static void
|
|
|
|
x11_compositor_get_resources(struct x11_compositor *c)
|
|
|
|
{
|
|
|
|
static const struct { const char *name; int offset; } atoms[] = {
|
|
|
|
{ "WM_PROTOCOLS", F(atom.wm_protocols) },
|
|
|
|
{ "WM_NORMAL_HINTS", F(atom.wm_normal_hints) },
|
|
|
|
{ "WM_SIZE_HINTS", F(atom.wm_size_hints) },
|
|
|
|
{ "WM_DELETE_WINDOW", F(atom.wm_delete_window) },
|
2011-01-26 22:02:31 +03:00
|
|
|
{ "WM_CLASS", F(atom.wm_class) },
|
2010-06-14 19:54:00 +04:00
|
|
|
{ "_NET_WM_NAME", F(atom.net_wm_name) },
|
2011-01-26 22:37:07 +03:00
|
|
|
{ "_NET_WM_ICON", F(atom.net_wm_icon) },
|
2011-06-18 12:20:54 +04:00
|
|
|
{ "_NET_WM_STATE", F(atom.net_wm_state) },
|
|
|
|
{ "_NET_WM_STATE_FULLSCREEN", F(atom.net_wm_state_fullscreen) },
|
2011-01-26 22:02:31 +03:00
|
|
|
{ "STRING", F(atom.string) },
|
2010-06-14 19:54:00 +04:00
|
|
|
{ "UTF8_STRING", F(atom.utf8_string) },
|
2011-01-26 22:37:07 +03:00
|
|
|
{ "CARDINAL", F(atom.cardinal) },
|
2012-05-01 23:37:10 +04:00
|
|
|
{ "_XKB_RULES_NAMES", F(atom.xkb_names) },
|
2010-06-14 19:54:00 +04:00
|
|
|
};
|
|
|
|
|
2011-12-23 22:33:45 +04:00
|
|
|
xcb_intern_atom_cookie_t cookies[ARRAY_LENGTH(atoms)];
|
2010-06-14 19:54:00 +04:00
|
|
|
xcb_intern_atom_reply_t *reply;
|
|
|
|
xcb_pixmap_t pixmap;
|
|
|
|
xcb_gc_t gc;
|
2012-03-30 19:52:39 +04:00
|
|
|
unsigned int i;
|
2010-06-14 19:54:00 +04:00
|
|
|
uint8_t data[] = { 0, 0, 0, 0 };
|
|
|
|
|
2011-12-23 22:33:45 +04:00
|
|
|
for (i = 0; i < ARRAY_LENGTH(atoms); i++)
|
2010-06-14 19:54:00 +04:00
|
|
|
cookies[i] = xcb_intern_atom (c->conn, 0,
|
|
|
|
strlen(atoms[i].name),
|
|
|
|
atoms[i].name);
|
|
|
|
|
2011-12-23 22:33:45 +04:00
|
|
|
for (i = 0; i < ARRAY_LENGTH(atoms); i++) {
|
2010-06-14 19:54:00 +04:00
|
|
|
reply = xcb_intern_atom_reply (c->conn, cookies[i], NULL);
|
|
|
|
*(xcb_atom_t *) ((char *) c + atoms[i].offset) = reply->atom;
|
|
|
|
free(reply);
|
|
|
|
}
|
|
|
|
|
|
|
|
pixmap = xcb_generate_id(c->conn);
|
|
|
|
gc = xcb_generate_id(c->conn);
|
|
|
|
xcb_create_pixmap(c->conn, 1, pixmap, c->screen->root, 1, 1);
|
|
|
|
xcb_create_gc(c->conn, gc, pixmap, 0, NULL);
|
|
|
|
xcb_put_image(c->conn, XCB_IMAGE_FORMAT_XY_PIXMAP,
|
|
|
|
pixmap, gc, 1, 1, 0, 0, 0, 32, sizeof data, data);
|
|
|
|
c->null_cursor = xcb_generate_id(c->conn);
|
|
|
|
xcb_create_cursor (c->conn, c->null_cursor,
|
|
|
|
pixmap, pixmap, 0, 0, 0, 0, 0, 0, 1, 1);
|
|
|
|
xcb_free_gc(c->conn, gc);
|
|
|
|
xcb_free_pixmap(c->conn, pixmap);
|
|
|
|
}
|
|
|
|
|
2010-12-02 00:52:15 +03:00
|
|
|
static void
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
x11_destroy(struct weston_compositor *ec)
|
2010-12-02 00:52:15 +03:00
|
|
|
{
|
2012-01-03 13:58:34 +04:00
|
|
|
struct x11_compositor *compositor = (struct x11_compositor *)ec;
|
|
|
|
|
|
|
|
wl_event_source_remove(compositor->xcb_source);
|
|
|
|
x11_input_destroy(compositor);
|
|
|
|
|
2012-01-03 20:29:15 +04:00
|
|
|
weston_compositor_shutdown(ec); /* destroys outputs, too */
|
2012-01-03 13:58:34 +04:00
|
|
|
|
|
|
|
x11_compositor_fini_egl(compositor);
|
2011-08-30 00:52:23 +04:00
|
|
|
|
2012-01-03 13:58:34 +04:00
|
|
|
XCloseDisplay(compositor->dpy);
|
2010-12-02 00:52:15 +03:00
|
|
|
free(ec);
|
|
|
|
}
|
|
|
|
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
static struct weston_compositor *
|
2011-06-18 12:20:54 +04:00
|
|
|
x11_compositor_create(struct wl_display *display,
|
2012-06-01 19:11:10 +04:00
|
|
|
int width, int height, int count, int fullscreen,
|
2012-06-07 16:07:05 +04:00
|
|
|
int no_input,
|
2012-06-01 19:14:02 +04:00
|
|
|
int argc, char *argv[], const char *config_file)
|
2010-06-14 19:54:00 +04:00
|
|
|
{
|
|
|
|
struct x11_compositor *c;
|
|
|
|
xcb_screen_iterator_t s;
|
2011-07-21 21:22:13 +04:00
|
|
|
int i, x;
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2012-06-09 00:45:33 +04:00
|
|
|
weston_log("initializing x11 backend\n");
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
c = malloc(sizeof *c);
|
|
|
|
if (c == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
memset(c, 0, sizeof *c);
|
2011-02-20 21:58:42 +03:00
|
|
|
|
|
|
|
c->dpy = XOpenDisplay(NULL);
|
2011-04-06 20:05:40 +04:00
|
|
|
if (c->dpy == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2011-02-20 21:58:42 +03:00
|
|
|
c->conn = XGetXCBConnection(c->dpy);
|
2011-03-25 16:06:37 +03:00
|
|
|
XSetEventQueueOwner(c->dpy, XCBOwnsEventQueue);
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
if (xcb_connection_has_error(c->conn))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
s = xcb_setup_roots_iterator(xcb_get_setup(c->conn));
|
|
|
|
c->screen = s.data;
|
2011-01-27 19:57:19 +03:00
|
|
|
wl_array_init(&c->keys);
|
2010-06-14 19:54:00 +04:00
|
|
|
|
|
|
|
x11_compositor_get_resources(c);
|
|
|
|
|
2010-08-09 22:43:33 +04:00
|
|
|
c->base.wl_display = display;
|
2010-11-10 03:42:35 +03:00
|
|
|
if (x11_compositor_init_egl(c) < 0)
|
2010-11-23 05:24:39 +03:00
|
|
|
return NULL;
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2011-01-15 00:20:21 +03:00
|
|
|
c->base.destroy = x11_destroy;
|
|
|
|
|
2010-06-14 19:54:00 +04:00
|
|
|
/* Can't init base class until we have a current egl context */
|
2012-06-01 19:14:02 +04:00
|
|
|
if (weston_compositor_init(&c->base, display, argc, argv,
|
|
|
|
config_file) < 0)
|
2010-06-15 05:03:11 +04:00
|
|
|
return NULL;
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2012-06-22 16:21:34 +04:00
|
|
|
if (x11_input_create(c, no_input) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
2011-07-21 21:22:13 +04:00
|
|
|
for (i = 0, x = 0; i < count; i++) {
|
|
|
|
if (x11_compositor_create_output(c, x, 0, width, height,
|
2012-06-07 16:07:05 +04:00
|
|
|
fullscreen, no_input) < 0)
|
2011-07-21 21:22:13 +04:00
|
|
|
return NULL;
|
|
|
|
x += width;
|
|
|
|
}
|
2010-06-14 19:54:00 +04:00
|
|
|
|
|
|
|
c->xcb_source =
|
2012-03-12 09:18:24 +04:00
|
|
|
wl_event_loop_add_fd(c->base.input_loop,
|
|
|
|
xcb_get_file_descriptor(c->conn),
|
2010-06-14 19:54:00 +04:00
|
|
|
WL_EVENT_READABLE,
|
|
|
|
x11_compositor_handle_event, c);
|
2011-04-22 20:18:13 +04:00
|
|
|
wl_event_source_check(c->xcb_source);
|
2010-06-14 19:54:00 +04:00
|
|
|
|
|
|
|
return &c->base;
|
|
|
|
}
|
2011-05-03 06:09:20 +04:00
|
|
|
|
Rename wayland-compositor to weston
This rename addresses a few problems around the split between core
Wayland and the wayland-demos repository.
1) Initially, we had one big repository with protocol code, sample
compositor and sample clients. We split that repository to make it
possible to implement the protocol without pulling in the sample/demo
code. At this point, the compositor is more than just a "demo" and
wayland-demos doesn't send the right message. The sample compositor
is a useful, self-contained project in it's own right, and we want to
move away from the "demos" label.
2) Another problem is that the wayland-demos compositor is often
called "the wayland compsitor", but it's really just one possible
compositor. Existing X11 compositors are expected to add Wayland
support and then gradually phase out/modularize the X11 support, for
example. Conversely, it's hard to talk about the wayland-demos
compositor specifically as opposed to, eg, the wayland protocol or a
wayland compositor in general.
We are also renaming the repo to weston, and the compositor
subdirectory to src/, to emphasize that the main "output" is the
compositor.
2012-01-03 19:29:47 +04:00
|
|
|
WL_EXPORT struct weston_compositor *
|
2012-06-01 19:14:02 +04:00
|
|
|
backend_init(struct wl_display *display, int argc, char *argv[],
|
|
|
|
const char *config_file)
|
2011-05-03 06:09:20 +04:00
|
|
|
{
|
2012-03-12 05:05:57 +04:00
|
|
|
int width = 1024, height = 640, fullscreen = 0, count = 1;
|
2012-06-07 16:07:05 +04:00
|
|
|
int no_input = 0;
|
2011-05-03 06:09:20 +04:00
|
|
|
|
2012-03-12 05:05:57 +04:00
|
|
|
const struct weston_option x11_options[] = {
|
|
|
|
{ WESTON_OPTION_INTEGER, "width", 0, &width },
|
|
|
|
{ WESTON_OPTION_INTEGER, "height", 0, &height },
|
|
|
|
{ WESTON_OPTION_BOOLEAN, "fullscreen", 0, &fullscreen },
|
|
|
|
{ WESTON_OPTION_INTEGER, "output-count", 0, &count },
|
2012-06-07 16:07:05 +04:00
|
|
|
{ WESTON_OPTION_BOOLEAN, "no-input", 0, &no_input },
|
2011-06-18 12:20:54 +04:00
|
|
|
};
|
2012-03-12 05:05:57 +04:00
|
|
|
|
|
|
|
parse_options(x11_options, ARRAY_LENGTH(x11_options), argc, argv);
|
2011-05-03 06:09:20 +04:00
|
|
|
|
2011-07-21 21:22:13 +04:00
|
|
|
return x11_compositor_create(display,
|
2012-06-01 19:11:10 +04:00
|
|
|
width, height, count, fullscreen,
|
2012-06-07 16:07:05 +04:00
|
|
|
no_input,
|
2012-06-01 19:14:02 +04:00
|
|
|
argc, argv, config_file);
|
2011-05-03 06:09:20 +04:00
|
|
|
}
|