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 <stdio.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>
|
2011-02-20 21:58:42 +03:00
|
|
|
#include <X11/Xlib.h>
|
|
|
|
#include <X11/Xlib-xcb.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"
|
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
|
|
|
|
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;
|
|
|
|
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;
|
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 {
|
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_input_device base;
|
2010-06-14 19:54:00 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-11-23 05:24:39 +03:00
|
|
|
static int
|
2010-06-14 19:54:00 +04:00
|
|
|
x11_input_create(struct x11_compositor *c)
|
|
|
|
{
|
|
|
|
struct x11_input *input;
|
|
|
|
|
|
|
|
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);
|
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_input_device_init(&input->base, &c->base);
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2010-12-08 17:48:52 +03:00
|
|
|
c->base.input_device = &input->base.input_device;
|
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)
|
|
|
|
{
|
|
|
|
struct x11_input *input = container_of(compositor->base.input_device,
|
|
|
|
struct x11_input,
|
|
|
|
base.input_device);
|
|
|
|
|
2012-01-03 20:29:15 +04:00
|
|
|
weston_input_device_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;
|
2010-07-29 06:52:28 +04:00
|
|
|
const char *extensions;
|
2011-03-02 12:07:59 +03:00
|
|
|
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
|
|
|
|
2011-02-20 21:58:42 +03:00
|
|
|
c->base.display = eglGetDisplay(c->dpy);
|
2010-06-14 19:54:00 +04:00
|
|
|
if (c->base.display == NULL) {
|
|
|
|
fprintf(stderr, "failed to create display\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!eglInitialize(c->base.display, &major, &minor)) {
|
|
|
|
fprintf(stderr, "failed to initialize display\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-07-29 06:52:28 +04:00
|
|
|
extensions = eglQueryString(c->base.display, EGL_EXTENSIONS);
|
2011-11-01 18:37:41 +04:00
|
|
|
if (!strstr(extensions, "EGL_KHR_surfaceless_gles2")) {
|
|
|
|
fprintf(stderr, "EGL_KHR_surfaceless_gles2 not available\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)) {
|
|
|
|
fprintf(stderr, "failed to bind EGL_OPENGL_ES_API\n");
|
|
|
|
return -1;
|
|
|
|
}
|
2011-03-02 12:07:59 +03:00
|
|
|
if (!eglChooseConfig(c->base.display, config_attribs,
|
|
|
|
&c->base.config, 1, &n) || n == 0) {
|
|
|
|
fprintf(stderr, "failed to choose config: %d\n", n);
|
|
|
|
return -1;
|
|
|
|
}
|
2010-11-23 05:24:39 +03:00
|
|
|
|
2011-03-02 12:07:59 +03:00
|
|
|
c->base.context = eglCreateContext(c->base.display, c->base.config,
|
2010-07-29 07:47:54 +04:00
|
|
|
EGL_NO_CONTEXT, context_attribs);
|
2010-06-14 19:54:00 +04:00
|
|
|
if (c->base.context == NULL) {
|
|
|
|
fprintf(stderr, "failed to create context\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!eglMakeCurrent(c->base.display, EGL_NO_SURFACE,
|
|
|
|
EGL_NO_SURFACE, c->base.context)) {
|
|
|
|
fprintf(stderr, "failed to make context current\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-03 13:58:34 +04:00
|
|
|
static void
|
|
|
|
x11_compositor_fini_egl(struct x11_compositor *compositor)
|
|
|
|
{
|
|
|
|
eglMakeCurrent(compositor->base.display,
|
|
|
|
EGL_NO_SURFACE, EGL_NO_SURFACE,
|
|
|
|
EGL_NO_CONTEXT);
|
|
|
|
|
|
|
|
eglTerminate(compositor->base.display);
|
|
|
|
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-01-26 08:47:45 +04:00
|
|
|
if (!eglMakeCurrent(compositor->base.display, output->egl_surface,
|
|
|
|
output->egl_surface, compositor->base.context)) {
|
2011-03-11 18:39:20 +03:00
|
|
|
fprintf(stderr, "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-01-26 08:47:45 +04:00
|
|
|
eglSwapBuffers(compositor->base.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);
|
|
|
|
|
|
|
|
eglDestroySurface(compositor->base.display, output->egl_surface);
|
|
|
|
|
|
|
|
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,
|
2011-06-18 12:20:54 +04:00
|
|
|
int width, int height, int fullscreen)
|
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;
|
|
|
|
uint32_t values[2] = {
|
|
|
|
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_EXPOSURE |
|
2010-07-07 17:51:11 +04:00
|
|
|
XCB_EVENT_MASK_STRUCTURE_NOTIFY |
|
|
|
|
XCB_EVENT_MASK_ENTER_WINDOW |
|
2011-01-27 19:57:19 +03:00
|
|
|
XCB_EVENT_MASK_LEAVE_WINDOW |
|
|
|
|
XCB_EVENT_MASK_KEYMAP_STATE |
|
|
|
|
XCB_EVENT_MASK_FOCUS_CHANGE,
|
2010-06-14 19:54:00 +04:00
|
|
|
0
|
|
|
|
};
|
|
|
|
|
|
|
|
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;
|
|
|
|
output->mode.refresh = 60;
|
|
|
|
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 =
|
|
|
|
eglCreateWindowSurface(c->base.display, c->base.config,
|
|
|
|
output->window, NULL);
|
|
|
|
if (!output->egl_surface) {
|
|
|
|
fprintf(stderr, "failed to create window surface\n");
|
2010-06-14 19:54:00 +04:00
|
|
|
return -1;
|
2011-03-02 12:07:59 +03:00
|
|
|
}
|
|
|
|
if (!eglMakeCurrent(c->base.display, output->egl_surface,
|
|
|
|
output->egl_surface, c->base.context)) {
|
|
|
|
fprintf(stderr, "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-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;
|
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);
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
int button;
|
|
|
|
|
|
|
|
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:
|
|
|
|
case 5:
|
|
|
|
case 6:
|
|
|
|
case 7:
|
|
|
|
/* X11 sends wheel events as buttons events. But
|
|
|
|
* linux input treats as REL_WHEEL, therefore not
|
|
|
|
* button type at all. When we update the input
|
|
|
|
* protocol and get the 'axis' event, we'll send
|
|
|
|
* scroll events as axis events. */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
notify_button(c->base.input_device,
|
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(), button, state);
|
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;
|
2010-06-14 19:54:00 +04:00
|
|
|
xcb_atom_t atom;
|
2011-01-27 19:57:19 +03:00
|
|
|
uint32_t *k;
|
|
|
|
int i, set;
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2011-04-19 17:23:29 +04:00
|
|
|
prev = NULL;
|
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:
|
|
|
|
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. */
|
2011-04-19 17:23:29 +04:00
|
|
|
notify_key(c->base.input_device,
|
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(),
|
2011-04-19 17:23:29 +04:00
|
|
|
key_release->detail - 8, 0);
|
|
|
|
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);
|
|
|
|
notify_keyboard_focus(c->base.input_device,
|
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(),
|
2011-04-19 20:38:22 +04:00
|
|
|
&output->base, &c->keys);
|
|
|
|
|
|
|
|
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;
|
|
|
|
notify_key(c->base.input_device,
|
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(),
|
2011-10-12 01:23:02 +04:00
|
|
|
key_press->detail - 8, 1);
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
|
|
|
case XCB_KEY_RELEASE:
|
2011-04-19 17:23:29 +04:00
|
|
|
prev = event;
|
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);
|
2010-06-14 19:54:00 +04:00
|
|
|
notify_motion(c->base.input_device,
|
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(),
|
2011-07-21 21:22:13 +04:00
|
|
|
output->base.x + motion_notify->event_x,
|
|
|
|
output->base.y + motion_notify->event_y);
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case XCB_EXPOSE:
|
2011-03-02 12:07:59 +03:00
|
|
|
/* FIXME: schedule output repaint */
|
|
|
|
/* output = x11_compositor_find_output(c, expose->window); */
|
2010-06-14 19:54:00 +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
|
|
|
weston_compositor_schedule_repaint(&c->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);
|
|
|
|
notify_pointer_focus(c->base.input_device,
|
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(),
|
2011-01-27 04:35:07 +03:00
|
|
|
&output->base,
|
2011-07-21 21:22:13 +04:00
|
|
|
output->base.x + enter_notify->event_x,
|
|
|
|
output->base.y + enter_notify->event_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);
|
2011-01-27 04:35:07 +03:00
|
|
|
notify_pointer_focus(c->base.input_device,
|
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(),
|
2011-01-27 04:35:07 +03:00
|
|
|
NULL,
|
2011-07-21 21:22:13 +04:00
|
|
|
output->base.x + enter_notify->event_x,
|
|
|
|
output->base.y + enter_notify->event_y);
|
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;
|
|
|
|
notify_keyboard_focus(c->base.input_device,
|
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(),
|
2011-04-23 21:04:11 +04:00
|
|
|
NULL, NULL);
|
2011-01-27 19:57:19 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2010-06-14 19:54:00 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
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;
|
2011-04-15 23:48:07 +04:00
|
|
|
notify_key(c->base.input_device,
|
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(),
|
2011-10-12 01:23:02 +04:00
|
|
|
key_release->detail - 8, 0);
|
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
|
|
|
|
2011-04-22 20:18:13 +04:00
|
|
|
return event != NULL;
|
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) },
|
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;
|
|
|
|
int i;
|
|
|
|
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,
|
2011-07-21 21:22:13 +04:00
|
|
|
int width, int height, int count, int fullscreen)
|
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
|
|
|
|
|
|
|
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 */
|
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
|
|
|
if (weston_compositor_init(&c->base, display) < 0)
|
2010-06-15 05:03:11 +04:00
|
|
|
return NULL;
|
2010-06-14 19:54:00 +04:00
|
|
|
|
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,
|
|
|
|
fullscreen) < 0)
|
|
|
|
return NULL;
|
|
|
|
x += width;
|
|
|
|
}
|
2010-06-14 19:54:00 +04:00
|
|
|
|
2010-11-23 05:24:39 +03:00
|
|
|
if (x11_input_create(c) < 0)
|
|
|
|
return NULL;
|
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-03-12 05:05:57 +04:00
|
|
|
backend_init(struct wl_display *display, int argc, char *argv[])
|
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;
|
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 },
|
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,
|
|
|
|
width, height, count, fullscreen);
|
2011-05-03 06:09:20 +04:00
|
|
|
}
|