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
|
|
|
/*
|
|
|
|
* Copyright © 2008-2011 Kristian Høgsberg
|
2018-04-19 14:20:01 +03:00
|
|
|
* Copyright © 2012, 2017, 2018 Collabora, Ltd.
|
|
|
|
* Copyright © 2017, 2018 General Electric Company
|
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
|
|
|
*
|
2015-06-12 01:35:43 +03:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
|
|
* a copy of this software and associated documentation files (the
|
|
|
|
* "Software"), to deal in the Software without restriction, including
|
|
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
* the following conditions:
|
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
|
|
|
*
|
2015-06-12 01:35:43 +03:00
|
|
|
* The above copyright notice and this permission notice (including the
|
|
|
|
* next paragraph) shall be included in all copies or substantial
|
|
|
|
* portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
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
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _WAYLAND_SYSTEM_COMPOSITOR_H_
|
|
|
|
#define _WAYLAND_SYSTEM_COMPOSITOR_H_
|
|
|
|
|
2013-03-28 21:02:42 +04:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2014-10-03 22:13:42 +04:00
|
|
|
#include <stdbool.h>
|
2016-07-19 14:16:27 +03:00
|
|
|
#include <stdint.h>
|
2014-09-24 06:08:45 +04:00
|
|
|
#include <time.h>
|
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
|
|
|
#include <pixman.h>
|
2012-05-01 23:37:10 +04:00
|
|
|
#include <xkbcommon/xkbcommon.h>
|
2013-08-07 06:27:04 +04:00
|
|
|
|
|
|
|
#define WL_HIDE_DEPRECATED
|
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
|
|
|
#include <wayland-server.h>
|
|
|
|
|
2013-02-16 05:53:20 +04:00
|
|
|
#include "matrix.h"
|
|
|
|
#include "config-parser.h"
|
2013-08-08 05:57:04 +04:00
|
|
|
#include "zalloc.h"
|
compositor: Implement JSON-timeline logging
Logging is activated and deactivated with the debug key binding 't'.
When activated, it creates a new log file, where it records the events.
The log file contains events and detailed object information entries in
JSON format, and is meant to be parsed in sequence from beginning to the
end.
The emitted events are mostly related to the output repaint cycle, like
when repaint begins, is submitted to GPU, and when it completes on a
vblank. This is recorded per-output. Also some per-surface events are
recorded, including when surface damage is flushed.
To reduce the log size, events refer to objects like outputs and
surfaces by id numbers. Detailed object information is emitted only as
needed: on the first object occurrence, and afterwards only if
weston_timeline_object::force_refresh asks for it.
The detailed information for surfaces includes the string returned by
weston_surface::get_label. Therefore it is important to set
weston_timeline_object::force_refresh = 1 whenever the string would
change, so that the new details get recorded.
A rudimentary parser and SVG generator can be found at:
https://github.com/ppaalanen/wesgr
The timeline logs can answer questions including:
- How does the compositor repaint cycle work timing-wise?
- When was the vblank deadline missed?
- What is the latency from surface commit to showing the new content on
screen?
- How long does it take to process the scenegraph?
v2: weston_surface::get_description renamed to get_label.
v3: reafctor a bit into fprint_quoted_string().
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
2014-11-12 16:09:24 +03:00
|
|
|
#include "timeline-object.h"
|
2012-03-30 16:45:40 +04:00
|
|
|
|
2016-08-12 11:41:34 +03:00
|
|
|
struct weston_geometry {
|
|
|
|
int32_t x, y;
|
|
|
|
int32_t width, height;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct weston_position {
|
|
|
|
int32_t x, y;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct weston_size {
|
|
|
|
int32_t width, height;
|
|
|
|
};
|
|
|
|
|
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_transform {
|
|
|
|
struct weston_matrix matrix;
|
2012-01-06 16:10:06 +04:00
|
|
|
struct wl_list link;
|
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
|
|
|
};
|
|
|
|
|
2018-02-26 17:18:29 +03:00
|
|
|
/** 2D device coordinates normalized to [0, 1] range */
|
|
|
|
struct weston_point2d_device_normalized {
|
|
|
|
double x;
|
|
|
|
double y;
|
|
|
|
};
|
|
|
|
|
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_surface;
|
2013-06-21 05:38:23 +04:00
|
|
|
struct weston_buffer;
|
2012-04-19 17:18:18 +04:00
|
|
|
struct shell_surface;
|
2012-05-16 21:45:18 +04:00
|
|
|
struct weston_seat;
|
2012-04-20 23:37:33 +04:00
|
|
|
struct weston_output;
|
2012-08-10 18:47:22 +04:00
|
|
|
struct input_method;
|
2015-08-05 22:48:11 +03:00
|
|
|
struct weston_pointer;
|
2014-09-29 22:18:40 +04:00
|
|
|
struct linux_dmabuf_buffer;
|
2016-06-02 21:48:09 +03:00
|
|
|
struct weston_recorder;
|
2016-07-22 12:56:31 +03:00
|
|
|
struct weston_pointer_constraint;
|
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
|
|
|
|
2012-05-30 19:31:42 +04:00
|
|
|
enum weston_keyboard_modifier {
|
|
|
|
MODIFIER_CTRL = (1 << 0),
|
|
|
|
MODIFIER_ALT = (1 << 1),
|
|
|
|
MODIFIER_SUPER = (1 << 2),
|
2012-06-28 22:13:10 +04:00
|
|
|
MODIFIER_SHIFT = (1 << 3),
|
2012-05-30 19:31:42 +04:00
|
|
|
};
|
|
|
|
|
2014-08-28 20:44:09 +04:00
|
|
|
enum weston_keyboard_locks {
|
|
|
|
WESTON_NUM_LOCK = (1 << 0),
|
|
|
|
WESTON_CAPS_LOCK = (1 << 1),
|
|
|
|
};
|
|
|
|
|
2012-05-30 19:31:45 +04:00
|
|
|
enum weston_led {
|
|
|
|
LED_NUM_LOCK = (1 << 0),
|
|
|
|
LED_CAPS_LOCK = (1 << 1),
|
|
|
|
LED_SCROLL_LOCK = (1 << 2),
|
|
|
|
};
|
|
|
|
|
compositor-drm: Add aspect-ratio parsing support
The flag bits 19-22 of the connector modes, provide the aspect-ratio
information. This information can be stored in flags bits of the
weston mode structure, so that it can used for setting a mode with a
particular aspect-ratio.
Currently, DRM layer supports aspect-ratio with atomic-modesetting by
default. For legacy modeset path, the user-space needs to set the
drm client cap for aspect-ratio, if it wants aspect-ratio information
in modes.
This patch:
- preserves aspect-ratio flags from kernel video modes and
accommodates it in wayland mode.
- uses aspect-ratio to pick the appropriate mode during modeset.
- changes the mode format in configuration file weston.ini to
accommodate aspect-ratio information as:
WIDTHxHEIGHT@REFRESH-RATE ASPECT-RATIO
The aspect-ratio can take the following values :
4:3, 16:9, 64:27, 256:135.
v2: As per recommendation from Pekka Paalanen, Quentin Glidic,
Daniel Stone, dropped the aspect-ratio info from wayland protocol,
thereby avoiding exposure of aspect-ratio to the client.
v3: As suggested by Pekka Paalanen, added aspect_ratio field to store
aspect-ratio information from the drm. Also added drm client
capability for aspect-ratio, as recommended by Daniel Vetter.
v4: Minor modifications and fixes as suggested by Pekka Paalanen.
v5: Rebased, fixed some styling issues, and added aspect-ratio
information while printing weston_modes.
v6: Moved the man pages changes to a different patch. Minor
reorganization of code as suggested by Pekka Paalanen.
Signed-off-by: Ankit Nautiyal <ankit.k.nautiyal@intel.com>
[Pekka: replace ARRAY_SIZE with ARRAY_LENGTH]
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
2097-03-18 21:54:57 +03:00
|
|
|
enum weston_mode_aspect_ratio {
|
|
|
|
/** The picture aspect ratio values, for the aspect_ratio field of
|
|
|
|
* weston_mode. The values here, are taken from
|
|
|
|
* DRM_MODE_PICTURE_ASPECT_* from drm_mode.h.
|
|
|
|
*/
|
|
|
|
WESTON_MODE_PIC_AR_NONE = 0, /* DRM_MODE_PICTURE_ASPECT_NONE */
|
|
|
|
WESTON_MODE_PIC_AR_4_3 = 1, /* DRM_MODE_PICTURE_ASPECT_4_3 */
|
|
|
|
WESTON_MODE_PIC_AR_16_9 = 2, /* DRM_MODE_PICTURE_ASPECT_16_9 */
|
|
|
|
WESTON_MODE_PIC_AR_64_27 = 3, /* DRM_MODE_PICTURE_ASPECT_64_27 */
|
|
|
|
WESTON_MODE_PIC_AR_256_135 = 4, /* DRM_MODE_PICTURE_ASPECT_256_135*/
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
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 {
|
|
|
|
uint32_t flags;
|
compositor-drm: Add aspect-ratio parsing support
The flag bits 19-22 of the connector modes, provide the aspect-ratio
information. This information can be stored in flags bits of the
weston mode structure, so that it can used for setting a mode with a
particular aspect-ratio.
Currently, DRM layer supports aspect-ratio with atomic-modesetting by
default. For legacy modeset path, the user-space needs to set the
drm client cap for aspect-ratio, if it wants aspect-ratio information
in modes.
This patch:
- preserves aspect-ratio flags from kernel video modes and
accommodates it in wayland mode.
- uses aspect-ratio to pick the appropriate mode during modeset.
- changes the mode format in configuration file weston.ini to
accommodate aspect-ratio information as:
WIDTHxHEIGHT@REFRESH-RATE ASPECT-RATIO
The aspect-ratio can take the following values :
4:3, 16:9, 64:27, 256:135.
v2: As per recommendation from Pekka Paalanen, Quentin Glidic,
Daniel Stone, dropped the aspect-ratio info from wayland protocol,
thereby avoiding exposure of aspect-ratio to the client.
v3: As suggested by Pekka Paalanen, added aspect_ratio field to store
aspect-ratio information from the drm. Also added drm client
capability for aspect-ratio, as recommended by Daniel Vetter.
v4: Minor modifications and fixes as suggested by Pekka Paalanen.
v5: Rebased, fixed some styling issues, and added aspect-ratio
information while printing weston_modes.
v6: Moved the man pages changes to a different patch. Minor
reorganization of code as suggested by Pekka Paalanen.
Signed-off-by: Ankit Nautiyal <ankit.k.nautiyal@intel.com>
[Pekka: replace ARRAY_SIZE with ARRAY_LENGTH]
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
2097-03-18 21:54:57 +03:00
|
|
|
enum weston_mode_aspect_ratio aspect_ratio;
|
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
|
|
|
int32_t width, height;
|
|
|
|
uint32_t refresh;
|
|
|
|
struct wl_list link;
|
|
|
|
};
|
|
|
|
|
2012-06-11 23:07:51 +04:00
|
|
|
struct weston_animation {
|
|
|
|
void (*frame)(struct weston_animation *animation,
|
2017-11-16 19:20:52 +03:00
|
|
|
struct weston_output *output,
|
|
|
|
const struct timespec *time);
|
2012-06-11 23:07:51 +04:00
|
|
|
int frame_counter;
|
|
|
|
struct wl_list link;
|
|
|
|
};
|
|
|
|
|
2013-06-17 17:15:22 +04:00
|
|
|
enum {
|
|
|
|
WESTON_SPRING_OVERSHOOT,
|
|
|
|
WESTON_SPRING_CLAMP,
|
|
|
|
WESTON_SPRING_BOUNCE
|
|
|
|
};
|
|
|
|
|
2012-06-11 23:07:51 +04:00
|
|
|
struct weston_spring {
|
|
|
|
double k;
|
|
|
|
double friction;
|
|
|
|
double current;
|
|
|
|
double target;
|
|
|
|
double previous;
|
2013-06-17 17:23:14 +04:00
|
|
|
double min, max;
|
2017-11-16 19:20:52 +03:00
|
|
|
struct timespec timestamp;
|
2013-06-17 17:15:22 +04:00
|
|
|
uint32_t clip;
|
2012-06-11 23:07:51 +04:00
|
|
|
};
|
|
|
|
|
2012-02-23 01:21:41 +04:00
|
|
|
struct weston_output_zoom {
|
2015-07-23 22:55:12 +03:00
|
|
|
bool active;
|
2012-02-23 01:21:41 +04:00
|
|
|
float increment;
|
|
|
|
float level;
|
2012-06-11 23:07:51 +04:00
|
|
|
float max_level;
|
2012-02-23 01:21:41 +04:00
|
|
|
float trans_x, trans_y;
|
2015-10-07 20:14:18 +03:00
|
|
|
struct {
|
|
|
|
double x, y;
|
|
|
|
} current;
|
2015-07-23 22:55:15 +03:00
|
|
|
struct weston_seat *seat;
|
2012-06-11 23:07:51 +04:00
|
|
|
struct weston_animation animation_z;
|
|
|
|
struct weston_spring spring_z;
|
2013-11-15 02:42:51 +04:00
|
|
|
struct wl_listener motion_listener;
|
2012-02-23 01:21:41 +04:00
|
|
|
};
|
|
|
|
|
2012-02-29 21:53:50 +04:00
|
|
|
/* bit compatible with drm definitions. */
|
|
|
|
enum dpms_enum {
|
|
|
|
WESTON_DPMS_ON,
|
|
|
|
WESTON_DPMS_STANDBY,
|
|
|
|
WESTON_DPMS_SUSPEND,
|
|
|
|
WESTON_DPMS_OFF
|
|
|
|
};
|
|
|
|
|
2017-03-24 16:39:24 +03:00
|
|
|
/** Represents a monitor
|
|
|
|
*
|
|
|
|
* This object represents a monitor (hardware backends like DRM) or a window
|
|
|
|
* (windowed nested backends).
|
|
|
|
*/
|
|
|
|
struct weston_head {
|
2017-08-14 16:05:35 +03:00
|
|
|
struct weston_compositor *compositor; /**< owning compositor */
|
|
|
|
struct wl_list compositor_link; /**< in weston_compositor::head_list */
|
2017-10-10 11:21:58 +03:00
|
|
|
struct wl_signal destroy_signal; /**< destroy callbacks */
|
2017-08-14 16:05:35 +03:00
|
|
|
|
2017-03-27 12:24:34 +03:00
|
|
|
struct weston_output *output; /**< the output driving this head */
|
2017-03-28 16:27:25 +03:00
|
|
|
struct wl_list output_link; /**< in weston_output::head_list */
|
2017-03-27 12:24:34 +03:00
|
|
|
|
2017-03-27 12:15:38 +03:00
|
|
|
struct wl_list resource_list; /**< wl_output protocol objects */
|
|
|
|
struct wl_global *global; /**< wl_output global */
|
|
|
|
|
2017-03-24 16:39:24 +03:00
|
|
|
int32_t mm_width; /**< physical image width in mm */
|
|
|
|
int32_t mm_height; /**< physical image height in mm */
|
|
|
|
char *make; /**< monitor manufacturer (PNP ID) */
|
|
|
|
char *model; /**< monitor model */
|
|
|
|
char *serial_number; /**< monitor serial */
|
|
|
|
uint32_t subpixel; /**< enum wl_output_subpixel */
|
|
|
|
bool connection_internal; /**< embedded monitor (e.g. laptop) */
|
2017-08-28 14:11:02 +03:00
|
|
|
bool device_changed; /**< monitor information has changed */
|
2017-08-14 14:43:13 +03:00
|
|
|
|
|
|
|
char *name; /**< head name, e.g. connector name */
|
2017-08-14 15:45:14 +03:00
|
|
|
bool connected; /**< is physically connected */
|
2017-03-24 16:39:24 +03: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
|
|
|
struct weston_output {
|
2012-04-20 06:50:08 +04:00
|
|
|
uint32_t id;
|
2013-05-02 13:10:04 +04:00
|
|
|
char *name;
|
2012-04-20 06:50:08 +04:00
|
|
|
|
2017-11-07 11:15:01 +03:00
|
|
|
/** Matches the lifetime from the user perspective */
|
|
|
|
struct wl_signal user_destroy_signal;
|
|
|
|
|
2012-11-13 22:10:18 +04:00
|
|
|
void *renderer_state;
|
|
|
|
|
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 wl_list link;
|
|
|
|
struct weston_compositor *compositor;
|
2014-10-16 19:55:21 +04:00
|
|
|
|
|
|
|
/** From global to output buffer coordinates. */
|
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_matrix matrix;
|
2015-03-24 19:36:13 +03:00
|
|
|
/** From output buffer to global coordinates. */
|
|
|
|
struct weston_matrix inverse_matrix;
|
2014-10-16 19:55:21 +04:00
|
|
|
|
2012-06-09 05:40:53 +04:00
|
|
|
struct wl_list animation_list;
|
2012-08-18 11:04:05 +04:00
|
|
|
int32_t x, y, width, height;
|
2015-02-23 14:54:49 +03:00
|
|
|
|
|
|
|
/** Output area in global coordinates, simple rect */
|
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
|
|
|
pixman_region32_t region;
|
2015-02-23 14:54:49 +03:00
|
|
|
|
2012-11-16 19:23:52 +04:00
|
|
|
pixman_region32_t previous_damage;
|
2017-03-01 14:34:06 +03:00
|
|
|
|
|
|
|
/** True if damage has occurred since the last repaint for this output;
|
|
|
|
* if set, a repaint will eventually occur. */
|
|
|
|
bool repaint_needed;
|
2017-03-03 19:59:42 +03:00
|
|
|
|
2018-06-05 04:37:06 +03:00
|
|
|
/** Used only between repaint_begin and repaint_cancel. */
|
|
|
|
bool repainted;
|
|
|
|
|
2017-03-03 19:59:42 +03:00
|
|
|
/** State of the repaint loop */
|
|
|
|
enum {
|
|
|
|
REPAINT_NOT_SCHEDULED = 0, /**< idle; no repaint will occur */
|
|
|
|
REPAINT_BEGIN_FROM_IDLE, /**< start_repaint_loop scheduled */
|
|
|
|
REPAINT_SCHEDULED, /**< repaint is scheduled to occur */
|
|
|
|
REPAINT_AWAITING_COMPLETION, /**< last repaint not yet finished */
|
|
|
|
} repaint_status;
|
|
|
|
|
2017-03-01 14:34:08 +03:00
|
|
|
/** If repaint_status is REPAINT_SCHEDULED, contains the time the
|
|
|
|
* next repaint should be run */
|
|
|
|
struct timespec next_repaint;
|
|
|
|
|
2017-10-26 14:33:59 +03:00
|
|
|
/** For cancelling the idle_repaint callback on output destruction. */
|
|
|
|
struct wl_event_source *idle_repaint_source;
|
|
|
|
|
2012-02-23 01:21:41 +04:00
|
|
|
struct weston_output_zoom zoom;
|
|
|
|
int dirty;
|
2012-05-24 20:29:46 +04:00
|
|
|
struct wl_signal frame_signal;
|
2017-11-07 11:15:01 +03:00
|
|
|
struct wl_signal destroy_signal; /**< sent when disabled */
|
2013-12-14 00:10:53 +04:00
|
|
|
int move_x, move_y;
|
2017-11-16 19:20:53 +03:00
|
|
|
struct timespec frame_time; /* presentation timestamp */
|
2014-09-24 06:08:47 +04:00
|
|
|
uint64_t msc; /* media stream counter */
|
2012-08-03 23:45:23 +04:00
|
|
|
int disable_planes;
|
2013-12-14 00:10:55 +04:00
|
|
|
int destroying;
|
2014-09-24 06:08:46 +04:00
|
|
|
struct wl_list feedback_list;
|
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
|
|
|
|
2012-08-10 18:09:20 +04:00
|
|
|
uint32_t transform;
|
2013-09-19 01:56:36 +04:00
|
|
|
int32_t native_scale;
|
2013-09-19 01:56:35 +04:00
|
|
|
int32_t current_scale;
|
2013-09-19 01:56:36 +04:00
|
|
|
int32_t original_scale;
|
2013-05-22 16:41:37 +04:00
|
|
|
|
2013-09-19 01:56:36 +04:00
|
|
|
struct weston_mode *native_mode;
|
2013-09-19 01:56:35 +04:00
|
|
|
struct weston_mode *current_mode;
|
|
|
|
struct weston_mode *original_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
|
|
|
struct wl_list mode_list;
|
|
|
|
|
2017-03-28 16:27:25 +03:00
|
|
|
struct wl_list head_list; /**< List of driven weston_heads */
|
2017-03-24 16:39:24 +03:00
|
|
|
|
2013-04-06 01:07:11 +04:00
|
|
|
void (*start_repaint_loop)(struct weston_output *output);
|
2013-10-22 19:11:26 +04:00
|
|
|
int (*repaint)(struct weston_output *output,
|
2017-03-01 14:34:10 +03:00
|
|
|
pixman_region32_t *damage,
|
|
|
|
void *repaint_data);
|
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
|
|
|
void (*destroy)(struct weston_output *output);
|
2017-03-01 14:34:10 +03:00
|
|
|
void (*assign_planes)(struct weston_output *output, void *repaint_data);
|
2012-04-17 13:20:47 +04:00
|
|
|
int (*switch_mode)(struct weston_output *output, struct weston_mode *mode);
|
2012-02-29 21:53:50 +04:00
|
|
|
|
2012-03-13 02:40:09 +04:00
|
|
|
/* backlight values are on 0-255 range, where higher is brighter */
|
2013-05-24 04:30:26 +04:00
|
|
|
int32_t backlight_current;
|
2012-02-29 21:53:50 +04:00
|
|
|
void (*set_backlight)(struct weston_output *output, uint32_t value);
|
|
|
|
void (*set_dpms)(struct weston_output *output, enum dpms_enum level);
|
2013-05-02 00:52:12 +04:00
|
|
|
|
|
|
|
uint16_t gamma_size;
|
|
|
|
void (*set_gamma)(struct weston_output *output,
|
|
|
|
uint16_t size,
|
|
|
|
uint16_t *r,
|
|
|
|
uint16_t *g,
|
|
|
|
uint16_t *b);
|
compositor: Implement JSON-timeline logging
Logging is activated and deactivated with the debug key binding 't'.
When activated, it creates a new log file, where it records the events.
The log file contains events and detailed object information entries in
JSON format, and is meant to be parsed in sequence from beginning to the
end.
The emitted events are mostly related to the output repaint cycle, like
when repaint begins, is submitted to GPU, and when it completes on a
vblank. This is recorded per-output. Also some per-surface events are
recorded, including when surface damage is flushed.
To reduce the log size, events refer to objects like outputs and
surfaces by id numbers. Detailed object information is emitted only as
needed: on the first object occurrence, and afterwards only if
weston_timeline_object::force_refresh asks for it.
The detailed information for surfaces includes the string returned by
weston_surface::get_label. Therefore it is important to set
weston_timeline_object::force_refresh = 1 whenever the string would
change, so that the new details get recorded.
A rudimentary parser and SVG generator can be found at:
https://github.com/ppaalanen/wesgr
The timeline logs can answer questions including:
- How does the compositor repaint cycle work timing-wise?
- When was the vblank deadline missed?
- What is the latency from surface commit to showing the new content on
screen?
- How long does it take to process the scenegraph?
v2: weston_surface::get_description renamed to get_label.
v3: reafctor a bit into fprint_quoted_string().
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
2014-11-12 16:09:24 +03:00
|
|
|
|
|
|
|
struct weston_timeline_object timeline;
|
2016-09-30 15:11:02 +03:00
|
|
|
|
2017-03-30 14:56:22 +03:00
|
|
|
bool enabled; /**< is in the output_list, not pending list */
|
2016-09-30 15:11:02 +03:00
|
|
|
int scale;
|
|
|
|
|
|
|
|
int (*enable)(struct weston_output *output);
|
|
|
|
int (*disable)(struct weston_output *output);
|
2017-08-16 10:39:17 +03:00
|
|
|
|
|
|
|
/** Attach a head in the backend
|
|
|
|
*
|
|
|
|
* @param output The output to attach to.
|
|
|
|
* @param head The head to attach.
|
|
|
|
* @return 0 on success, -1 on failure.
|
|
|
|
*
|
|
|
|
* Do anything necessary to account for a new head being attached to
|
|
|
|
* the output, and check any conditions possible. On failure, both
|
|
|
|
* the head and the output must be left as before the call.
|
|
|
|
*
|
|
|
|
* Libweston core will add the head to the head_list after a successful
|
|
|
|
* call.
|
|
|
|
*/
|
|
|
|
int (*attach_head)(struct weston_output *output,
|
|
|
|
struct weston_head *head);
|
|
|
|
|
|
|
|
/** Detach a head in the backend
|
|
|
|
*
|
|
|
|
* @param output The output to detach from.
|
|
|
|
* @param head The head to detach.
|
|
|
|
*
|
|
|
|
* Do any clean-up necessary to detach this head from the output.
|
|
|
|
* The head has already been removed from the output's head_list.
|
|
|
|
*/
|
|
|
|
void (*detach_head)(struct weston_output *output,
|
|
|
|
struct weston_head *head);
|
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
|
|
|
};
|
|
|
|
|
2014-10-05 23:39:14 +04:00
|
|
|
enum weston_pointer_motion_mask {
|
|
|
|
WESTON_POINTER_MOTION_ABS = 1 << 0,
|
|
|
|
WESTON_POINTER_MOTION_REL = 1 << 1,
|
2014-10-22 01:51:29 +04:00
|
|
|
WESTON_POINTER_MOTION_REL_UNACCEL = 1 << 2,
|
2014-10-05 23:39:14 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct weston_pointer_motion_event {
|
|
|
|
uint32_t mask;
|
2017-11-24 19:01:46 +03:00
|
|
|
struct timespec time;
|
2014-10-05 23:39:14 +04:00
|
|
|
double x;
|
|
|
|
double y;
|
|
|
|
double dx;
|
|
|
|
double dy;
|
2014-10-22 01:51:29 +04:00
|
|
|
double dx_unaccel;
|
|
|
|
double dy_unaccel;
|
2014-10-05 23:39:14 +04:00
|
|
|
};
|
|
|
|
|
2016-01-18 08:58:17 +03:00
|
|
|
struct weston_pointer_axis_event {
|
|
|
|
uint32_t axis;
|
2016-03-22 18:44:54 +03:00
|
|
|
double value;
|
2016-01-18 09:38:22 +03:00
|
|
|
bool has_discrete;
|
|
|
|
int32_t discrete;
|
2016-01-18 08:58:17 +03:00
|
|
|
};
|
|
|
|
|
2013-05-07 06:15:05 +04:00
|
|
|
struct weston_pointer_grab;
|
|
|
|
struct weston_pointer_grab_interface {
|
2013-05-09 06:02:59 +04:00
|
|
|
void (*focus)(struct weston_pointer_grab *grab);
|
2017-11-24 19:01:46 +03:00
|
|
|
void (*motion)(struct weston_pointer_grab *grab,
|
|
|
|
const struct timespec *time,
|
2014-10-05 23:39:14 +04:00
|
|
|
struct weston_pointer_motion_event *event);
|
2013-05-07 06:15:05 +04:00
|
|
|
void (*button)(struct weston_pointer_grab *grab,
|
2017-11-16 19:20:55 +03:00
|
|
|
const struct timespec *time,
|
|
|
|
uint32_t button, uint32_t state);
|
2014-10-04 18:28:29 +04:00
|
|
|
void (*axis)(struct weston_pointer_grab *grab,
|
2017-11-16 19:20:56 +03:00
|
|
|
const struct timespec *time,
|
2016-01-18 08:58:17 +03:00
|
|
|
struct weston_pointer_axis_event *event);
|
2016-01-18 09:38:22 +03:00
|
|
|
void (*axis_source)(struct weston_pointer_grab *grab, uint32_t source);
|
|
|
|
void (*frame)(struct weston_pointer_grab *grab);
|
2013-10-26 01:18:05 +04:00
|
|
|
void (*cancel)(struct weston_pointer_grab *grab);
|
2013-04-18 23:07:39 +04:00
|
|
|
};
|
|
|
|
|
2013-05-07 06:15:05 +04:00
|
|
|
struct weston_pointer_grab {
|
|
|
|
const struct weston_pointer_grab_interface *interface;
|
|
|
|
struct weston_pointer *pointer;
|
2013-04-18 23:07:39 +04:00
|
|
|
};
|
|
|
|
|
2013-04-18 23:25:39 +04:00
|
|
|
struct weston_keyboard_grab;
|
|
|
|
struct weston_keyboard_grab_interface {
|
2017-11-16 19:20:57 +03:00
|
|
|
void (*key)(struct weston_keyboard_grab *grab,
|
|
|
|
const struct timespec *time, uint32_t key, uint32_t state);
|
2013-04-18 23:25:39 +04:00
|
|
|
void (*modifiers)(struct weston_keyboard_grab *grab, uint32_t serial,
|
2013-04-18 23:07:39 +04:00
|
|
|
uint32_t mods_depressed, uint32_t mods_latched,
|
|
|
|
uint32_t mods_locked, uint32_t group);
|
2013-10-26 01:18:05 +04:00
|
|
|
void (*cancel)(struct weston_keyboard_grab *grab);
|
2013-04-18 23:07:39 +04:00
|
|
|
};
|
|
|
|
|
2013-04-18 23:25:39 +04:00
|
|
|
struct weston_keyboard_grab {
|
|
|
|
const struct weston_keyboard_grab_interface *interface;
|
|
|
|
struct weston_keyboard *keyboard;
|
2013-04-18 23:07:39 +04:00
|
|
|
};
|
|
|
|
|
2013-05-07 06:19:57 +04:00
|
|
|
struct weston_touch_grab;
|
|
|
|
struct weston_touch_grab_interface {
|
|
|
|
void (*down)(struct weston_touch_grab *grab,
|
2017-11-16 19:20:58 +03:00
|
|
|
const struct timespec *time,
|
2013-04-18 23:07:39 +04:00
|
|
|
int touch_id,
|
|
|
|
wl_fixed_t sx,
|
|
|
|
wl_fixed_t sy);
|
2013-05-07 06:19:57 +04:00
|
|
|
void (*up)(struct weston_touch_grab *grab,
|
2017-11-16 19:20:59 +03:00
|
|
|
const struct timespec *time,
|
2013-04-18 23:07:39 +04:00
|
|
|
int touch_id);
|
2013-05-07 06:19:57 +04:00
|
|
|
void (*motion)(struct weston_touch_grab *grab,
|
2017-11-16 19:21:00 +03:00
|
|
|
const struct timespec *time,
|
2013-04-18 23:07:39 +04:00
|
|
|
int touch_id,
|
|
|
|
wl_fixed_t sx,
|
|
|
|
wl_fixed_t sy);
|
2014-04-12 11:39:51 +04:00
|
|
|
void (*frame)(struct weston_touch_grab *grab);
|
2013-10-26 01:18:05 +04:00
|
|
|
void (*cancel)(struct weston_touch_grab *grab);
|
2013-04-18 23:07:39 +04:00
|
|
|
};
|
|
|
|
|
2013-05-07 06:19:57 +04:00
|
|
|
struct weston_touch_grab {
|
|
|
|
const struct weston_touch_grab_interface *interface;
|
|
|
|
struct weston_touch *touch;
|
2013-04-18 23:07:39 +04:00
|
|
|
};
|
|
|
|
|
2013-07-26 03:09:37 +04:00
|
|
|
struct weston_data_offer {
|
2013-06-14 19:07:55 +04:00
|
|
|
struct wl_resource *resource;
|
2013-07-26 02:52:14 +04:00
|
|
|
struct weston_data_source *source;
|
2013-04-18 23:07:39 +04:00
|
|
|
struct wl_listener source_destroy_listener;
|
2016-01-19 01:52:12 +03:00
|
|
|
uint32_t dnd_actions;
|
|
|
|
enum wl_data_device_manager_dnd_action preferred_dnd_action;
|
|
|
|
bool in_ask;
|
2013-04-18 23:07:39 +04:00
|
|
|
};
|
|
|
|
|
2013-07-26 02:52:14 +04:00
|
|
|
struct weston_data_source {
|
2013-06-14 19:07:55 +04:00
|
|
|
struct wl_resource *resource;
|
|
|
|
struct wl_signal destroy_signal;
|
2013-04-18 23:07:39 +04:00
|
|
|
struct wl_array mime_types;
|
2016-01-15 23:14:23 +03:00
|
|
|
struct weston_data_offer *offer;
|
|
|
|
struct weston_seat *seat;
|
|
|
|
bool accepted;
|
2016-01-19 01:52:12 +03:00
|
|
|
bool actions_set;
|
|
|
|
uint32_t dnd_actions;
|
|
|
|
enum wl_data_device_manager_dnd_action current_dnd_action;
|
2016-01-15 23:14:26 +03:00
|
|
|
enum wl_data_device_manager_dnd_action compositor_action;
|
2013-04-18 23:07:39 +04:00
|
|
|
|
2013-07-26 02:52:14 +04:00
|
|
|
void (*accept)(struct weston_data_source *source,
|
2013-04-18 23:07:39 +04:00
|
|
|
uint32_t serial, const char *mime_type);
|
2013-07-26 02:52:14 +04:00
|
|
|
void (*send)(struct weston_data_source *source,
|
2013-04-18 23:07:39 +04:00
|
|
|
const char *mime_type, int32_t fd);
|
2013-07-26 02:52:14 +04:00
|
|
|
void (*cancel)(struct weston_data_source *source);
|
2013-04-18 23:07:39 +04:00
|
|
|
};
|
|
|
|
|
2015-07-22 07:05:38 +03:00
|
|
|
struct weston_pointer_client {
|
|
|
|
struct wl_list link;
|
|
|
|
struct wl_client *client;
|
|
|
|
struct wl_list pointer_resources;
|
2014-10-22 23:21:17 +04:00
|
|
|
struct wl_list relative_pointer_resources;
|
2015-07-22 07:05:38 +03:00
|
|
|
};
|
|
|
|
|
2013-05-07 06:15:05 +04:00
|
|
|
struct weston_pointer {
|
2013-05-07 07:19:49 +04:00
|
|
|
struct weston_seat *seat;
|
2013-04-18 23:07:39 +04:00
|
|
|
|
2015-07-22 07:05:38 +03:00
|
|
|
struct wl_list pointer_clients;
|
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view *focus;
|
2015-07-22 07:05:38 +03:00
|
|
|
struct weston_pointer_client *focus_client;
|
2013-04-18 23:07:39 +04:00
|
|
|
uint32_t focus_serial;
|
2013-11-20 21:00:24 +04:00
|
|
|
struct wl_listener focus_view_listener;
|
|
|
|
struct wl_listener focus_resource_listener;
|
2013-04-18 23:07:39 +04:00
|
|
|
struct wl_signal focus_signal;
|
2013-11-15 02:42:50 +04:00
|
|
|
struct wl_signal motion_signal;
|
2016-07-22 12:52:58 +03:00
|
|
|
struct wl_signal destroy_signal;
|
2013-04-18 23:07:39 +04:00
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view *sprite;
|
2013-05-08 23:02:05 +04:00
|
|
|
struct wl_listener sprite_destroy_listener;
|
|
|
|
int32_t hotspot_x, hotspot_y;
|
|
|
|
|
2013-05-07 06:15:05 +04:00
|
|
|
struct weston_pointer_grab *grab;
|
|
|
|
struct weston_pointer_grab default_grab;
|
2013-04-18 23:07:39 +04:00
|
|
|
wl_fixed_t grab_x, grab_y;
|
|
|
|
uint32_t grab_button;
|
|
|
|
uint32_t grab_serial;
|
2017-11-16 19:20:55 +03:00
|
|
|
struct timespec grab_time;
|
2013-04-18 23:07:39 +04:00
|
|
|
|
|
|
|
wl_fixed_t x, y;
|
2014-02-06 05:14:42 +04:00
|
|
|
wl_fixed_t sx, sy;
|
2013-04-18 23:07:39 +04:00
|
|
|
uint32_t button_count;
|
2014-01-29 20:47:51 +04:00
|
|
|
|
|
|
|
struct wl_listener output_destroy_listener;
|
2018-02-20 15:06:26 +03:00
|
|
|
|
|
|
|
struct wl_list timestamps_list;
|
2013-04-18 23:07:39 +04:00
|
|
|
};
|
|
|
|
|
2017-11-29 04:42:47 +03:00
|
|
|
/** libinput style calibration matrix
|
|
|
|
*
|
|
|
|
* See https://wayland.freedesktop.org/libinput/doc/latest/absolute_axes.html
|
|
|
|
* and libinput_device_config_calibration_set_matrix().
|
|
|
|
*/
|
|
|
|
struct weston_touch_device_matrix {
|
|
|
|
float m[6];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct weston_touch_device;
|
|
|
|
|
|
|
|
/** Operations for a calibratable touchscreen */
|
|
|
|
struct weston_touch_device_ops {
|
|
|
|
/** Get the associated output if existing. */
|
|
|
|
struct weston_output *(*get_output)(struct weston_touch_device *device);
|
|
|
|
|
|
|
|
/** Get the name of the associated head if existing. */
|
|
|
|
const char *
|
|
|
|
(*get_calibration_head_name)(struct weston_touch_device *device);
|
|
|
|
|
|
|
|
/** Retrieve the current calibration matrix. */
|
|
|
|
void (*get_calibration)(struct weston_touch_device *device,
|
|
|
|
struct weston_touch_device_matrix *cal);
|
|
|
|
|
|
|
|
/** Set a new calibration matrix. */
|
|
|
|
void (*set_calibration)(struct weston_touch_device *device,
|
|
|
|
const struct weston_touch_device_matrix *cal);
|
|
|
|
};
|
|
|
|
|
input: introduce touch event mode for calibrator
In addition to the normal touch event processing mode, introduce a new
mode for calibrating a touchscreen input device.
In the calibration mode, normal touch event processing is skipped, and
the raw events are forwarded to the calibrator instead. The calibrator
is not yet implemented, so the calls will be added in a following patch.
To switch between modes, two functions are added, one for entering each
mode. The mode switch happens only when no touches are down on any touch
device, to avoid confusing touch grabs and clients. To realise this, the
state machine has four states: prepare and actual state for both normal
and calibrator modes.
At this point nothing will attempt to change the touch event mode.
The new calibrator mode is necessary, because when calibrating a
touchscreen, the touch events must be routed to the calibration client
directly. The touch coordinates are expected to be wrong, so they cannot
go through the normal focus surface picking. The calibrator code also
cannot use the normal touch grab interface, because it needs to be able
to distinguish between different physical touch input devices, even if
they are part of the same weston_seat. This requirement makes
calibration special enough to warrant the new mode, a sort of "super
grab".
Co-developed by Louis-Francis and Pekka.
Signed-off-by: Louis-Francis Ratté-Boulianne <lfrb@collabora.com>
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
v1 Tested-by: Matt Hoosier <matt.hoosier@gmail.com>
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
2017-11-29 04:42:47 +03:00
|
|
|
enum weston_touch_mode {
|
|
|
|
/** Normal touch event handling */
|
|
|
|
WESTON_TOUCH_MODE_NORMAL,
|
|
|
|
|
|
|
|
/** Prepare moving to WESTON_TOUCH_MODE_CALIB.
|
|
|
|
*
|
|
|
|
* Move to WESTON_TOUCH_MODE_CALIB as soon as no touches are down on
|
|
|
|
* any seat. Until then, all touch events are routed normally.
|
|
|
|
*/
|
|
|
|
WESTON_TOUCH_MODE_PREP_CALIB,
|
|
|
|
|
|
|
|
/** Calibration mode
|
|
|
|
*
|
|
|
|
* Only a single weston_touch_device forwards events to the calibrator
|
|
|
|
* all other touch device cause a calibrator "wrong device" event to
|
|
|
|
* be sent.
|
|
|
|
*/
|
|
|
|
WESTON_TOUCH_MODE_CALIB,
|
|
|
|
|
|
|
|
/** Prepare moving to WESTON_TOUCH_MODE_NORMAL.
|
|
|
|
*
|
|
|
|
* Move to WESTON_TOUCH_MODE_NORMAL as soon as no touches are down on
|
|
|
|
* any seat. Until then, touch events are routed as in
|
|
|
|
* WESTON_TOUCH_MODE_CALIB except "wrong device" events are not sent.
|
|
|
|
*/
|
|
|
|
WESTON_TOUCH_MODE_PREP_NORMAL
|
|
|
|
};
|
|
|
|
|
2017-11-29 04:42:47 +03:00
|
|
|
/** Represents a physical touchscreen input device */
|
|
|
|
struct weston_touch_device {
|
|
|
|
char *syspath; /**< unique name */
|
2013-04-18 23:07:39 +04:00
|
|
|
|
2017-11-29 04:42:47 +03:00
|
|
|
struct weston_touch *aggregate; /**< weston_touch this is part of */
|
|
|
|
struct wl_list link; /**< in weston_touch::device_list */
|
|
|
|
struct wl_signal destroy_signal; /**< destroy notifier */
|
|
|
|
|
|
|
|
void *backend_data; /**< backend-specific private */
|
|
|
|
|
|
|
|
const struct weston_touch_device_ops *ops;
|
2017-11-29 04:42:47 +03:00
|
|
|
struct weston_touch_device_matrix saved_calibration;
|
2017-11-29 04:42:47 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Represents a set of touchscreen devices aggregated under a seat */
|
2013-05-07 06:19:57 +04:00
|
|
|
struct weston_touch {
|
2013-05-07 07:19:49 +04:00
|
|
|
struct weston_seat *seat;
|
2013-04-18 23:07:39 +04:00
|
|
|
|
2017-11-29 04:42:47 +03:00
|
|
|
struct wl_list device_list; /* struct weston_touch_device::link */
|
|
|
|
|
2013-04-18 23:07:39 +04:00
|
|
|
struct wl_list resource_list;
|
2013-09-19 20:32:00 +04:00
|
|
|
struct wl_list focus_resource_list;
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view *focus;
|
2013-11-20 21:00:24 +04:00
|
|
|
struct wl_listener focus_view_listener;
|
|
|
|
struct wl_listener focus_resource_listener;
|
2013-04-18 23:07:39 +04:00
|
|
|
uint32_t focus_serial;
|
|
|
|
struct wl_signal focus_signal;
|
|
|
|
|
2013-12-03 01:05:03 +04:00
|
|
|
uint32_t num_tp;
|
|
|
|
|
2013-05-07 06:19:57 +04:00
|
|
|
struct weston_touch_grab *grab;
|
|
|
|
struct weston_touch_grab default_grab;
|
2013-10-03 19:43:06 +04:00
|
|
|
int grab_touch_id;
|
2013-04-18 23:07:39 +04:00
|
|
|
wl_fixed_t grab_x, grab_y;
|
|
|
|
uint32_t grab_serial;
|
2017-11-16 19:20:58 +03:00
|
|
|
struct timespec grab_time;
|
2018-02-20 15:07:03 +03:00
|
|
|
|
|
|
|
struct wl_list timestamps_list;
|
2013-04-18 23:07:39 +04:00
|
|
|
};
|
|
|
|
|
2014-10-05 23:39:14 +04:00
|
|
|
void
|
|
|
|
weston_pointer_motion_to_abs(struct weston_pointer *pointer,
|
|
|
|
struct weston_pointer_motion_event *event,
|
|
|
|
wl_fixed_t *x, wl_fixed_t *y);
|
|
|
|
|
2013-04-18 23:07:39 +04:00
|
|
|
void
|
2017-11-24 19:01:46 +03:00
|
|
|
weston_pointer_send_motion(struct weston_pointer *pointer,
|
|
|
|
const struct timespec *time,
|
2016-08-12 11:41:32 +03:00
|
|
|
struct weston_pointer_motion_event *event);
|
|
|
|
bool
|
|
|
|
weston_pointer_has_focus_resource(struct weston_pointer *pointer);
|
|
|
|
void
|
|
|
|
weston_pointer_send_button(struct weston_pointer *pointer,
|
2017-11-16 19:20:55 +03:00
|
|
|
const struct timespec *time,
|
|
|
|
uint32_t button, uint32_t state_w);
|
2016-08-12 11:41:32 +03:00
|
|
|
void
|
2014-10-04 18:28:29 +04:00
|
|
|
weston_pointer_send_axis(struct weston_pointer *pointer,
|
2017-11-16 19:20:56 +03:00
|
|
|
const struct timespec *time,
|
2016-01-18 08:58:17 +03:00
|
|
|
struct weston_pointer_axis_event *event);
|
2016-01-18 09:38:22 +03:00
|
|
|
void
|
|
|
|
weston_pointer_send_axis_source(struct weston_pointer *pointer,
|
|
|
|
uint32_t source);
|
|
|
|
void
|
|
|
|
weston_pointer_send_frame(struct weston_pointer *pointer);
|
|
|
|
|
2014-10-04 18:28:29 +04:00
|
|
|
void
|
2013-05-07 06:15:05 +04:00
|
|
|
weston_pointer_set_focus(struct weston_pointer *pointer,
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view *view,
|
2013-05-07 06:15:05 +04:00
|
|
|
wl_fixed_t sx, wl_fixed_t sy);
|
2013-04-18 23:07:39 +04:00
|
|
|
void
|
2015-05-11 23:40:11 +03:00
|
|
|
weston_pointer_clear_focus(struct weston_pointer *pointer);
|
|
|
|
void
|
2013-05-07 06:15:05 +04:00
|
|
|
weston_pointer_start_grab(struct weston_pointer *pointer,
|
|
|
|
struct weston_pointer_grab *grab);
|
2013-04-18 23:07:39 +04:00
|
|
|
void
|
2013-05-07 06:15:05 +04:00
|
|
|
weston_pointer_end_grab(struct weston_pointer *pointer);
|
2013-06-25 21:56:41 +04:00
|
|
|
void
|
|
|
|
weston_pointer_clamp(struct weston_pointer *pointer,
|
|
|
|
wl_fixed_t *fx, wl_fixed_t *fy);
|
2013-11-15 02:42:52 +04:00
|
|
|
void
|
|
|
|
weston_pointer_move(struct weston_pointer *pointer,
|
2014-10-05 23:39:14 +04:00
|
|
|
struct weston_pointer_motion_event *event);
|
2013-11-15 02:42:53 +04:00
|
|
|
void
|
|
|
|
weston_pointer_set_default_grab(struct weston_pointer *pointer,
|
|
|
|
const struct weston_pointer_grab_interface *interface);
|
2013-04-18 23:07:39 +04:00
|
|
|
|
2016-07-22 12:56:31 +03:00
|
|
|
void
|
|
|
|
weston_pointer_constraint_destroy(struct weston_pointer_constraint *constraint);
|
|
|
|
|
2013-04-18 23:07:39 +04:00
|
|
|
void
|
2013-04-18 23:25:39 +04:00
|
|
|
weston_keyboard_set_focus(struct weston_keyboard *keyboard,
|
2013-05-08 17:54:37 +04:00
|
|
|
struct weston_surface *surface);
|
2013-04-18 23:07:39 +04:00
|
|
|
void
|
2013-04-18 23:25:39 +04:00
|
|
|
weston_keyboard_start_grab(struct weston_keyboard *device,
|
|
|
|
struct weston_keyboard_grab *grab);
|
2013-04-18 23:07:39 +04:00
|
|
|
void
|
2013-04-18 23:25:39 +04:00
|
|
|
weston_keyboard_end_grab(struct weston_keyboard *keyboard);
|
2014-08-28 20:44:09 +04:00
|
|
|
int
|
|
|
|
/*
|
|
|
|
* 'mask' and 'value' should be a bitwise mask of one or more
|
|
|
|
* valued of the weston_keyboard_locks enum.
|
|
|
|
*/
|
|
|
|
weston_keyboard_set_locks(struct weston_keyboard *keyboard,
|
|
|
|
uint32_t mask, uint32_t value);
|
2013-04-18 23:07:39 +04:00
|
|
|
|
2016-08-12 11:41:32 +03:00
|
|
|
bool
|
|
|
|
weston_keyboard_has_focus_resource(struct weston_keyboard *keyboard);
|
|
|
|
void
|
|
|
|
weston_keyboard_send_key(struct weston_keyboard *keyboard,
|
2017-11-16 19:20:57 +03:00
|
|
|
const struct timespec *time, uint32_t key,
|
2016-08-12 11:41:32 +03:00
|
|
|
enum wl_keyboard_key_state state);
|
|
|
|
void
|
|
|
|
weston_keyboard_send_modifiers(struct weston_keyboard *keyboard,
|
|
|
|
uint32_t serial, uint32_t mods_depressed,
|
|
|
|
uint32_t mods_latched,
|
|
|
|
uint32_t mods_locked, uint32_t group);
|
|
|
|
|
2013-04-18 23:07:39 +04:00
|
|
|
void
|
2015-05-01 00:45:41 +03:00
|
|
|
weston_touch_set_focus(struct weston_touch *touch,
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view *view);
|
2013-07-23 11:51:06 +04:00
|
|
|
void
|
2017-11-29 04:42:47 +03:00
|
|
|
weston_touch_start_grab(struct weston_touch *touch,
|
2013-05-07 06:19:57 +04:00
|
|
|
struct weston_touch_grab *grab);
|
2013-04-18 23:07:39 +04:00
|
|
|
void
|
2013-05-07 06:19:57 +04:00
|
|
|
weston_touch_end_grab(struct weston_touch *touch);
|
2013-04-18 23:07:39 +04:00
|
|
|
|
2016-08-12 11:41:32 +03:00
|
|
|
bool
|
|
|
|
weston_touch_has_focus_resource(struct weston_touch *touch);
|
|
|
|
void
|
2017-11-16 19:20:58 +03:00
|
|
|
weston_touch_send_down(struct weston_touch *touch, const struct timespec *time,
|
2016-08-12 11:41:32 +03:00
|
|
|
int touch_id, wl_fixed_t x, wl_fixed_t y);
|
|
|
|
void
|
2017-11-16 19:20:59 +03:00
|
|
|
weston_touch_send_up(struct weston_touch *touch, const struct timespec *time,
|
|
|
|
int touch_id);
|
2016-08-12 11:41:32 +03:00
|
|
|
void
|
2017-11-16 19:21:00 +03:00
|
|
|
weston_touch_send_motion(struct weston_touch *touch,
|
|
|
|
const struct timespec *time, int touch_id,
|
|
|
|
wl_fixed_t x, wl_fixed_t y);
|
2016-08-12 11:41:32 +03:00
|
|
|
void
|
|
|
|
weston_touch_send_frame(struct weston_touch *touch);
|
|
|
|
|
2017-11-29 04:42:47 +03:00
|
|
|
struct weston_touch_device *
|
|
|
|
weston_touch_create_touch_device(struct weston_touch *touch,
|
|
|
|
const char *syspath,
|
|
|
|
void *backend_data,
|
|
|
|
const struct weston_touch_device_ops *ops);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_touch_device_destroy(struct weston_touch_device *device);
|
|
|
|
|
|
|
|
bool
|
|
|
|
weston_touch_device_can_calibrate(struct weston_touch_device *device);
|
|
|
|
|
2013-04-18 23:07:39 +04:00
|
|
|
void
|
2013-05-07 07:19:49 +04:00
|
|
|
wl_data_device_set_keyboard_focus(struct weston_seat *seat);
|
2013-04-18 23:07:39 +04:00
|
|
|
|
|
|
|
int
|
|
|
|
wl_data_device_manager_init(struct wl_display *display);
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2013-05-07 07:19:49 +04:00
|
|
|
weston_seat_set_selection(struct weston_seat *seat,
|
2013-07-26 02:52:14 +04:00
|
|
|
struct weston_data_source *source, uint32_t serial);
|
2015-05-01 12:59:35 +03:00
|
|
|
void
|
|
|
|
weston_seat_send_selection(struct weston_seat *seat, struct wl_client *client);
|
|
|
|
|
2013-09-05 07:44:26 +04:00
|
|
|
int
|
2013-11-25 14:42:49 +04:00
|
|
|
weston_pointer_start_drag(struct weston_pointer *pointer,
|
2013-09-05 07:44:26 +04:00
|
|
|
struct weston_data_source *source,
|
|
|
|
struct weston_surface *icon,
|
|
|
|
struct wl_client *client);
|
2013-11-25 14:42:49 +04:00
|
|
|
int
|
|
|
|
weston_touch_start_drag(struct weston_touch *touch,
|
|
|
|
struct weston_data_source *source,
|
|
|
|
struct weston_surface *icon,
|
|
|
|
struct wl_client *client);
|
2013-04-18 23:07:39 +04:00
|
|
|
|
2012-05-30 19:32:05 +04:00
|
|
|
struct weston_xkb_info {
|
|
|
|
struct xkb_keymap *keymap;
|
2012-06-01 15:14:06 +04:00
|
|
|
size_t keymap_size;
|
2017-06-28 20:17:46 +03:00
|
|
|
char *keymap_string;
|
2013-09-05 17:31:40 +04:00
|
|
|
int32_t ref_count;
|
2012-06-22 16:21:33 +04:00
|
|
|
xkb_mod_index_t shift_mod;
|
|
|
|
xkb_mod_index_t caps_mod;
|
2012-05-30 19:32:05 +04:00
|
|
|
xkb_mod_index_t ctrl_mod;
|
|
|
|
xkb_mod_index_t alt_mod;
|
2012-06-22 16:21:33 +04:00
|
|
|
xkb_mod_index_t mod2_mod;
|
|
|
|
xkb_mod_index_t mod3_mod;
|
2012-05-30 19:32:05 +04:00
|
|
|
xkb_mod_index_t super_mod;
|
2012-06-22 16:21:33 +04:00
|
|
|
xkb_mod_index_t mod5_mod;
|
2012-05-30 19:32:05 +04:00
|
|
|
xkb_led_index_t num_led;
|
|
|
|
xkb_led_index_t caps_led;
|
|
|
|
xkb_led_index_t scroll_led;
|
|
|
|
};
|
|
|
|
|
2013-01-17 00:26:50 +04:00
|
|
|
struct weston_keyboard {
|
2013-05-07 07:19:49 +04:00
|
|
|
struct weston_seat *seat;
|
2013-04-18 23:25:39 +04:00
|
|
|
|
|
|
|
struct wl_list resource_list;
|
2013-09-19 20:32:00 +04:00
|
|
|
struct wl_list focus_resource_list;
|
2013-05-08 17:54:37 +04:00
|
|
|
struct weston_surface *focus;
|
2013-11-20 21:00:24 +04:00
|
|
|
struct wl_listener focus_resource_listener;
|
2013-04-18 23:25:39 +04:00
|
|
|
uint32_t focus_serial;
|
|
|
|
struct wl_signal focus_signal;
|
|
|
|
|
|
|
|
struct weston_keyboard_grab *grab;
|
|
|
|
struct weston_keyboard_grab default_grab;
|
|
|
|
uint32_t grab_key;
|
|
|
|
uint32_t grab_serial;
|
2017-11-16 19:20:57 +03:00
|
|
|
struct timespec grab_time;
|
2013-04-18 23:25:39 +04:00
|
|
|
|
|
|
|
struct wl_array keys;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
uint32_t mods_depressed;
|
|
|
|
uint32_t mods_latched;
|
|
|
|
uint32_t mods_locked;
|
|
|
|
uint32_t group;
|
|
|
|
} modifiers;
|
2013-01-17 00:26:50 +04:00
|
|
|
|
2013-04-18 23:25:39 +04:00
|
|
|
struct weston_keyboard_grab input_method_grab;
|
2013-01-17 00:26:50 +04:00
|
|
|
struct wl_resource *input_method_resource;
|
2013-12-03 12:14:26 +04:00
|
|
|
|
|
|
|
struct weston_xkb_info *xkb_info;
|
|
|
|
struct {
|
|
|
|
struct xkb_state *state;
|
|
|
|
enum weston_led leds;
|
|
|
|
} xkb_state;
|
|
|
|
struct xkb_keymap *pending_keymap;
|
2018-02-20 15:05:50 +03:00
|
|
|
|
|
|
|
struct wl_list timestamps_list;
|
2013-01-17 00:26:50 +04:00
|
|
|
};
|
|
|
|
|
2012-05-16 21:45:18 +04:00
|
|
|
struct weston_seat {
|
2013-05-07 07:19:49 +04:00
|
|
|
struct wl_list base_resource_list;
|
|
|
|
|
2013-07-09 00:20:31 +04:00
|
|
|
struct wl_global *global;
|
2015-08-01 00:55:32 +03:00
|
|
|
struct weston_pointer *pointer_state;
|
|
|
|
struct weston_keyboard *keyboard_state;
|
|
|
|
struct weston_touch *touch_state;
|
2013-10-18 01:04:05 +04:00
|
|
|
int pointer_device_count;
|
|
|
|
int keyboard_device_count;
|
|
|
|
int touch_device_count;
|
2013-05-07 07:19:49 +04:00
|
|
|
|
2013-06-25 21:56:42 +04:00
|
|
|
struct weston_output *output; /* constraint */
|
|
|
|
|
2013-03-26 00:42:45 +04:00
|
|
|
struct wl_signal destroy_signal;
|
2014-04-03 04:53:45 +04:00
|
|
|
struct wl_signal updated_caps_signal;
|
2012-05-30 19:32:02 +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
|
|
|
struct weston_compositor *compositor;
|
|
|
|
struct wl_list link;
|
2012-05-30 19:31:42 +04:00
|
|
|
enum weston_keyboard_modifier modifier_state;
|
2013-05-08 17:54:37 +04:00
|
|
|
struct weston_surface *saved_kbd_focus;
|
2012-03-16 19:25:11 +04:00
|
|
|
struct wl_listener saved_kbd_focus_listener;
|
2013-05-08 23:27:47 +04:00
|
|
|
struct wl_list drag_resource_list;
|
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
|
|
|
|
2013-05-07 07:19:49 +04:00
|
|
|
uint32_t selection_serial;
|
2013-07-26 02:52:14 +04:00
|
|
|
struct weston_data_source *selection_data_source;
|
2013-05-07 07:19:49 +04:00
|
|
|
struct wl_listener selection_data_source_listener;
|
|
|
|
struct wl_signal selection_signal;
|
|
|
|
|
2012-05-30 19:31:45 +04:00
|
|
|
void (*led_update)(struct weston_seat *ws, enum weston_led leds);
|
|
|
|
|
2012-08-10 18:47:22 +04:00
|
|
|
struct input_method *input_method;
|
2013-05-31 21:09:50 +04:00
|
|
|
char *seat_name;
|
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
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
2015-12-12 00:11:37 +03:00
|
|
|
WESTON_COMPOSITOR_ACTIVE, /* normal rendering and events */
|
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_IDLE, /* shell->unlock called on activity */
|
2013-03-29 16:01:56 +04:00
|
|
|
WESTON_COMPOSITOR_OFFSCREEN, /* no rendering, no frame events */
|
2016-08-30 22:05:01 +03:00
|
|
|
WESTON_COMPOSITOR_SLEEPING /* same as offscreen, but also set dpms
|
|
|
|
* to off */
|
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
|
|
|
};
|
|
|
|
|
2014-07-09 23:12:56 +04:00
|
|
|
struct weston_layer_entry {
|
|
|
|
struct wl_list link;
|
|
|
|
struct weston_layer *layer;
|
|
|
|
};
|
|
|
|
|
2016-12-17 15:40:51 +03:00
|
|
|
/**
|
|
|
|
* Higher value means higher in the stack.
|
|
|
|
*
|
|
|
|
* These values are based on well-known concepts in a classic desktop
|
|
|
|
* environment. Third-party modules based on libweston are encouraged to use
|
|
|
|
* them to integrate better with other projects.
|
|
|
|
*
|
|
|
|
* A fully integrated environment can use any value, based on these or not,
|
|
|
|
* at their discretion.
|
|
|
|
*/
|
|
|
|
enum weston_layer_position {
|
|
|
|
/*
|
|
|
|
* Special value to make the layer invisible and still rendered.
|
|
|
|
* This is used by compositors wanting e.g. minimized surfaces to still
|
|
|
|
* receive frame callbacks.
|
|
|
|
*/
|
|
|
|
WESTON_LAYER_POSITION_HIDDEN = 0x00000000,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There should always be a background layer with a surface covering
|
|
|
|
* the visible area.
|
|
|
|
*
|
|
|
|
* If the compositor handles the background itself, it should use
|
|
|
|
* BACKGROUND.
|
|
|
|
*
|
|
|
|
* If the compositor supports runtime-loadable modules to set the
|
|
|
|
* background, it should put a solid color surface at (BACKGROUND - 1)
|
|
|
|
* and modules must use BACKGROUND.
|
|
|
|
*/
|
|
|
|
WESTON_LAYER_POSITION_BACKGROUND = 0x00000002,
|
|
|
|
|
|
|
|
/* For "desktop widgets" and applications like conky. */
|
|
|
|
WESTON_LAYER_POSITION_BOTTOM_UI = 0x30000000,
|
|
|
|
|
|
|
|
/* For regular applications, only one layer should have this value
|
|
|
|
* to ensure proper stacking control. */
|
|
|
|
WESTON_LAYER_POSITION_NORMAL = 0x50000000,
|
|
|
|
|
|
|
|
/* For desktop UI, like panels. */
|
|
|
|
WESTON_LAYER_POSITION_UI = 0x80000000,
|
|
|
|
|
|
|
|
/* For fullscreen applications that should cover UI. */
|
|
|
|
WESTON_LAYER_POSITION_FULLSCREEN = 0xb0000000,
|
|
|
|
|
|
|
|
/* For special UI like on-screen keyboard that fullscreen applications
|
|
|
|
* will need. */
|
|
|
|
WESTON_LAYER_POSITION_TOP_UI = 0xe0000000,
|
|
|
|
|
|
|
|
/* For the lock surface. */
|
|
|
|
WESTON_LAYER_POSITION_LOCK = 0xffff0000,
|
|
|
|
|
|
|
|
/* Values reserved for libweston internal usage */
|
|
|
|
WESTON_LAYER_POSITION_CURSOR = 0xfffffffe,
|
|
|
|
WESTON_LAYER_POSITION_FADE = 0xffffffff,
|
|
|
|
};
|
|
|
|
|
2012-02-29 21:42:35 +04:00
|
|
|
struct weston_layer {
|
2016-12-17 15:40:51 +03:00
|
|
|
struct weston_compositor *compositor;
|
|
|
|
struct wl_list link; /* weston_compositor::layer_list */
|
|
|
|
enum weston_layer_position position;
|
2014-07-09 23:12:57 +04:00
|
|
|
pixman_box32_t mask;
|
2016-12-17 15:40:51 +03:00
|
|
|
struct weston_layer_entry view_list;
|
2012-02-29 21:42:35 +04:00
|
|
|
};
|
|
|
|
|
2012-08-03 19:30:18 +04:00
|
|
|
struct weston_plane {
|
2013-10-23 09:58:31 +04:00
|
|
|
struct weston_compositor *compositor;
|
2015-02-23 15:08:25 +03:00
|
|
|
pixman_region32_t damage; /**< in global coords */
|
2013-03-05 19:30:29 +04:00
|
|
|
pixman_region32_t clip;
|
2012-08-03 19:30:18 +04:00
|
|
|
int32_t x, y;
|
2013-03-05 19:30:27 +04:00
|
|
|
struct wl_list link;
|
2012-08-03 19:30:18 +04:00
|
|
|
};
|
|
|
|
|
2012-09-06 06:49:55 +04:00
|
|
|
struct weston_renderer {
|
2012-11-13 22:10:21 +04:00
|
|
|
int (*read_pixels)(struct weston_output *output,
|
|
|
|
pixman_format_code_t format, void *pixels,
|
|
|
|
uint32_t x, uint32_t y,
|
|
|
|
uint32_t width, uint32_t height);
|
2012-09-06 06:49:55 +04:00
|
|
|
void (*repaint_output)(struct weston_output *output,
|
|
|
|
pixman_region32_t *output_damage);
|
|
|
|
void (*flush_damage)(struct weston_surface *surface);
|
2013-06-21 05:38:23 +04:00
|
|
|
void (*attach)(struct weston_surface *es, struct weston_buffer *buffer);
|
2012-11-13 22:10:23 +04:00
|
|
|
void (*surface_set_color)(struct weston_surface *surface,
|
|
|
|
float red, float green,
|
|
|
|
float blue, float alpha);
|
2013-01-08 20:09:01 +04:00
|
|
|
void (*destroy)(struct weston_compositor *ec);
|
2015-02-09 14:16:57 +03:00
|
|
|
|
|
|
|
|
|
|
|
/** See weston_surface_get_content_size() */
|
|
|
|
void (*surface_get_content_size)(struct weston_surface *surface,
|
|
|
|
int *width, int *height);
|
|
|
|
|
|
|
|
/** See weston_surface_copy_content() */
|
|
|
|
int (*surface_copy_content)(struct weston_surface *surface,
|
|
|
|
void *target, size_t size,
|
|
|
|
int src_x, int src_y,
|
|
|
|
int width, int height);
|
2014-09-29 22:18:40 +04:00
|
|
|
|
|
|
|
/** See weston_compositor_import_dmabuf() */
|
|
|
|
bool (*import_dmabuf)(struct weston_compositor *ec,
|
|
|
|
struct linux_dmabuf_buffer *buffer);
|
2016-11-23 11:33:20 +03:00
|
|
|
|
2017-12-05 17:26:16 +03:00
|
|
|
/** On error sets num_formats to zero */
|
|
|
|
void (*query_dmabuf_formats)(struct weston_compositor *ec,
|
2016-11-23 11:33:20 +03:00
|
|
|
int **formats, int *num_formats);
|
|
|
|
|
2017-12-05 17:26:16 +03:00
|
|
|
/** On error sets num_modifiers to zero */
|
|
|
|
void (*query_dmabuf_modifiers)(struct weston_compositor *ec,
|
2016-11-23 11:33:20 +03:00
|
|
|
int format, uint64_t **modifiers,
|
|
|
|
int *num_modifiers);
|
2012-09-06 06:49:55 +04:00
|
|
|
};
|
|
|
|
|
2013-05-22 19:03:04 +04:00
|
|
|
enum weston_capability {
|
|
|
|
/* backend/renderer supports arbitrary rotation */
|
|
|
|
WESTON_CAP_ROTATION_ANY = 0x0001,
|
2013-05-22 19:03:05 +04:00
|
|
|
|
|
|
|
/* screencaptures need to be y-flipped */
|
|
|
|
WESTON_CAP_CAPTURE_YFLIP = 0x0002,
|
2014-04-03 04:53:46 +04:00
|
|
|
|
2015-03-19 04:42:00 +03:00
|
|
|
/* backend/renderer has a separate cursor plane */
|
2014-04-03 04:53:46 +04:00
|
|
|
WESTON_CAP_CURSOR_PLANE = 0x0004,
|
|
|
|
|
|
|
|
/* backend supports setting arbitrary resolutions */
|
|
|
|
WESTON_CAP_ARBITRARY_MODES = 0x0008,
|
2015-02-16 15:39:11 +03:00
|
|
|
|
|
|
|
/* renderer supports weston_view_set_mask() clipping */
|
|
|
|
WESTON_CAP_VIEW_CLIP_MASK = 0x0010,
|
2013-05-22 19:03:04 +04:00
|
|
|
};
|
|
|
|
|
2015-10-17 19:24:13 +03:00
|
|
|
/* Configuration struct for a backend.
|
|
|
|
*
|
|
|
|
* This struct carries the configuration for a backend, and it's
|
|
|
|
* passed to the backend's init entry point. The backend will
|
|
|
|
* likely want to subclass this in order to handle backend specific
|
|
|
|
* data.
|
2016-04-16 06:28:29 +03:00
|
|
|
*
|
|
|
|
* NOTE: Alternate designs were proposed (Feb 2016) for using opaque
|
|
|
|
* structures[1] and for section+key/value getter/setters[2]. The rationale
|
|
|
|
* for selecting the transparent structure design is based on several
|
|
|
|
* assumptions[3] which may require re-evaluating the design choice if they
|
|
|
|
* fail to hold.
|
|
|
|
*
|
|
|
|
* 1: https://lists.freedesktop.org/archives/wayland-devel/2016-February/026989.html
|
|
|
|
* 2: https://lists.freedesktop.org/archives/wayland-devel/2016-February/026929.html
|
|
|
|
* 3: https://lists.freedesktop.org/archives/wayland-devel/2016-February/027228.html
|
2015-10-17 19:24:13 +03:00
|
|
|
*/
|
|
|
|
struct weston_backend_config {
|
2016-04-16 06:28:29 +03:00
|
|
|
/** Major version for the backend-specific config struct
|
|
|
|
*
|
|
|
|
* This version must match exactly what the backend expects, otherwise
|
|
|
|
* the struct is incompatible.
|
|
|
|
*/
|
|
|
|
uint32_t struct_version;
|
|
|
|
|
|
|
|
/** Minor version of the backend-specific config struct
|
|
|
|
*
|
|
|
|
* This must be set to sizeof(struct backend-specific config).
|
|
|
|
* If the value here is smaller than what the backend expects, the
|
|
|
|
* extra config members will assume their default values.
|
|
|
|
*
|
|
|
|
* A value greater than what the backend expects is incompatible.
|
|
|
|
*/
|
|
|
|
size_t struct_size;
|
2015-10-17 19:24:13 +03:00
|
|
|
};
|
|
|
|
|
2014-10-11 19:27:30 +04:00
|
|
|
struct weston_backend {
|
2015-10-17 19:24:13 +03:00
|
|
|
void (*destroy)(struct weston_compositor *compositor);
|
2017-03-01 14:34:10 +03:00
|
|
|
|
|
|
|
/** Begin a repaint sequence
|
|
|
|
*
|
|
|
|
* Provides the backend with explicit markers around repaint
|
|
|
|
* sequences, which may allow the backend to aggregate state
|
|
|
|
* application. This call will be bracketed by the repaint_flush (on
|
|
|
|
* success), or repaint_cancel (when any output in the grouping fails
|
|
|
|
* repaint).
|
|
|
|
*
|
|
|
|
* Returns an opaque pointer, which the backend may use as private
|
|
|
|
* data referring to the repaint cycle.
|
|
|
|
*/
|
|
|
|
void * (*repaint_begin)(struct weston_compositor *compositor);
|
|
|
|
|
|
|
|
/** Cancel a repaint sequence
|
|
|
|
*
|
|
|
|
* Cancels a repaint sequence, when an error has occurred during
|
|
|
|
* one output's repaint; see repaint_begin.
|
|
|
|
*
|
|
|
|
* @param repaint_data Data returned by repaint_begin
|
|
|
|
*/
|
|
|
|
void (*repaint_cancel)(struct weston_compositor *compositor,
|
|
|
|
void *repaint_data);
|
|
|
|
|
|
|
|
/** Conclude a repaint sequence
|
|
|
|
*
|
|
|
|
* Called on successful completion of a repaint sequence; see
|
|
|
|
* repaint_begin.
|
|
|
|
*
|
|
|
|
* @param repaint_data Data returned by repaint_begin
|
|
|
|
*/
|
|
|
|
void (*repaint_flush)(struct weston_compositor *compositor,
|
|
|
|
void *repaint_data);
|
2017-08-16 10:39:17 +03:00
|
|
|
|
|
|
|
/** Allocate a new output
|
|
|
|
*
|
|
|
|
* @param compositor The compositor.
|
|
|
|
* @param name Name for the new output.
|
|
|
|
*
|
|
|
|
* Allocates a new output structure that embeds a weston_output,
|
|
|
|
* initializes it, and returns the pointer to the weston_output
|
|
|
|
* member.
|
|
|
|
*
|
|
|
|
* Must set weston_output members @c destroy, @c enable and @c disable.
|
|
|
|
*/
|
|
|
|
struct weston_output *
|
|
|
|
(*create_output)(struct weston_compositor *compositor,
|
|
|
|
const char *name);
|
2014-10-11 19:27:30 +04:00
|
|
|
};
|
|
|
|
|
2017-11-29 04:42:47 +03:00
|
|
|
/** Callback for saving calibration
|
|
|
|
*
|
|
|
|
* \param compositor The compositor.
|
|
|
|
* \param device The physical touch device to save for.
|
|
|
|
* \param calibration The new calibration from a client.
|
|
|
|
* \return -1 on failure, 0 on success.
|
|
|
|
*
|
|
|
|
* Failure will prevent taking the new calibration into use.
|
|
|
|
*/
|
|
|
|
typedef int (*weston_touch_calibration_save_func)(
|
|
|
|
struct weston_compositor *compositor,
|
|
|
|
struct weston_touch_device *device,
|
|
|
|
const struct weston_touch_device_matrix *calibration);
|
|
|
|
struct weston_touch_calibrator;
|
|
|
|
|
2016-08-12 11:41:35 +03:00
|
|
|
struct weston_desktop_xwayland;
|
|
|
|
struct weston_desktop_xwayland_interface;
|
2017-10-12 14:13:42 +03:00
|
|
|
struct weston_debug_compositor;
|
2016-08-12 11:41:35 +03: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
|
|
|
struct weston_compositor {
|
2012-04-12 17:55:26 +04:00
|
|
|
struct wl_signal destroy_signal;
|
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 wl_display *wl_display;
|
2016-08-12 11:41:35 +03:00
|
|
|
struct weston_desktop_xwayland *xwayland;
|
|
|
|
const struct weston_desktop_xwayland_interface *xwayland_interface;
|
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
|
|
|
|
2013-06-12 22:43:21 +04:00
|
|
|
/* surface signals */
|
2014-04-07 09:04:50 +04:00
|
|
|
struct wl_signal create_surface_signal;
|
2012-04-12 17:55:26 +04:00
|
|
|
struct wl_signal activate_signal;
|
2013-06-12 22:43:21 +04:00
|
|
|
struct wl_signal transform_signal;
|
|
|
|
|
2012-09-27 18:48:36 +04:00
|
|
|
struct wl_signal kill_signal;
|
2013-02-21 20:35:23 +04:00
|
|
|
struct wl_signal idle_signal;
|
|
|
|
struct wl_signal wake_signal;
|
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
|
|
|
|
2012-06-21 23:52:17 +04:00
|
|
|
struct wl_signal show_input_panel_signal;
|
|
|
|
struct wl_signal hide_input_panel_signal;
|
2013-04-18 18:47:28 +04:00
|
|
|
struct wl_signal update_input_panel_signal;
|
2012-06-21 23:52:17 +04:00
|
|
|
|
2012-11-18 22:06:42 +04:00
|
|
|
struct wl_signal seat_created_signal;
|
2013-05-02 00:52:11 +04:00
|
|
|
struct wl_signal output_created_signal;
|
2014-01-29 20:47:51 +04:00
|
|
|
struct wl_signal output_destroyed_signal;
|
2014-01-29 20:47:52 +04:00
|
|
|
struct wl_signal output_moved_signal;
|
2016-05-28 00:22:57 +03:00
|
|
|
struct wl_signal output_resized_signal; /* callback argument: resized output */
|
2012-11-18 22:06:42 +04:00
|
|
|
|
2018-03-20 14:29:40 +03:00
|
|
|
/* Signal for output changes triggered by configuration from frontend
|
|
|
|
* or head state changes from backend.
|
|
|
|
*/
|
|
|
|
struct wl_signal output_heads_changed_signal; /* arg: weston_output */
|
|
|
|
|
2013-09-18 03:02:57 +04:00
|
|
|
struct wl_signal session_signal;
|
|
|
|
int session_active;
|
|
|
|
|
2012-02-29 21:42:35 +04:00
|
|
|
struct weston_layer fade_layer;
|
|
|
|
struct weston_layer cursor_layer;
|
|
|
|
|
2016-09-30 15:11:02 +03:00
|
|
|
struct wl_list pending_output_list;
|
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 wl_list output_list;
|
2017-08-14 16:05:35 +03:00
|
|
|
struct wl_list head_list; /* struct weston_head::compositor_link */
|
2012-05-16 21:45:18 +04:00
|
|
|
struct wl_list seat_list;
|
2016-12-17 15:40:51 +03:00
|
|
|
struct wl_list layer_list; /* struct weston_layer::link */
|
2016-03-30 14:08:24 +03:00
|
|
|
struct wl_list view_list; /* struct weston_view::link */
|
2013-03-05 19:30:27 +04:00
|
|
|
struct wl_list plane_list;
|
2012-05-30 19:31:58 +04:00
|
|
|
struct wl_list key_binding_list;
|
2013-11-19 14:37:12 +04:00
|
|
|
struct wl_list modifier_binding_list;
|
2012-05-30 19:31:58 +04:00
|
|
|
struct wl_list button_binding_list;
|
2013-10-03 19:43:04 +04:00
|
|
|
struct wl_list touch_binding_list;
|
2012-05-30 19:31:58 +04:00
|
|
|
struct wl_list axis_binding_list;
|
2012-11-08 19:20:45 +04:00
|
|
|
struct wl_list debug_binding_list;
|
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
|
|
|
|
|
|
|
uint32_t state;
|
|
|
|
struct wl_event_source *idle_source;
|
|
|
|
uint32_t idle_inhibit;
|
2013-03-10 17:37:04 +04:00
|
|
|
int idle_time; /* timeout, s */
|
2017-03-01 14:34:08 +03:00
|
|
|
struct wl_event_source *repaint_timer;
|
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
|
|
|
|
2013-11-15 02:42:53 +04:00
|
|
|
const struct weston_pointer_grab_interface *default_pointer_grab;
|
|
|
|
|
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
|
|
|
/* Repaint state. */
|
2012-08-03 19:30:18 +04:00
|
|
|
struct weston_plane primary_plane;
|
2013-05-22 19:03:04 +04:00
|
|
|
uint32_t capabilities; /* combination of enum weston_capability */
|
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
|
|
|
|
2012-09-06 06:49:55 +04:00
|
|
|
struct weston_renderer *renderer;
|
|
|
|
|
2012-11-13 22:10:22 +04:00
|
|
|
pixman_format_code_t read_format;
|
2012-04-11 17:19:37 +04:00
|
|
|
|
2014-10-11 19:27:30 +04:00
|
|
|
struct weston_backend *backend;
|
2012-01-03 20:29:15 +04:00
|
|
|
|
2013-09-18 01:41:03 +04:00
|
|
|
struct weston_launcher *launcher;
|
2012-04-20 06:50:08 +04:00
|
|
|
|
2016-06-29 12:54:26 +03:00
|
|
|
struct wl_list plugin_api_list; /* struct weston_plugin_api::link */
|
|
|
|
|
2012-04-20 06:50:08 +04:00
|
|
|
uint32_t output_id_pool;
|
2012-05-01 23:37:10 +04:00
|
|
|
|
2012-05-30 19:32:04 +04:00
|
|
|
struct xkb_rule_names xkb_names;
|
|
|
|
struct xkb_context *xkb_context;
|
2013-09-05 17:31:40 +04:00
|
|
|
struct weston_xkb_info *xkb_info;
|
2013-06-24 19:52:44 +04:00
|
|
|
|
2014-08-12 16:58:25 +04:00
|
|
|
int32_t kb_repeat_rate;
|
|
|
|
int32_t kb_repeat_delay;
|
2014-09-24 06:08:45 +04:00
|
|
|
|
2016-01-12 13:21:47 +03:00
|
|
|
bool vt_switching;
|
|
|
|
|
2014-09-24 06:08:45 +04:00
|
|
|
clockid_t presentation_clock;
|
2014-05-21 17:17:27 +04:00
|
|
|
int32_t repaint_msec;
|
2014-10-29 21:44:33 +03:00
|
|
|
|
2014-10-18 20:42:19 +04:00
|
|
|
unsigned int activate_serial;
|
|
|
|
|
2016-07-22 12:56:31 +03:00
|
|
|
struct wl_global *pointer_constraints;
|
|
|
|
|
2014-10-29 21:44:33 +03:00
|
|
|
int exit_code;
|
2014-10-12 00:56:24 +04:00
|
|
|
|
|
|
|
void *user_data;
|
|
|
|
void (*exit)(struct weston_compositor *c);
|
2016-10-21 22:03:13 +03:00
|
|
|
|
|
|
|
/* Whether to let the compositor run without any input device. */
|
|
|
|
bool require_input;
|
|
|
|
|
2018-03-20 14:29:40 +03:00
|
|
|
/* Signal for a backend to inform a frontend about possible changes
|
|
|
|
* in head status.
|
|
|
|
*/
|
2017-08-15 13:00:02 +03:00
|
|
|
struct wl_signal heads_changed_signal;
|
|
|
|
struct wl_event_source *heads_changed_source;
|
input: introduce touch event mode for calibrator
In addition to the normal touch event processing mode, introduce a new
mode for calibrating a touchscreen input device.
In the calibration mode, normal touch event processing is skipped, and
the raw events are forwarded to the calibrator instead. The calibrator
is not yet implemented, so the calls will be added in a following patch.
To switch between modes, two functions are added, one for entering each
mode. The mode switch happens only when no touches are down on any touch
device, to avoid confusing touch grabs and clients. To realise this, the
state machine has four states: prepare and actual state for both normal
and calibrator modes.
At this point nothing will attempt to change the touch event mode.
The new calibrator mode is necessary, because when calibrating a
touchscreen, the touch events must be routed to the calibration client
directly. The touch coordinates are expected to be wrong, so they cannot
go through the normal focus surface picking. The calibrator code also
cannot use the normal touch grab interface, because it needs to be able
to distinguish between different physical touch input devices, even if
they are part of the same weston_seat. This requirement makes
calibration special enough to warrant the new mode, a sort of "super
grab".
Co-developed by Louis-Francis and Pekka.
Signed-off-by: Louis-Francis Ratté-Boulianne <lfrb@collabora.com>
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
v1 Tested-by: Matt Hoosier <matt.hoosier@gmail.com>
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
2017-11-29 04:42:47 +03:00
|
|
|
|
2017-11-29 04:42:47 +03:00
|
|
|
/* Touchscreen calibrator support: */
|
input: introduce touch event mode for calibrator
In addition to the normal touch event processing mode, introduce a new
mode for calibrating a touchscreen input device.
In the calibration mode, normal touch event processing is skipped, and
the raw events are forwarded to the calibrator instead. The calibrator
is not yet implemented, so the calls will be added in a following patch.
To switch between modes, two functions are added, one for entering each
mode. The mode switch happens only when no touches are down on any touch
device, to avoid confusing touch grabs and clients. To realise this, the
state machine has four states: prepare and actual state for both normal
and calibrator modes.
At this point nothing will attempt to change the touch event mode.
The new calibrator mode is necessary, because when calibrating a
touchscreen, the touch events must be routed to the calibration client
directly. The touch coordinates are expected to be wrong, so they cannot
go through the normal focus surface picking. The calibrator code also
cannot use the normal touch grab interface, because it needs to be able
to distinguish between different physical touch input devices, even if
they are part of the same weston_seat. This requirement makes
calibration special enough to warrant the new mode, a sort of "super
grab".
Co-developed by Louis-Francis and Pekka.
Signed-off-by: Louis-Francis Ratté-Boulianne <lfrb@collabora.com>
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
v1 Tested-by: Matt Hoosier <matt.hoosier@gmail.com>
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
2017-11-29 04:42:47 +03:00
|
|
|
enum weston_touch_mode touch_mode;
|
2017-11-29 04:42:47 +03:00
|
|
|
struct wl_global *touch_calibration;
|
|
|
|
weston_touch_calibration_save_func touch_calibration_save;
|
|
|
|
struct weston_layer calibrator_layer;
|
|
|
|
struct weston_touch_calibrator *touch_calibrator;
|
2017-10-12 14:13:42 +03:00
|
|
|
|
|
|
|
struct weston_debug_compositor *weston_debug;
|
2018-07-20 11:46:24 +03:00
|
|
|
struct weston_debug_scope *debug_scene;
|
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
|
|
|
};
|
|
|
|
|
2013-06-21 05:38:23 +04:00
|
|
|
struct weston_buffer {
|
|
|
|
struct wl_resource *resource;
|
|
|
|
struct wl_signal destroy_signal;
|
|
|
|
struct wl_listener destroy_listener;
|
|
|
|
|
|
|
|
union {
|
|
|
|
struct wl_shm_buffer *shm_buffer;
|
2013-06-28 05:17:02 +04:00
|
|
|
void *legacy_buffer;
|
2013-06-21 05:38:23 +04:00
|
|
|
};
|
|
|
|
int32_t width, height;
|
|
|
|
uint32_t busy_count;
|
2013-08-29 11:36:44 +04:00
|
|
|
int y_inverted;
|
2013-06-21 05:38:23 +04:00
|
|
|
};
|
|
|
|
|
compositor: introduce weston_buffer_reference
The wl_buffer reference counting API has been inconsistent. You would
manually increment the refcount and register a destroy listener, as
opposed to calling weston_buffer_post_release(), which internally
decremented the refcount, and then removing a list item.
Replace both cases with a single function:
weston_buffer_reference(weston_buffer_reference *ref, wl_buffer *buffer)
Buffer is assigned to ref->buffer, while taking care of all the refcounting
and release posting. You take a reference by passing a non-NULL buffer, and
release a reference by passing NULL as buffer. The function uses an
internal wl_buffer destroy listener, so the pointer gets reset on
destruction automatically.
This is inspired by the pipe_resource_reference() of Mesa, and modified
by krh's suggestion to add struct weston_buffer_reference.
Additionally, when a surface gets destroyed, the associated wl_buffer
will send a release event. Often the buffer is already destroyed on
client side, so the event will be discarded by libwayland-client.
Compositor-drm.c is converted to use weston_buffer_reference.
Signed-off-by: Pekka Paalanen <ppaalanen@gmail.com>
2012-12-04 17:58:12 +04:00
|
|
|
struct weston_buffer_reference {
|
2013-06-21 05:38:23 +04:00
|
|
|
struct weston_buffer *buffer;
|
compositor: introduce weston_buffer_reference
The wl_buffer reference counting API has been inconsistent. You would
manually increment the refcount and register a destroy listener, as
opposed to calling weston_buffer_post_release(), which internally
decremented the refcount, and then removing a list item.
Replace both cases with a single function:
weston_buffer_reference(weston_buffer_reference *ref, wl_buffer *buffer)
Buffer is assigned to ref->buffer, while taking care of all the refcounting
and release posting. You take a reference by passing a non-NULL buffer, and
release a reference by passing NULL as buffer. The function uses an
internal wl_buffer destroy listener, so the pointer gets reset on
destruction automatically.
This is inspired by the pipe_resource_reference() of Mesa, and modified
by krh's suggestion to add struct weston_buffer_reference.
Additionally, when a surface gets destroyed, the associated wl_buffer
will send a release event. Often the buffer is already destroyed on
client side, so the event will be discarded by libwayland-client.
Compositor-drm.c is converted to use weston_buffer_reference.
Signed-off-by: Pekka Paalanen <ppaalanen@gmail.com>
2012-12-04 17:58:12 +04:00
|
|
|
struct wl_listener destroy_listener;
|
|
|
|
};
|
|
|
|
|
2013-11-26 21:19:41 +04:00
|
|
|
struct weston_buffer_viewport {
|
2014-03-14 16:38:15 +04:00
|
|
|
struct {
|
|
|
|
/* wl_surface.set_buffer_transform */
|
|
|
|
uint32_t transform;
|
2013-11-26 21:19:41 +04:00
|
|
|
|
2014-03-14 16:38:15 +04:00
|
|
|
/* wl_surface.set_scaling_factor */
|
|
|
|
int32_t scale;
|
2013-11-26 21:19:46 +04:00
|
|
|
|
2014-03-14 16:38:16 +04:00
|
|
|
/*
|
|
|
|
* If src_width != wl_fixed_from_int(-1),
|
|
|
|
* then and only then src_* are used.
|
|
|
|
*/
|
2014-03-14 16:38:15 +04:00
|
|
|
wl_fixed_t src_x, src_y;
|
|
|
|
wl_fixed_t src_width, src_height;
|
|
|
|
} buffer;
|
|
|
|
|
|
|
|
struct {
|
2014-03-14 16:38:16 +04:00
|
|
|
/*
|
|
|
|
* If width == -1, the size is inferred from the buffer.
|
|
|
|
*/
|
2014-03-14 16:38:15 +04:00
|
|
|
int32_t width, height;
|
|
|
|
} surface;
|
2014-06-13 20:14:20 +04:00
|
|
|
|
|
|
|
int changed;
|
2013-11-26 21:19:41 +04:00
|
|
|
};
|
|
|
|
|
2012-02-24 01:11:59 +04:00
|
|
|
struct weston_region {
|
2013-06-14 19:07:56 +04:00
|
|
|
struct wl_resource *resource;
|
2012-02-24 01:11:59 +04:00
|
|
|
pixman_region32_t region;
|
|
|
|
};
|
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
/* Using weston_view transformations
|
2012-02-07 15:18:00 +04:00
|
|
|
*
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
* To add a transformation to a view, create a struct weston_transform, and
|
|
|
|
* add it to the list view->geometry.transformation_list. Whenever you
|
|
|
|
* change the list, anything under view->geometry, or anything in the
|
2013-03-08 16:56:49 +04:00
|
|
|
* weston_transforms linked into the list, you must call
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
* weston_view_geometry_dirty().
|
2012-02-07 15:18:00 +04:00
|
|
|
*
|
|
|
|
* The order in the list defines the order of transformations. Let the list
|
|
|
|
* contain the transformation matrices M1, ..., Mn as head to tail. The
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
* transformation is applied to view-local coordinate vector p as
|
2012-02-07 15:18:00 +04:00
|
|
|
* P = Mn * ... * M2 * M1 * p
|
|
|
|
* to produce the global coordinate vector P. The total transform
|
|
|
|
* Mn * ... * M2 * M1
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
* is cached in view->transform.matrix, and the inverse of it in
|
|
|
|
* view->transform.inverse.
|
2012-02-07 15:18:00 +04:00
|
|
|
*
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
* The list always contains view->transform.position transformation, which
|
|
|
|
* is the translation by view->geometry.x and y.
|
2012-02-07 15:18:00 +04:00
|
|
|
*
|
|
|
|
* If you want to apply a transformation in local coordinates, add your
|
|
|
|
* weston_transform to the head of the list. If you want to apply a
|
|
|
|
* transformation in global coordinates, add it to the tail of the list.
|
2013-03-08 16:56:50 +04:00
|
|
|
*
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
* If view->geometry.parent is set, the total transformation of this
|
|
|
|
* view will be the parent's total transformation and this transformation
|
2013-03-08 16:56:50 +04:00
|
|
|
* combined:
|
|
|
|
* Mparent * Mn * ... * M2 * M1
|
2012-02-07 15:18:00 +04:00
|
|
|
*/
|
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view {
|
|
|
|
struct weston_surface *surface;
|
|
|
|
struct wl_list surface_link;
|
2013-06-07 07:34:41 +04:00
|
|
|
struct wl_signal destroy_signal;
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
|
2016-03-30 14:08:24 +03:00
|
|
|
struct wl_list link; /* weston_compositor::view_list */
|
2015-02-18 17:30:47 +03:00
|
|
|
struct weston_layer_entry layer_link; /* part of geometry */
|
2012-08-03 19:30:18 +04:00
|
|
|
struct weston_plane *plane;
|
2015-02-18 17:06:46 +03:00
|
|
|
|
|
|
|
/* For weston_layer inheritance from another view */
|
2014-07-09 23:12:57 +04:00
|
|
|
struct weston_view *parent_view;
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
|
2014-10-18 20:42:19 +04:00
|
|
|
unsigned int click_to_activate_serial;
|
|
|
|
|
2015-02-17 14:10:01 +03:00
|
|
|
pixman_region32_t clip; /* See weston_view_damage_below() */
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
float alpha; /* part of geometry, see below */
|
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
|
|
|
|
2012-11-13 22:10:23 +04:00
|
|
|
void *renderer_state;
|
|
|
|
|
2012-01-24 11:53:37 +04:00
|
|
|
/* Surface geometry state, mutable.
|
2013-03-08 16:56:49 +04:00
|
|
|
* If you change anything, call weston_surface_geometry_dirty().
|
2012-01-24 11:53:37 +04:00
|
|
|
* That includes the transformations referenced from the list.
|
|
|
|
*/
|
2012-01-06 16:10:06 +04:00
|
|
|
struct {
|
2012-09-30 04:57:21 +04:00
|
|
|
float x, y; /* surface translation on display */
|
2012-01-25 18:22:05 +04:00
|
|
|
|
2012-01-24 11:53:37 +04:00
|
|
|
/* struct weston_transform */
|
|
|
|
struct wl_list transformation_list;
|
2013-03-08 16:56:50 +04:00
|
|
|
|
|
|
|
/* managed by weston_surface_set_transform_parent() */
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view *parent;
|
2013-03-08 16:56:50 +04:00
|
|
|
struct wl_listener parent_destroy_listener;
|
|
|
|
struct wl_list child_list; /* geometry.parent_link */
|
|
|
|
struct wl_list parent_link;
|
2015-02-16 15:39:11 +03:00
|
|
|
|
|
|
|
/* managed by weston_view_set_mask() */
|
|
|
|
bool scissor_enabled;
|
|
|
|
pixman_region32_t scissor; /* always a simple rect */
|
2012-01-24 11:53:37 +04:00
|
|
|
} geometry;
|
2012-01-06 16:10:06 +04:00
|
|
|
|
2012-01-24 11:53:37 +04:00
|
|
|
/* State derived from geometry state, read-only.
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
* This is updated by weston_view_update_transform().
|
2012-01-24 11:53:37 +04:00
|
|
|
*/
|
|
|
|
struct {
|
2013-03-08 16:56:49 +04:00
|
|
|
int dirty;
|
|
|
|
|
2015-02-19 12:49:18 +03:00
|
|
|
/* Approximations in global coordinates:
|
|
|
|
* - boundingbox is guaranteed to include the whole view in
|
|
|
|
* the smallest possible single rectangle.
|
|
|
|
* - opaque is guaranteed to be fully opaque, though not
|
|
|
|
* necessarily include all opaque areas.
|
|
|
|
*/
|
2012-01-25 17:17:40 +04:00
|
|
|
pixman_region32_t boundingbox;
|
2012-02-09 18:39:38 +04:00
|
|
|
pixman_region32_t opaque;
|
2012-01-25 17:17:40 +04:00
|
|
|
|
2012-01-24 11:53:37 +04:00
|
|
|
/* matrix and inverse are used only if enabled = 1.
|
|
|
|
* If enabled = 0, use x, y, width, height directly.
|
|
|
|
*/
|
|
|
|
int enabled;
|
2012-01-12 17:00:57 +04:00
|
|
|
struct weston_matrix matrix;
|
2012-01-20 12:47:57 +04:00
|
|
|
struct weston_matrix inverse;
|
2012-01-25 15:37:39 +04:00
|
|
|
|
|
|
|
struct weston_transform position; /* matrix from x, y */
|
2012-01-06 16:10:06 +04:00
|
|
|
} transform;
|
|
|
|
|
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
|
|
|
/*
|
2016-03-30 14:33:33 +03:00
|
|
|
* The primary output for this view.
|
|
|
|
* Used for picking the output for driving internal animations on the
|
|
|
|
* view, inheriting the primary output for related views in shells, etc.
|
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 *output;
|
2018-04-26 12:08:10 +03:00
|
|
|
struct wl_listener output_destroy_listener;
|
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
|
|
|
|
2012-04-20 06:50:09 +04:00
|
|
|
/*
|
|
|
|
* A more complete representation of all outputs this surface is
|
|
|
|
* displayed on.
|
|
|
|
*/
|
|
|
|
uint32_t output_mask;
|
2014-12-17 17:20:41 +03:00
|
|
|
|
|
|
|
/* Per-surface Presentation feedback flags, controlled by backend. */
|
|
|
|
uint32_t psf_flags;
|
2016-06-30 07:04:28 +03:00
|
|
|
|
|
|
|
bool is_mapped;
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
};
|
|
|
|
|
2014-05-20 23:33:03 +04:00
|
|
|
struct weston_surface_state {
|
|
|
|
/* wl_surface.attach */
|
|
|
|
int newly_attached;
|
|
|
|
struct weston_buffer *buffer;
|
|
|
|
struct wl_listener buffer_destroy_listener;
|
|
|
|
int32_t sx;
|
|
|
|
int32_t sy;
|
|
|
|
|
|
|
|
/* wl_surface.damage */
|
2015-11-26 23:17:48 +03:00
|
|
|
pixman_region32_t damage_surface;
|
|
|
|
/* wl_surface.damage_buffer */
|
|
|
|
pixman_region32_t damage_buffer;
|
2014-05-20 23:33:03 +04:00
|
|
|
|
|
|
|
/* wl_surface.set_opaque_region */
|
|
|
|
pixman_region32_t opaque;
|
|
|
|
|
|
|
|
/* wl_surface.set_input_region */
|
|
|
|
pixman_region32_t input;
|
|
|
|
|
|
|
|
/* wl_surface.frame */
|
|
|
|
struct wl_list frame_callback_list;
|
|
|
|
|
2014-09-24 06:08:46 +04:00
|
|
|
/* presentation.feedback */
|
|
|
|
struct wl_list feedback_list;
|
|
|
|
|
2014-05-20 23:33:03 +04:00
|
|
|
/* wl_surface.set_buffer_transform */
|
|
|
|
/* wl_surface.set_scaling_factor */
|
2016-04-15 14:47:08 +03:00
|
|
|
/* wp_viewport.set_source */
|
|
|
|
/* wp_viewport.set_destination */
|
2014-05-20 23:33:03 +04:00
|
|
|
struct weston_buffer_viewport buffer_viewport;
|
|
|
|
};
|
|
|
|
|
2016-07-22 12:50:26 +03:00
|
|
|
struct weston_surface_activation_data {
|
|
|
|
struct weston_surface *surface;
|
|
|
|
struct weston_seat *seat;
|
|
|
|
};
|
|
|
|
|
2016-07-22 12:56:31 +03:00
|
|
|
struct weston_pointer_constraint {
|
|
|
|
struct wl_list link;
|
|
|
|
|
|
|
|
struct weston_surface *surface;
|
|
|
|
struct weston_view *view;
|
|
|
|
struct wl_resource *resource;
|
|
|
|
struct weston_pointer_grab grab;
|
|
|
|
struct weston_pointer *pointer;
|
|
|
|
uint32_t lifetime;
|
|
|
|
|
|
|
|
pixman_region32_t region;
|
|
|
|
pixman_region32_t region_pending;
|
|
|
|
bool region_is_pending;
|
|
|
|
|
|
|
|
wl_fixed_t hint_x;
|
|
|
|
wl_fixed_t hint_y;
|
|
|
|
wl_fixed_t hint_x_pending;
|
|
|
|
wl_fixed_t hint_y_pending;
|
|
|
|
bool hint_is_pending;
|
|
|
|
|
|
|
|
struct wl_listener pointer_destroy_listener;
|
|
|
|
struct wl_listener surface_destroy_listener;
|
|
|
|
struct wl_listener surface_commit_listener;
|
|
|
|
struct wl_listener surface_activate_listener;
|
|
|
|
};
|
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_surface {
|
|
|
|
struct wl_resource *resource;
|
2015-04-17 14:23:38 +03:00
|
|
|
struct wl_signal destroy_signal; /* callback argument: this surface */
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_compositor *compositor;
|
2016-07-22 12:48:03 +03:00
|
|
|
struct wl_signal commit_signal;
|
2015-02-19 14:59:55 +03:00
|
|
|
|
|
|
|
/** Damage in local coordinates from the client, for tex upload. */
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
pixman_region32_t damage;
|
2015-02-19 14:59:55 +03:00
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
pixman_region32_t opaque; /* part of geometry, see below */
|
|
|
|
pixman_region32_t input;
|
|
|
|
int32_t width, height;
|
|
|
|
int32_t ref_count;
|
|
|
|
|
|
|
|
/* Not for long-term storage. This exists for book-keeping while
|
|
|
|
* iterating over surfaces and views
|
|
|
|
*/
|
2015-11-19 01:32:26 +03:00
|
|
|
bool touched;
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
|
|
|
|
void *renderer_state;
|
|
|
|
|
|
|
|
struct wl_list views;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Which output to vsync this surface to.
|
2016-03-30 14:33:33 +03:00
|
|
|
* Used to determine whether to send or queue frame events, and for
|
|
|
|
* other client-visible syncing/throttling tied to the output
|
|
|
|
* repaint cycle.
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
*/
|
|
|
|
struct weston_output *output;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A more complete representation of all outputs this surface is
|
|
|
|
* displayed on.
|
|
|
|
*/
|
|
|
|
uint32_t output_mask;
|
2012-04-20 06:50:09 +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
|
|
|
struct wl_list frame_callback_list;
|
2014-09-24 06:08:46 +04:00
|
|
|
struct wl_list feedback_list;
|
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
|
|
|
|
compositor: introduce weston_buffer_reference
The wl_buffer reference counting API has been inconsistent. You would
manually increment the refcount and register a destroy listener, as
opposed to calling weston_buffer_post_release(), which internally
decremented the refcount, and then removing a list item.
Replace both cases with a single function:
weston_buffer_reference(weston_buffer_reference *ref, wl_buffer *buffer)
Buffer is assigned to ref->buffer, while taking care of all the refcounting
and release posting. You take a reference by passing a non-NULL buffer, and
release a reference by passing NULL as buffer. The function uses an
internal wl_buffer destroy listener, so the pointer gets reset on
destruction automatically.
This is inspired by the pipe_resource_reference() of Mesa, and modified
by krh's suggestion to add struct weston_buffer_reference.
Additionally, when a surface gets destroyed, the associated wl_buffer
will send a release event. Often the buffer is already destroyed on
client side, so the event will be discarded by libwayland-client.
Compositor-drm.c is converted to use weston_buffer_reference.
Signed-off-by: Pekka Paalanen <ppaalanen@gmail.com>
2012-12-04 17:58:12 +04:00
|
|
|
struct weston_buffer_reference buffer_ref;
|
2013-11-26 21:19:41 +04:00
|
|
|
struct weston_buffer_viewport buffer_viewport;
|
2014-03-14 16:38:17 +04:00
|
|
|
int32_t width_from_buffer; /* before applying viewport */
|
|
|
|
int32_t height_from_buffer;
|
2014-10-10 18:36:45 +04:00
|
|
|
bool keep_buffer; /* for backends to prevent early release */
|
2012-02-28 14:07:54 +04:00
|
|
|
|
2016-04-15 14:47:08 +03:00
|
|
|
/* wp_viewport resource for this surface */
|
2014-01-08 17:39:17 +04:00
|
|
|
struct wl_resource *viewport_resource;
|
2013-11-26 21:19:46 +04:00
|
|
|
|
2012-10-10 13:49:23 +04:00
|
|
|
/* All the pending state, that wl_surface.commit will apply. */
|
2014-05-20 23:33:03 +04:00
|
|
|
struct weston_surface_state pending;
|
2012-10-10 13:49:23 +04:00
|
|
|
|
2014-10-16 19:55:19 +04:00
|
|
|
/* Matrices representating of the full transformation between
|
|
|
|
* buffer and surface coordinates. These matrices are updated
|
|
|
|
* using the weston_surface_build_buffer_matrix function. */
|
|
|
|
struct weston_matrix buffer_to_surface_matrix;
|
|
|
|
struct weston_matrix surface_to_buffer_matrix;
|
|
|
|
|
2012-03-27 18:36:41 +04:00
|
|
|
/*
|
2014-04-28 19:19:27 +04:00
|
|
|
* If non-NULL, this function will be called on
|
|
|
|
* wl_surface::commit after a new buffer has been set up for
|
|
|
|
* this surface. The integer params are the sx and sy
|
|
|
|
* parameters supplied to wl_surface::attach.
|
2012-03-27 18:36:41 +04:00
|
|
|
*/
|
2016-08-12 11:41:33 +03:00
|
|
|
void (*committed)(struct weston_surface *es, int32_t sx, int32_t sy);
|
|
|
|
void *committed_private;
|
compositor: add weston_surface_set_label_func()
When printing out logs from Weston's actions, mainly for debugging, it
can be very difficult to identify the different surfaces. Inspecting
the configure function pointer is not useful, as the configure functions
may live in modules.
Add vfunc get_label to weston_surface, which will produce a short,
human-readable description of the surface, which allows identifying it
better, rather than just looking at the surface size, for instance.
Set the label function from most parts of Weston, to identify cursors and
drag icons, and panels, backgrounds, screensavers and lock surfaces, and
the desktop shell's application surfaces.
v2: renamed 'description' to 'label', so we get
weston_surface_set_label_func().
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
2014-08-06 20:36:51 +04:00
|
|
|
int (*get_label)(struct weston_surface *surface, char *buf, size_t len);
|
compositor: introduce sub-surfaces
Implement the basic protocol for sub-surfaces:
- expose wl_subcompositor global interface
- error checking on protocol calls
- associate a parent wl_surface to a sub-surface
- introduce the sub-surface role, which is exclusive
- an implementation of the wl_subsurface interface
- allow nesting of sub-surfaces
- proper surface transformation inheritance from parent to sub-surfaces
- two different modes of wl_surface.commit for sub-surfaces
- hook sub-surfaces up to repaint by modifying the repaint list code
Struct weston_subsurface is dynamically allocated. For sub-surfaces, it
is completely populated.
For parent surfaces, weston_subsurface acts only as a link for stacking
order purposes. The wl_resource is unused, parent_destroy_listener is
not registered, the transform is not linked, etc.
Sub-surfaces are not added directly into layers for display or input.
Instead, they are hooked up via the sub-surface list present in parent
weston_surface. This way sub-surfaces are inherently linked to the
parent surface, and cannot be displayed unless the parent is mapped,
too. This also eases restacking, as only the parent will be in a layer
list. Also, only the main surface should be subject to shell actions.
The surface list rebuilding in weston_output_repaint() is modified to
process sub-surface lists, if they are non-empty. The sub-surface list
always contains the parent, too, unless empty. The collection of
frame_callback_list is moved to a later loop, to streamline the surface
list rebuild functions.
Features still lacking are:
- full-surface alpha support for compound windows
Changes in v2:
- fix a bug in surface mapping: commit a sub-surface would cause the
main surface to never be mapped.
- remove debug printfs
- detect attempt of making a surface its own parent
- always zero-alloc weston_subsurface
- apply wl_subsurface.set_position in commit, not immediately
- add weston_surface_to_subsurface()
- implement sub-surface commit modes parent-cached and independent
- implement wl_subcompositor.destroy and wl_subsurface.destroy
Changes in v3:
- rebased, and use the new transform inheritance code
- squashed the commit "add sub-surfaces to repaint list"
- fixed a buffer reference leak in commit_from_cache()
- Rewrite the sub-surface destructor code, and make it leave the
wl_subsurface protocol object inert, if one destroys the corresponding
wl_surface.
- replaced set_commit_mode with set_sync and set_desync
- allowed sub-surface nesting, and fixed repaint accordingly
- implemented nested sub-surface commit modes
- Made the sub-surface order changes from wl_subsurface.place_above and
.place_below to be applied when the parent surface state is applied,
instead of immediately. This conforms with the protocol specification
now.
Signed-off-by: Pekka Paalanen <ppaalanen@gmail.com>
2013-04-25 14:57:42 +04:00
|
|
|
|
|
|
|
/* Parent's list of its sub-surfaces, weston_subsurface:parent_link.
|
|
|
|
* Contains also the parent itself as a dummy weston_subsurface,
|
|
|
|
* if the list is not empty.
|
|
|
|
*/
|
|
|
|
struct wl_list subsurface_list; /* weston_subsurface::parent_link */
|
|
|
|
struct wl_list subsurface_list_pending; /* ...::parent_link_pending */
|
compositor: send error for surface role resets
With the more accurate definition of wl_surface roles in Wayland,
enforce the restriction: a role is always set permanently, and
attempting to change it is a protocol error.
This patch is based on Jasper's patch:
http://lists.freedesktop.org/archives/wayland-devel/2014-August/016811.html
The difference in this patch compared to his are:
- send role errors on the interface whose request triggers it, not on
wl_surface
- an interface could have several requests assigning different roles,
cannot use wl_interface as the unique key; use an arbitary string
instead
- ensure in window-manager.c that create_shell_surface() ->
create_common_surface() is never called with surface->configure set,
to avoid compositor abort
- use wl_resource_post_no_memory() where appropriate instead of
hand-rolling it with wl_resource_post_error()
Ideally we would not add weston_surface::role_name field, but use
weston_surface::configure. At the moment this is not possible though,
because at least shell.c uses several different roles with the same
configure function. Drag'n'drop uses two configure functions for the
same role. The configure hook is also reset in several places,
which is not good for role tracking.
This patch overlooks the wl_surface roles assigned in privileged
extensions: screensaver, panel, background, lock, input panel.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
Reviewed-by: Jasper St. Pierre <jstpierre@mecheye.net>
2014-10-01 16:02:41 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For tracking protocol role assignments. Different roles may
|
|
|
|
* have the same configure hook, e.g. in shell.c. Configure hook
|
|
|
|
* may get reset, this will not.
|
|
|
|
* XXX: map configure functions 1:1 to roles, and never reset it,
|
|
|
|
* and replace role_name with configure.
|
|
|
|
*/
|
|
|
|
const char *role_name;
|
compositor: Implement JSON-timeline logging
Logging is activated and deactivated with the debug key binding 't'.
When activated, it creates a new log file, where it records the events.
The log file contains events and detailed object information entries in
JSON format, and is meant to be parsed in sequence from beginning to the
end.
The emitted events are mostly related to the output repaint cycle, like
when repaint begins, is submitted to GPU, and when it completes on a
vblank. This is recorded per-output. Also some per-surface events are
recorded, including when surface damage is flushed.
To reduce the log size, events refer to objects like outputs and
surfaces by id numbers. Detailed object information is emitted only as
needed: on the first object occurrence, and afterwards only if
weston_timeline_object::force_refresh asks for it.
The detailed information for surfaces includes the string returned by
weston_surface::get_label. Therefore it is important to set
weston_timeline_object::force_refresh = 1 whenever the string would
change, so that the new details get recorded.
A rudimentary parser and SVG generator can be found at:
https://github.com/ppaalanen/wesgr
The timeline logs can answer questions including:
- How does the compositor repaint cycle work timing-wise?
- When was the vblank deadline missed?
- What is the latency from surface commit to showing the new content on
screen?
- How long does it take to process the scenegraph?
v2: weston_surface::get_description renamed to get_label.
v3: reafctor a bit into fprint_quoted_string().
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
2014-11-12 16:09:24 +03:00
|
|
|
|
|
|
|
struct weston_timeline_object timeline;
|
2016-06-30 07:04:28 +03:00
|
|
|
|
|
|
|
bool is_mapped;
|
2016-07-22 12:56:31 +03:00
|
|
|
|
|
|
|
/* An list of per seat pointer constraints. */
|
|
|
|
struct wl_list pointer_constraints;
|
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
|
|
|
};
|
|
|
|
|
2014-05-20 20:23:53 +04:00
|
|
|
struct weston_subsurface {
|
|
|
|
struct wl_resource *resource;
|
|
|
|
|
|
|
|
/* guaranteed to be valid and non-NULL */
|
|
|
|
struct weston_surface *surface;
|
|
|
|
struct wl_listener surface_destroy_listener;
|
|
|
|
|
|
|
|
/* can be NULL */
|
|
|
|
struct weston_surface *parent;
|
|
|
|
struct wl_listener parent_destroy_listener;
|
|
|
|
struct wl_list parent_link;
|
|
|
|
struct wl_list parent_link_pending;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
int32_t x;
|
|
|
|
int32_t y;
|
|
|
|
int set;
|
|
|
|
} position;
|
|
|
|
|
2014-05-20 23:33:03 +04:00
|
|
|
int has_cached_data;
|
|
|
|
struct weston_surface_state cached;
|
|
|
|
struct weston_buffer_reference cached_buffer_ref;
|
2014-05-20 20:23:53 +04:00
|
|
|
|
2017-01-27 19:30:29 +03:00
|
|
|
/* Sub-surface has been reordered; need to apply damage. */
|
|
|
|
bool reordered;
|
|
|
|
|
2014-05-20 20:23:53 +04:00
|
|
|
int synchronized;
|
|
|
|
|
|
|
|
/* Used for constructing the view tree */
|
|
|
|
struct wl_list unused_views;
|
|
|
|
};
|
|
|
|
|
2012-06-22 16:21:29 +04:00
|
|
|
enum weston_key_state_update {
|
|
|
|
STATE_UPDATE_AUTOMATIC,
|
|
|
|
STATE_UPDATE_NONE,
|
|
|
|
};
|
|
|
|
|
2014-10-18 20:20:16 +04:00
|
|
|
enum weston_activate_flag {
|
|
|
|
WESTON_ACTIVATE_FLAG_NONE = 0,
|
|
|
|
WESTON_ACTIVATE_FLAG_CONFIGURE = 1 << 0,
|
2014-10-18 20:42:19 +04:00
|
|
|
WESTON_ACTIVATE_FLAG_CLICKED = 1 << 1,
|
2014-10-18 20:20:16 +04:00
|
|
|
};
|
|
|
|
|
2013-02-16 05:53:20 +04:00
|
|
|
void
|
|
|
|
weston_version(int *major, int *minor, int *micro);
|
|
|
|
|
2018-04-26 12:08:10 +03:00
|
|
|
void
|
|
|
|
weston_view_set_output(struct weston_view *view, struct weston_output *output);
|
|
|
|
|
2012-01-20 18:48:25 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_update_transform(struct weston_view *view);
|
2012-01-20 18:48:25 +04:00
|
|
|
|
2013-03-08 16:56:49 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_geometry_dirty(struct weston_view *view);
|
2013-03-08 16:56:49 +04:00
|
|
|
|
2012-03-27 18:36:37 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_to_global_fixed(struct weston_view *view,
|
|
|
|
wl_fixed_t sx, wl_fixed_t sy,
|
|
|
|
wl_fixed_t *x, wl_fixed_t *y);
|
2012-05-08 20:17:53 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_to_global_float(struct weston_view *view,
|
|
|
|
float sx, float sy, float *x, float *y);
|
2012-01-24 11:59:29 +04:00
|
|
|
|
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_from_global_float(struct weston_view *view,
|
|
|
|
float x, float y, float *vx, float *vy);
|
2012-09-06 05:59:35 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_from_global(struct weston_view *view,
|
|
|
|
int32_t x, int32_t y, int32_t *vx, int32_t *vy);
|
2012-05-08 20:17:53 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_from_global_fixed(struct weston_view *view,
|
|
|
|
wl_fixed_t x, wl_fixed_t y,
|
|
|
|
wl_fixed_t *vx, wl_fixed_t *vy);
|
2012-01-24 11:59:29 +04:00
|
|
|
|
2014-09-19 01:46:49 +04:00
|
|
|
void
|
2012-11-28 19:10:26 +04:00
|
|
|
weston_surface_to_buffer_float(struct weston_surface *surface,
|
|
|
|
float x, float y, float *bx, float *by);
|
|
|
|
pixman_box32_t
|
|
|
|
weston_surface_to_buffer_rect(struct weston_surface *surface,
|
|
|
|
pixman_box32_t rect);
|
|
|
|
|
2015-03-04 15:23:28 +03:00
|
|
|
void
|
|
|
|
weston_surface_to_buffer_region(struct weston_surface *surface,
|
|
|
|
pixman_region32_t *surface_region,
|
|
|
|
pixman_region32_t *buffer_region);
|
|
|
|
|
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
|
|
|
void
|
|
|
|
weston_spring_init(struct weston_spring *spring,
|
|
|
|
double k, double current, double target);
|
|
|
|
void
|
2017-11-16 19:20:52 +03:00
|
|
|
weston_spring_update(struct weston_spring *spring, const struct timespec *time);
|
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
|
|
|
int
|
|
|
|
weston_spring_done(struct weston_spring *spring);
|
|
|
|
|
2014-10-18 20:42:19 +04:00
|
|
|
void
|
|
|
|
weston_view_activate(struct weston_view *view,
|
|
|
|
struct weston_seat *seat,
|
|
|
|
uint32_t flags);
|
|
|
|
|
2012-01-26 08:32:28 +04:00
|
|
|
void
|
2017-11-24 19:01:46 +03:00
|
|
|
notify_motion(struct weston_seat *seat, const struct timespec *time,
|
2014-10-05 23:39:14 +04:00
|
|
|
struct weston_pointer_motion_event *event);
|
2013-03-27 19:59:43 +04:00
|
|
|
void
|
2017-11-24 19:01:46 +03:00
|
|
|
notify_motion_absolute(struct weston_seat *seat, const struct timespec *time,
|
2016-03-22 18:44:54 +03:00
|
|
|
double x, double y);
|
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
|
|
|
void
|
2017-11-16 19:20:55 +03:00
|
|
|
notify_button(struct weston_seat *seat, const struct timespec *time,
|
|
|
|
int32_t button, enum wl_pointer_button_state state);
|
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
|
|
|
void
|
2017-11-16 19:20:56 +03:00
|
|
|
notify_axis(struct weston_seat *seat, const struct timespec *time,
|
2016-01-18 08:58:17 +03:00
|
|
|
struct weston_pointer_axis_event *event);
|
2016-01-18 09:38:22 +03:00
|
|
|
void
|
|
|
|
notify_axis_source(struct weston_seat *seat, uint32_t source);
|
|
|
|
|
|
|
|
void
|
|
|
|
notify_pointer_frame(struct weston_seat *seat);
|
|
|
|
|
2012-03-22 20:47:01 +04:00
|
|
|
void
|
2017-11-16 19:20:57 +03:00
|
|
|
notify_key(struct weston_seat *seat, const struct timespec *time, uint32_t key,
|
2012-06-22 16:21:37 +04:00
|
|
|
enum wl_keyboard_key_state state,
|
|
|
|
enum weston_key_state_update update_state);
|
2012-06-22 16:21:38 +04:00
|
|
|
void
|
2012-08-10 17:50:11 +04:00
|
|
|
notify_modifiers(struct weston_seat *seat, uint32_t serial);
|
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
|
|
|
|
|
|
|
void
|
2012-08-10 17:50:11 +04:00
|
|
|
notify_pointer_focus(struct weston_seat *seat, struct weston_output *output,
|
2016-03-22 18:44:54 +03:00
|
|
|
double x, double y);
|
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
|
|
|
|
|
|
|
void
|
2012-08-10 17:50:11 +04:00
|
|
|
notify_keyboard_focus_in(struct weston_seat *seat, struct wl_array *keys,
|
2012-06-22 16:21:29 +04:00
|
|
|
enum weston_key_state_update update_state);
|
|
|
|
void
|
2012-08-10 17:50:11 +04:00
|
|
|
notify_keyboard_focus_out(struct weston_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
|
|
|
|
|
|
|
void
|
2018-02-26 17:18:29 +03:00
|
|
|
notify_touch_normalized(struct weston_touch_device *device,
|
|
|
|
const struct timespec *time,
|
|
|
|
int touch_id,
|
|
|
|
double x, double y,
|
|
|
|
const struct weston_point2d_device_normalized *norm,
|
|
|
|
int touch_type);
|
|
|
|
|
|
|
|
/** Feed in touch down, motion, and up events, non-calibratable device.
|
|
|
|
*
|
|
|
|
* @sa notify_touch_cal
|
|
|
|
*/
|
|
|
|
static inline void
|
2018-02-26 15:43:00 +03:00
|
|
|
notify_touch(struct weston_touch_device *device, const struct timespec *time,
|
2018-02-26 17:18:29 +03:00
|
|
|
int touch_id, double x, double y, int touch_type)
|
|
|
|
{
|
|
|
|
notify_touch_normalized(device, time, touch_id, x, y, NULL, touch_type);
|
|
|
|
}
|
|
|
|
|
2014-04-12 11:39:51 +04:00
|
|
|
void
|
2018-02-26 15:43:00 +03:00
|
|
|
notify_touch_frame(struct weston_touch_device *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
|
|
|
|
2015-11-07 00:56:09 +03:00
|
|
|
void
|
2018-02-26 15:43:00 +03:00
|
|
|
notify_touch_cancel(struct weston_touch_device *device);
|
2015-11-07 00:56:09 +03:00
|
|
|
|
input: introduce touch event mode for calibrator
In addition to the normal touch event processing mode, introduce a new
mode for calibrating a touchscreen input device.
In the calibration mode, normal touch event processing is skipped, and
the raw events are forwarded to the calibrator instead. The calibrator
is not yet implemented, so the calls will be added in a following patch.
To switch between modes, two functions are added, one for entering each
mode. The mode switch happens only when no touches are down on any touch
device, to avoid confusing touch grabs and clients. To realise this, the
state machine has four states: prepare and actual state for both normal
and calibrator modes.
At this point nothing will attempt to change the touch event mode.
The new calibrator mode is necessary, because when calibrating a
touchscreen, the touch events must be routed to the calibration client
directly. The touch coordinates are expected to be wrong, so they cannot
go through the normal focus surface picking. The calibrator code also
cannot use the normal touch grab interface, because it needs to be able
to distinguish between different physical touch input devices, even if
they are part of the same weston_seat. This requirement makes
calibration special enough to warrant the new mode, a sort of "super
grab".
Co-developed by Louis-Francis and Pekka.
Signed-off-by: Louis-Francis Ratté-Boulianne <lfrb@collabora.com>
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
v1 Tested-by: Matt Hoosier <matt.hoosier@gmail.com>
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
2017-11-29 04:42:47 +03:00
|
|
|
void
|
|
|
|
weston_compositor_set_touch_mode_normal(struct weston_compositor *compositor);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_compositor_set_touch_mode_calib(struct weston_compositor *compositor);
|
|
|
|
|
2017-11-29 04:42:47 +03:00
|
|
|
void
|
|
|
|
touch_calibrator_mode_changed(struct weston_compositor *compositor);
|
|
|
|
|
|
|
|
void
|
|
|
|
notify_touch_calibrator(struct weston_touch_device *device,
|
|
|
|
const struct timespec *time, int32_t slot,
|
|
|
|
const struct weston_point2d_device_normalized *norm,
|
|
|
|
int touch_type);
|
|
|
|
|
|
|
|
void
|
|
|
|
notify_touch_calibrator_frame(struct weston_touch_device *device);
|
|
|
|
|
|
|
|
void
|
|
|
|
notify_touch_calibrator_cancel(struct weston_touch_device *device);
|
input: introduce touch event mode for calibrator
In addition to the normal touch event processing mode, introduce a new
mode for calibrating a touchscreen input device.
In the calibration mode, normal touch event processing is skipped, and
the raw events are forwarded to the calibrator instead. The calibrator
is not yet implemented, so the calls will be added in a following patch.
To switch between modes, two functions are added, one for entering each
mode. The mode switch happens only when no touches are down on any touch
device, to avoid confusing touch grabs and clients. To realise this, the
state machine has four states: prepare and actual state for both normal
and calibrator modes.
At this point nothing will attempt to change the touch event mode.
The new calibrator mode is necessary, because when calibrating a
touchscreen, the touch events must be routed to the calibration client
directly. The touch coordinates are expected to be wrong, so they cannot
go through the normal focus surface picking. The calibrator code also
cannot use the normal touch grab interface, because it needs to be able
to distinguish between different physical touch input devices, even if
they are part of the same weston_seat. This requirement makes
calibration special enough to warrant the new mode, a sort of "super
grab".
Co-developed by Louis-Francis and Pekka.
Signed-off-by: Louis-Francis Ratté-Boulianne <lfrb@collabora.com>
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
v1 Tested-by: Matt Hoosier <matt.hoosier@gmail.com>
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
2017-11-29 04:42:47 +03:00
|
|
|
|
2014-07-09 23:12:56 +04:00
|
|
|
void
|
|
|
|
weston_layer_entry_insert(struct weston_layer_entry *list,
|
|
|
|
struct weston_layer_entry *entry);
|
|
|
|
void
|
|
|
|
weston_layer_entry_remove(struct weston_layer_entry *entry);
|
2012-02-29 21:42:35 +04:00
|
|
|
void
|
2016-12-17 15:40:51 +03:00
|
|
|
weston_layer_init(struct weston_layer *layer,
|
|
|
|
struct weston_compositor *compositor);
|
|
|
|
void
|
|
|
|
weston_layer_set_position(struct weston_layer *layer,
|
|
|
|
enum weston_layer_position position);
|
|
|
|
void
|
|
|
|
weston_layer_unset_position(struct weston_layer *layer);
|
2012-02-29 21:42:35 +04:00
|
|
|
|
2014-07-09 23:12:57 +04:00
|
|
|
void
|
|
|
|
weston_layer_set_mask(struct weston_layer *layer, int x, int y, int width, int height);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_layer_set_mask_infinite(struct weston_layer *layer);
|
|
|
|
|
2018-07-20 10:38:25 +03:00
|
|
|
bool
|
|
|
|
weston_layer_mask_is_infinite(struct weston_layer *layer);
|
|
|
|
|
2012-08-03 19:30:18 +04:00
|
|
|
void
|
2013-10-23 09:58:31 +04:00
|
|
|
weston_plane_init(struct weston_plane *plane,
|
|
|
|
struct weston_compositor *ec,
|
|
|
|
int32_t x, int32_t y);
|
2012-08-03 19:30:18 +04:00
|
|
|
void
|
|
|
|
weston_plane_release(struct weston_plane *plane);
|
|
|
|
|
2013-03-05 19:30:27 +04:00
|
|
|
void
|
|
|
|
weston_compositor_stack_plane(struct weston_compositor *ec,
|
|
|
|
struct weston_plane *plane,
|
|
|
|
struct weston_plane *above);
|
|
|
|
|
compositor: set presentation.presented flags
Change weston_output_finish_frame() signature so that backends are
required to set the flags, that will be reported on the Presentation
'presented' event. This is meant for output-wide feedback flags. Flags
that vary per wl_surface are subject for the following patch.
All start_repaint_loop functions use the special private flag
PRESENTATION_FEEDBACK_INVALID to mark, that this call of
weston_output_finish_frame() cannot trigger the 'presented' event. If it
does, we now hit an assert, and should then investigate why a fake update
triggered Presentation feedback.
DRM:
Page flip is always vsync'd, and always gets the completion timestamp
from the kernel which should correspond well to hardware. Completion is
triggered by the kernel/hardware.
Vblank handler is only used with the broken planes path, therefore do
not report VSYNC, because we cannot guarantee all the planes updated at
the same time. We cannot set the INVALID, because it would abort the
compositor if the broken planes path was ever used. This is a hack that
will get fixed with nuclear pageflip support in the future.
fbdev:
No vsync, update done by copy, no completion event from hardware, and
completion time is totally fake.
headless:
No real output to update.
RDP:
Guessing that maybe no vsync, fake time, and copy make sense (pixels
sent over network). Also no event that the pixels have been shown?
RPI:
Presumably Dispmanx updates are vsync'd. We get a completion event from
the driver, but need to read the clock ourselves, so the completion time
is somewhat unreliable. Zero-copy flag not implemented though it would
be theoretically possible with EGL clients (zero-copy is a per-surface
flag anyway, so in this patch).
Wayland:
No information how the host compositor is doing updates, so make a safe
guess without assuming vsync or hardware completion event. While we do
get some timestamp from the host compositor, it is not the completion
time. Would need to hook to the Presentation extension of the host
compositor to get more accurate flags.
X11:
No idea about vsync, completion event, or copying. Also the timestamp is
a fake.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
Reviewed-by: Mario Kleiner <mario.kleiner.de@gmail.com>
Tested-by: Mario Kleiner <mario.kleiner.de@gmail.com>
Acked-by: Mario Kleiner <mario.kleiner.de@gmail.com>
2014-12-17 17:20:40 +03:00
|
|
|
/* An invalid flag in presented_flags to catch logic errors. */
|
2016-02-18 17:53:27 +03:00
|
|
|
#define WP_PRESENTATION_FEEDBACK_INVALID (1U << 31)
|
compositor: set presentation.presented flags
Change weston_output_finish_frame() signature so that backends are
required to set the flags, that will be reported on the Presentation
'presented' event. This is meant for output-wide feedback flags. Flags
that vary per wl_surface are subject for the following patch.
All start_repaint_loop functions use the special private flag
PRESENTATION_FEEDBACK_INVALID to mark, that this call of
weston_output_finish_frame() cannot trigger the 'presented' event. If it
does, we now hit an assert, and should then investigate why a fake update
triggered Presentation feedback.
DRM:
Page flip is always vsync'd, and always gets the completion timestamp
from the kernel which should correspond well to hardware. Completion is
triggered by the kernel/hardware.
Vblank handler is only used with the broken planes path, therefore do
not report VSYNC, because we cannot guarantee all the planes updated at
the same time. We cannot set the INVALID, because it would abort the
compositor if the broken planes path was ever used. This is a hack that
will get fixed with nuclear pageflip support in the future.
fbdev:
No vsync, update done by copy, no completion event from hardware, and
completion time is totally fake.
headless:
No real output to update.
RDP:
Guessing that maybe no vsync, fake time, and copy make sense (pixels
sent over network). Also no event that the pixels have been shown?
RPI:
Presumably Dispmanx updates are vsync'd. We get a completion event from
the driver, but need to read the clock ourselves, so the completion time
is somewhat unreliable. Zero-copy flag not implemented though it would
be theoretically possible with EGL clients (zero-copy is a per-surface
flag anyway, so in this patch).
Wayland:
No information how the host compositor is doing updates, so make a safe
guess without assuming vsync or hardware completion event. While we do
get some timestamp from the host compositor, it is not the completion
time. Would need to hook to the Presentation extension of the host
compositor to get more accurate flags.
X11:
No idea about vsync, completion event, or copying. Also the timestamp is
a fake.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
Reviewed-by: Mario Kleiner <mario.kleiner.de@gmail.com>
Tested-by: Mario Kleiner <mario.kleiner.de@gmail.com>
Acked-by: Mario Kleiner <mario.kleiner.de@gmail.com>
2014-12-17 17:20:40 +03: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
|
|
|
void
|
2014-09-24 06:08:45 +04:00
|
|
|
weston_output_finish_frame(struct weston_output *output,
|
compositor: set presentation.presented flags
Change weston_output_finish_frame() signature so that backends are
required to set the flags, that will be reported on the Presentation
'presented' event. This is meant for output-wide feedback flags. Flags
that vary per wl_surface are subject for the following patch.
All start_repaint_loop functions use the special private flag
PRESENTATION_FEEDBACK_INVALID to mark, that this call of
weston_output_finish_frame() cannot trigger the 'presented' event. If it
does, we now hit an assert, and should then investigate why a fake update
triggered Presentation feedback.
DRM:
Page flip is always vsync'd, and always gets the completion timestamp
from the kernel which should correspond well to hardware. Completion is
triggered by the kernel/hardware.
Vblank handler is only used with the broken planes path, therefore do
not report VSYNC, because we cannot guarantee all the planes updated at
the same time. We cannot set the INVALID, because it would abort the
compositor if the broken planes path was ever used. This is a hack that
will get fixed with nuclear pageflip support in the future.
fbdev:
No vsync, update done by copy, no completion event from hardware, and
completion time is totally fake.
headless:
No real output to update.
RDP:
Guessing that maybe no vsync, fake time, and copy make sense (pixels
sent over network). Also no event that the pixels have been shown?
RPI:
Presumably Dispmanx updates are vsync'd. We get a completion event from
the driver, but need to read the clock ourselves, so the completion time
is somewhat unreliable. Zero-copy flag not implemented though it would
be theoretically possible with EGL clients (zero-copy is a per-surface
flag anyway, so in this patch).
Wayland:
No information how the host compositor is doing updates, so make a safe
guess without assuming vsync or hardware completion event. While we do
get some timestamp from the host compositor, it is not the completion
time. Would need to hook to the Presentation extension of the host
compositor to get more accurate flags.
X11:
No idea about vsync, completion event, or copying. Also the timestamp is
a fake.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
Reviewed-by: Mario Kleiner <mario.kleiner.de@gmail.com>
Tested-by: Mario Kleiner <mario.kleiner.de@gmail.com>
Acked-by: Mario Kleiner <mario.kleiner.de@gmail.com>
2014-12-17 17:20:40 +03:00
|
|
|
const struct timespec *stamp,
|
|
|
|
uint32_t presented_flags);
|
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
|
|
|
void
|
2012-06-20 08:35:59 +04:00
|
|
|
weston_output_schedule_repaint(struct weston_output *output);
|
|
|
|
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
|
|
|
weston_output_damage(struct weston_output *output);
|
|
|
|
void
|
|
|
|
weston_compositor_schedule_repaint(struct weston_compositor *compositor);
|
|
|
|
void
|
|
|
|
weston_compositor_fade(struct weston_compositor *compositor, float tint);
|
|
|
|
void
|
|
|
|
weston_compositor_damage_all(struct weston_compositor *compositor);
|
|
|
|
void
|
|
|
|
weston_compositor_unlock(struct weston_compositor *compositor);
|
|
|
|
void
|
|
|
|
weston_compositor_wake(struct weston_compositor *compositor);
|
|
|
|
void
|
2013-03-29 16:01:56 +04:00
|
|
|
weston_compositor_offscreen(struct weston_compositor *compositor);
|
|
|
|
void
|
2013-02-21 20:35:22 +04:00
|
|
|
weston_compositor_sleep(struct weston_compositor *compositor);
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view *
|
|
|
|
weston_compositor_pick_view(struct weston_compositor *compositor,
|
|
|
|
wl_fixed_t x, wl_fixed_t y,
|
|
|
|
wl_fixed_t *sx, wl_fixed_t *sy);
|
2012-02-15 19:02:57 +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
|
|
|
|
|
|
|
struct weston_binding;
|
2015-07-15 21:00:36 +03:00
|
|
|
typedef void (*weston_key_binding_handler_t)(struct weston_keyboard *keyboard,
|
2017-11-16 19:20:57 +03:00
|
|
|
const struct timespec *time,
|
|
|
|
uint32_t key,
|
2012-05-30 19:31:58 +04:00
|
|
|
void *data);
|
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_binding *
|
2012-05-30 19:31:58 +04:00
|
|
|
weston_compositor_add_key_binding(struct weston_compositor *compositor,
|
|
|
|
uint32_t key,
|
|
|
|
enum weston_keyboard_modifier modifier,
|
|
|
|
weston_key_binding_handler_t binding,
|
|
|
|
void *data);
|
|
|
|
|
2015-07-15 21:00:36 +03:00
|
|
|
typedef void (*weston_modifier_binding_handler_t)(struct weston_keyboard *keyboard,
|
2013-11-19 14:37:12 +04:00
|
|
|
enum weston_keyboard_modifier modifier,
|
|
|
|
void *data);
|
|
|
|
struct weston_binding *
|
|
|
|
weston_compositor_add_modifier_binding(struct weston_compositor *compositor,
|
|
|
|
enum weston_keyboard_modifier modifier,
|
|
|
|
weston_modifier_binding_handler_t binding,
|
|
|
|
void *data);
|
|
|
|
|
2015-07-15 21:00:36 +03:00
|
|
|
typedef void (*weston_button_binding_handler_t)(struct weston_pointer *pointer,
|
2017-11-16 19:20:55 +03:00
|
|
|
const struct timespec *time,
|
|
|
|
uint32_t button,
|
2012-05-30 19:31:58 +04:00
|
|
|
void *data);
|
|
|
|
struct weston_binding *
|
|
|
|
weston_compositor_add_button_binding(struct weston_compositor *compositor,
|
|
|
|
uint32_t button,
|
|
|
|
enum weston_keyboard_modifier modifier,
|
|
|
|
weston_button_binding_handler_t binding,
|
|
|
|
void *data);
|
|
|
|
|
2015-07-15 21:00:36 +03:00
|
|
|
typedef void (*weston_touch_binding_handler_t)(struct weston_touch *touch,
|
2017-11-16 19:20:58 +03:00
|
|
|
const struct timespec *time,
|
2013-10-03 19:43:04 +04:00
|
|
|
void *data);
|
|
|
|
struct weston_binding *
|
|
|
|
weston_compositor_add_touch_binding(struct weston_compositor *compositor,
|
|
|
|
enum weston_keyboard_modifier modifier,
|
|
|
|
weston_touch_binding_handler_t binding,
|
|
|
|
void *data);
|
|
|
|
|
2015-07-15 21:00:36 +03:00
|
|
|
typedef void (*weston_axis_binding_handler_t)(struct weston_pointer *pointer,
|
2017-11-16 19:20:56 +03:00
|
|
|
const struct timespec *time,
|
2016-01-18 08:58:17 +03:00
|
|
|
struct weston_pointer_axis_event *event,
|
|
|
|
void *data);
|
2012-05-30 19:31:58 +04:00
|
|
|
struct weston_binding *
|
|
|
|
weston_compositor_add_axis_binding(struct weston_compositor *compositor,
|
|
|
|
uint32_t axis,
|
|
|
|
enum weston_keyboard_modifier modifier,
|
|
|
|
weston_axis_binding_handler_t binding,
|
|
|
|
void *data);
|
2012-11-08 19:20:45 +04:00
|
|
|
struct weston_binding *
|
|
|
|
weston_compositor_add_debug_binding(struct weston_compositor *compositor,
|
|
|
|
uint32_t key,
|
|
|
|
weston_key_binding_handler_t binding,
|
|
|
|
void *data);
|
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
|
|
|
void
|
|
|
|
weston_binding_destroy(struct weston_binding *binding);
|
|
|
|
|
2015-02-19 18:02:13 +03:00
|
|
|
void
|
|
|
|
weston_install_debug_key_binding(struct weston_compositor *compositor,
|
|
|
|
uint32_t mod);
|
|
|
|
|
2012-01-03 20:29:15 +04:00
|
|
|
void
|
|
|
|
weston_binding_list_destroy_all(struct wl_list *list);
|
|
|
|
|
2014-11-19 14:43:32 +03:00
|
|
|
void
|
2012-05-30 19:31:58 +04:00
|
|
|
weston_compositor_run_key_binding(struct weston_compositor *compositor,
|
2015-07-15 21:00:43 +03:00
|
|
|
struct weston_keyboard *keyboard,
|
2017-11-16 19:20:57 +03:00
|
|
|
const struct timespec *time,
|
2012-05-30 19:31:58 +04:00
|
|
|
uint32_t key,
|
|
|
|
enum wl_keyboard_key_state state);
|
2013-11-19 14:37:12 +04:00
|
|
|
|
|
|
|
void
|
|
|
|
weston_compositor_run_modifier_binding(struct weston_compositor *compositor,
|
2015-07-15 21:00:43 +03:00
|
|
|
struct weston_keyboard *keyboard,
|
2013-11-19 14:37:12 +04:00
|
|
|
enum weston_keyboard_modifier modifier,
|
|
|
|
enum wl_keyboard_key_state state);
|
2012-05-30 19:31:58 +04:00
|
|
|
void
|
|
|
|
weston_compositor_run_button_binding(struct weston_compositor *compositor,
|
2017-11-16 19:20:55 +03:00
|
|
|
struct weston_pointer *pointer,
|
|
|
|
const struct timespec *time,
|
2012-05-30 19:31:58 +04:00
|
|
|
uint32_t button,
|
|
|
|
enum wl_pointer_button_state value);
|
2013-10-03 19:43:04 +04:00
|
|
|
void
|
|
|
|
weston_compositor_run_touch_binding(struct weston_compositor *compositor,
|
2017-11-16 19:20:58 +03:00
|
|
|
struct weston_touch *touch,
|
|
|
|
const struct timespec *time,
|
2013-10-03 19:43:04 +04:00
|
|
|
int touch_type);
|
2013-03-08 00:50:00 +04:00
|
|
|
int
|
2012-05-30 19:31:58 +04:00
|
|
|
weston_compositor_run_axis_binding(struct weston_compositor *compositor,
|
2017-11-16 19:20:56 +03:00
|
|
|
struct weston_pointer *pointer,
|
|
|
|
const struct timespec *time,
|
2016-01-18 08:58:17 +03:00
|
|
|
struct weston_pointer_axis_event *event);
|
2012-11-08 19:20:45 +04:00
|
|
|
int
|
|
|
|
weston_compositor_run_debug_binding(struct weston_compositor *compositor,
|
2017-11-16 19:20:57 +03:00
|
|
|
struct weston_keyboard *keyboard,
|
|
|
|
const struct timespec *time,
|
2012-11-08 19:20:45 +04:00
|
|
|
uint32_t key,
|
|
|
|
enum wl_keyboard_key_state state);
|
2012-05-30 19:31:58 +04:00
|
|
|
|
2013-11-15 02:42:53 +04:00
|
|
|
void
|
|
|
|
weston_compositor_set_default_pointer_grab(struct weston_compositor *compositor,
|
|
|
|
const struct weston_pointer_grab_interface *interface);
|
|
|
|
|
2012-01-30 17:04:04 +04:00
|
|
|
int
|
|
|
|
weston_environment_get_fd(const char *env);
|
|
|
|
|
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_surface *
|
2012-01-27 20:58:31 +04:00
|
|
|
weston_surface_create(struct weston_compositor *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
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view *
|
|
|
|
weston_view_create(struct weston_surface *surface);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_view_destroy(struct weston_view *view);
|
|
|
|
|
2012-02-29 21:42:35 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_set_position(struct weston_view *view,
|
|
|
|
float x, float y);
|
2012-02-29 21:42:35 +04:00
|
|
|
|
2012-02-13 15:03:59 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_set_transform_parent(struct weston_view *view,
|
|
|
|
struct weston_view *parent);
|
|
|
|
|
2015-02-16 15:39:11 +03:00
|
|
|
void
|
|
|
|
weston_view_set_mask(struct weston_view *view,
|
|
|
|
int x, int y, int width, int height);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_view_set_mask_infinite(struct weston_view *view);
|
|
|
|
|
2014-10-03 22:13:42 +04:00
|
|
|
bool
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_is_mapped(struct weston_view *view);
|
2012-02-13 15:03:59 +04:00
|
|
|
|
2013-03-08 16:56:50 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_schedule_repaint(struct weston_view *view);
|
2013-03-08 16:56:50 +04:00
|
|
|
|
2014-10-03 22:13:42 +04:00
|
|
|
bool
|
2012-03-27 18:36:36 +04:00
|
|
|
weston_surface_is_mapped(struct weston_surface *surface);
|
|
|
|
|
2014-09-19 01:46:49 +04:00
|
|
|
void
|
2013-12-05 06:32:03 +04:00
|
|
|
weston_surface_set_size(struct weston_surface *surface,
|
|
|
|
int32_t width, int32_t height);
|
|
|
|
|
2012-08-04 00:29:12 +04:00
|
|
|
void
|
|
|
|
weston_surface_schedule_repaint(struct weston_surface *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
|
|
|
void
|
|
|
|
weston_surface_damage(struct weston_surface *surface);
|
|
|
|
|
2012-02-24 08:03:14 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_damage_below(struct weston_view *view);
|
2012-02-24 08:03:14 +04:00
|
|
|
|
2012-08-03 19:30:18 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_move_to_plane(struct weston_view *view,
|
|
|
|
struct weston_plane *plane);
|
|
|
|
void
|
|
|
|
weston_view_unmap(struct weston_view *view);
|
|
|
|
|
2012-06-27 05:19:23 +04:00
|
|
|
void
|
|
|
|
weston_surface_unmap(struct weston_surface *surface);
|
|
|
|
|
shell: keyboard focus and restacking fixes for sub-surfaces
The shell needs to redirect some actions to the parent surface, when
they originally target a sub-surface. This patch implements the
following:
- Move, resize, and rotate bindings always target the parent surface.
- Opacity (full-surface alpha) binding targets the parent surface. This
is broken, because it should change the opacity of the whole compound
window, which is difficult to implement in the renderer.
- click_to_activate_binding() needs to check the shell surface type from
the main surface, because sub-surface would produce SHELL_SURFACE_NONE
and prevent activation.
- Also activate() needs to check the type from the main surface, and
restack the main surface. Keyboard focus is assigned to the original
(sub-)surface.
- focus_state_surface_destroy() needs to handle sub-surfaces: only the
main surface will be in a layer list. If the destroyed surface is
indeed a sub-surface, activate the main surface next. This way a
client that destroys a focused sub-surface still retains focus in the
same window.
- The workspace_manager.move_surface request can accept also
sub-surfaces, and it will move the corresponding main surface.
Changes in v2:
- do not special-case keyboard focus for sub-surfaces
- fix surface type checks for sub-surfaces in shell, fix restacking of
sub-surfaces in shell, fix focus_state_surface_destroy()
Changes in v3:
- Renamed weston_surface_get_parent() to
weston_surface_get_main_surface() to be more explicit that this is
about sub-surfaces
- Fixed move_surface_to_workspace() to handle keyboard focus on a
sub-surface.
- Used a temporary variable in several places to clarify code, instead
of reassigning a variable.
- Fixed workspace_manager_move_surface() to deal with sub-surfaces.
Signed-off-by: Pekka Paalanen <ppaalanen@gmail.com>
2013-04-25 14:57:44 +04:00
|
|
|
struct weston_surface *
|
|
|
|
weston_surface_get_main_surface(struct weston_surface *surface);
|
|
|
|
|
compositor: send error for surface role resets
With the more accurate definition of wl_surface roles in Wayland,
enforce the restriction: a role is always set permanently, and
attempting to change it is a protocol error.
This patch is based on Jasper's patch:
http://lists.freedesktop.org/archives/wayland-devel/2014-August/016811.html
The difference in this patch compared to his are:
- send role errors on the interface whose request triggers it, not on
wl_surface
- an interface could have several requests assigning different roles,
cannot use wl_interface as the unique key; use an arbitary string
instead
- ensure in window-manager.c that create_shell_surface() ->
create_common_surface() is never called with surface->configure set,
to avoid compositor abort
- use wl_resource_post_no_memory() where appropriate instead of
hand-rolling it with wl_resource_post_error()
Ideally we would not add weston_surface::role_name field, but use
weston_surface::configure. At the moment this is not possible though,
because at least shell.c uses several different roles with the same
configure function. Drag'n'drop uses two configure functions for the
same role. The configure hook is also reset in several places,
which is not good for role tracking.
This patch overlooks the wl_surface roles assigned in privileged
extensions: screensaver, panel, background, lock, input panel.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
Reviewed-by: Jasper St. Pierre <jstpierre@mecheye.net>
2014-10-01 16:02:41 +04:00
|
|
|
int
|
|
|
|
weston_surface_set_role(struct weston_surface *surface,
|
|
|
|
const char *role_name,
|
|
|
|
struct wl_resource *error_resource,
|
|
|
|
uint32_t error_code);
|
2016-08-12 11:41:37 +03:00
|
|
|
const char *
|
|
|
|
weston_surface_get_role(struct weston_surface *surface);
|
compositor: send error for surface role resets
With the more accurate definition of wl_surface roles in Wayland,
enforce the restriction: a role is always set permanently, and
attempting to change it is a protocol error.
This patch is based on Jasper's patch:
http://lists.freedesktop.org/archives/wayland-devel/2014-August/016811.html
The difference in this patch compared to his are:
- send role errors on the interface whose request triggers it, not on
wl_surface
- an interface could have several requests assigning different roles,
cannot use wl_interface as the unique key; use an arbitary string
instead
- ensure in window-manager.c that create_shell_surface() ->
create_common_surface() is never called with surface->configure set,
to avoid compositor abort
- use wl_resource_post_no_memory() where appropriate instead of
hand-rolling it with wl_resource_post_error()
Ideally we would not add weston_surface::role_name field, but use
weston_surface::configure. At the moment this is not possible though,
because at least shell.c uses several different roles with the same
configure function. Drag'n'drop uses two configure functions for the
same role. The configure hook is also reset in several places,
which is not good for role tracking.
This patch overlooks the wl_surface roles assigned in privileged
extensions: screensaver, panel, background, lock, input panel.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
Reviewed-by: Jasper St. Pierre <jstpierre@mecheye.net>
2014-10-01 16:02:41 +04:00
|
|
|
|
compositor: add weston_surface_set_label_func()
When printing out logs from Weston's actions, mainly for debugging, it
can be very difficult to identify the different surfaces. Inspecting
the configure function pointer is not useful, as the configure functions
may live in modules.
Add vfunc get_label to weston_surface, which will produce a short,
human-readable description of the surface, which allows identifying it
better, rather than just looking at the surface size, for instance.
Set the label function from most parts of Weston, to identify cursors and
drag icons, and panels, backgrounds, screensavers and lock surfaces, and
the desktop shell's application surfaces.
v2: renamed 'description' to 'label', so we get
weston_surface_set_label_func().
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
2014-08-06 20:36:51 +04:00
|
|
|
void
|
|
|
|
weston_surface_set_label_func(struct weston_surface *surface,
|
|
|
|
int (*desc)(struct weston_surface *,
|
|
|
|
char *, size_t));
|
|
|
|
|
2015-02-09 14:16:57 +03:00
|
|
|
void
|
|
|
|
weston_surface_get_content_size(struct weston_surface *surface,
|
|
|
|
int *width, int *height);
|
|
|
|
|
2016-08-12 11:41:34 +03:00
|
|
|
struct weston_geometry
|
|
|
|
weston_surface_get_bounding_box(struct weston_surface *surface);
|
|
|
|
|
2015-02-09 14:16:57 +03:00
|
|
|
int
|
|
|
|
weston_surface_copy_content(struct weston_surface *surface,
|
|
|
|
void *target, size_t size,
|
|
|
|
int src_x, int src_y,
|
|
|
|
int width, int height);
|
|
|
|
|
2013-06-21 05:38:23 +04:00
|
|
|
struct weston_buffer *
|
|
|
|
weston_buffer_from_resource(struct wl_resource *resource);
|
|
|
|
|
compositor: introduce weston_buffer_reference
The wl_buffer reference counting API has been inconsistent. You would
manually increment the refcount and register a destroy listener, as
opposed to calling weston_buffer_post_release(), which internally
decremented the refcount, and then removing a list item.
Replace both cases with a single function:
weston_buffer_reference(weston_buffer_reference *ref, wl_buffer *buffer)
Buffer is assigned to ref->buffer, while taking care of all the refcounting
and release posting. You take a reference by passing a non-NULL buffer, and
release a reference by passing NULL as buffer. The function uses an
internal wl_buffer destroy listener, so the pointer gets reset on
destruction automatically.
This is inspired by the pipe_resource_reference() of Mesa, and modified
by krh's suggestion to add struct weston_buffer_reference.
Additionally, when a surface gets destroyed, the associated wl_buffer
will send a release event. Often the buffer is already destroyed on
client side, so the event will be discarded by libwayland-client.
Compositor-drm.c is converted to use weston_buffer_reference.
Signed-off-by: Pekka Paalanen <ppaalanen@gmail.com>
2012-12-04 17:58:12 +04:00
|
|
|
void
|
|
|
|
weston_buffer_reference(struct weston_buffer_reference *ref,
|
2013-06-21 05:38:23 +04:00
|
|
|
struct weston_buffer *buffer);
|
compositor: introduce weston_buffer_reference
The wl_buffer reference counting API has been inconsistent. You would
manually increment the refcount and register a destroy listener, as
opposed to calling weston_buffer_post_release(), which internally
decremented the refcount, and then removing a list item.
Replace both cases with a single function:
weston_buffer_reference(weston_buffer_reference *ref, wl_buffer *buffer)
Buffer is assigned to ref->buffer, while taking care of all the refcounting
and release posting. You take a reference by passing a non-NULL buffer, and
release a reference by passing NULL as buffer. The function uses an
internal wl_buffer destroy listener, so the pointer gets reset on
destruction automatically.
This is inspired by the pipe_resource_reference() of Mesa, and modified
by krh's suggestion to add struct weston_buffer_reference.
Additionally, when a surface gets destroyed, the associated wl_buffer
will send a release event. Often the buffer is already destroyed on
client side, so the event will be discarded by libwayland-client.
Compositor-drm.c is converted to use weston_buffer_reference.
Signed-off-by: Pekka Paalanen <ppaalanen@gmail.com>
2012-12-04 17:58:12 +04:00
|
|
|
|
2017-11-16 19:21:01 +03:00
|
|
|
void
|
|
|
|
weston_compositor_get_time(struct timespec *time);
|
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
|
|
|
|
2018-07-20 11:46:24 +03:00
|
|
|
char *
|
|
|
|
weston_compositor_print_scene_graph(struct weston_compositor *ec);
|
|
|
|
|
2014-10-12 00:56:24 +04:00
|
|
|
void
|
|
|
|
weston_compositor_destroy(struct weston_compositor *ec);
|
|
|
|
struct weston_compositor *
|
|
|
|
weston_compositor_create(struct wl_display *display, void *user_data);
|
2016-06-03 15:23:46 +03:00
|
|
|
|
|
|
|
enum weston_compositor_backend {
|
|
|
|
WESTON_BACKEND_DRM,
|
|
|
|
WESTON_BACKEND_FBDEV,
|
|
|
|
WESTON_BACKEND_HEADLESS,
|
|
|
|
WESTON_BACKEND_RDP,
|
|
|
|
WESTON_BACKEND_WAYLAND,
|
|
|
|
WESTON_BACKEND_X11,
|
|
|
|
};
|
|
|
|
|
2016-06-03 14:49:54 +03:00
|
|
|
int
|
|
|
|
weston_compositor_load_backend(struct weston_compositor *compositor,
|
2016-06-03 15:23:46 +03:00
|
|
|
enum weston_compositor_backend backend,
|
2016-06-03 14:49:54 +03:00
|
|
|
struct weston_backend_config *config_base);
|
2014-10-12 00:56:24 +04:00
|
|
|
void
|
|
|
|
weston_compositor_exit(struct weston_compositor *ec);
|
|
|
|
void *
|
|
|
|
weston_compositor_get_user_data(struct weston_compositor *compositor);
|
2014-09-24 06:08:45 +04:00
|
|
|
int
|
|
|
|
weston_compositor_set_presentation_clock(struct weston_compositor *compositor,
|
|
|
|
clockid_t clk_id);
|
|
|
|
int
|
|
|
|
weston_compositor_set_presentation_clock_software(
|
|
|
|
struct weston_compositor *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
|
|
|
void
|
2015-03-18 13:17:26 +03:00
|
|
|
weston_compositor_read_presentation_clock(
|
|
|
|
const struct weston_compositor *compositor,
|
|
|
|
struct timespec *ts);
|
|
|
|
|
2014-09-29 22:18:40 +04:00
|
|
|
bool
|
|
|
|
weston_compositor_import_dmabuf(struct weston_compositor *compositor,
|
|
|
|
struct linux_dmabuf_buffer *buffer);
|
|
|
|
|
2015-03-18 13:17:26 +03:00
|
|
|
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
|
|
|
weston_compositor_shutdown(struct weston_compositor *ec);
|
|
|
|
void
|
2014-10-29 21:44:33 +03:00
|
|
|
weston_compositor_exit_with_code(struct weston_compositor *compositor,
|
|
|
|
int exit_code);
|
|
|
|
void
|
2012-06-18 04:10:59 +04:00
|
|
|
weston_output_init_zoom(struct weston_output *output);
|
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_output_update_zoom(struct weston_output *output);
|
2012-02-23 01:21:41 +04:00
|
|
|
void
|
2015-07-23 22:55:15 +03:00
|
|
|
weston_output_activate_zoom(struct weston_output *output,
|
|
|
|
struct weston_seat *seat);
|
2013-11-15 02:42:51 +04:00
|
|
|
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
|
|
|
weston_output_move(struct weston_output *output, int x, int y);
|
2016-09-30 15:11:12 +03:00
|
|
|
|
2017-11-07 11:15:01 +03:00
|
|
|
void
|
|
|
|
weston_output_add_destroy_listener(struct weston_output *output,
|
|
|
|
struct wl_listener *listener);
|
|
|
|
struct wl_listener *
|
|
|
|
weston_output_get_destroy_listener(struct weston_output *output,
|
|
|
|
wl_notify_func_t notify);
|
2015-05-06 21:41:57 +03:00
|
|
|
void
|
2017-08-16 12:07:14 +03:00
|
|
|
weston_output_release(struct weston_output *output);
|
2013-07-23 01:33:42 +04:00
|
|
|
void
|
2013-10-28 07:25:00 +04:00
|
|
|
weston_output_transform_coordinate(struct weston_output *output,
|
2016-03-22 18:44:54 +03:00
|
|
|
double device_x, double device_y,
|
|
|
|
double *x, double *y);
|
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
|
|
|
|
|
|
|
void
|
2013-05-31 21:09:50 +04:00
|
|
|
weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec,
|
|
|
|
const char *seat_name);
|
2012-05-30 19:32:02 +04:00
|
|
|
void
|
|
|
|
weston_seat_init_pointer(struct weston_seat *seat);
|
2013-10-18 01:04:05 +04:00
|
|
|
void
|
|
|
|
weston_seat_release_pointer(struct weston_seat *seat);
|
2013-02-16 23:29:24 +04:00
|
|
|
int
|
2012-05-30 19:32:06 +04:00
|
|
|
weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap);
|
2012-05-30 19:32:02 +04:00
|
|
|
void
|
2013-10-18 01:04:05 +04:00
|
|
|
weston_seat_release_keyboard(struct weston_seat *seat);
|
|
|
|
void
|
2012-05-30 19:32:02 +04:00
|
|
|
weston_seat_init_touch(struct weston_seat *seat);
|
2013-04-18 23:40:10 +04:00
|
|
|
void
|
2013-10-18 01:04:05 +04:00
|
|
|
weston_seat_release_touch(struct weston_seat *seat);
|
|
|
|
void
|
2013-05-07 05:51:21 +04:00
|
|
|
weston_seat_repick(struct weston_seat *seat);
|
2013-10-10 21:44:19 +04:00
|
|
|
void
|
|
|
|
weston_seat_update_keymap(struct weston_seat *seat, struct xkb_keymap *keymap);
|
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
|
|
|
|
2012-01-03 20:29:15 +04:00
|
|
|
void
|
2012-05-16 21:45:18 +04:00
|
|
|
weston_seat_release(struct weston_seat *seat);
|
2013-04-18 23:40:10 +04:00
|
|
|
int
|
2016-06-02 21:48:08 +03:00
|
|
|
weston_compositor_set_xkb_rule_names(struct weston_compositor *ec,
|
|
|
|
struct xkb_rule_names *names);
|
2013-04-18 23:40:10 +04:00
|
|
|
void
|
|
|
|
weston_compositor_xkb_destroy(struct weston_compositor *ec);
|
2012-01-03 20:29:15 +04:00
|
|
|
|
2012-08-01 08:00:57 +04:00
|
|
|
/* String literal of spaces, the same width as the timestamp. */
|
|
|
|
#define STAMP_SPACE " "
|
|
|
|
|
2016-06-02 21:48:13 +03:00
|
|
|
typedef int (*log_func_t)(const char *fmt, va_list ap);
|
2012-08-01 08:00:57 +04:00
|
|
|
void
|
2016-06-02 21:48:13 +03:00
|
|
|
weston_log_set_handler(log_func_t log, log_func_t cont);
|
2012-08-01 08:00:57 +04:00
|
|
|
int
|
2013-06-18 09:00:27 +04:00
|
|
|
weston_vlog(const char *fmt, va_list ap);
|
|
|
|
int
|
|
|
|
weston_vlog_continue(const char *fmt, va_list ap);
|
|
|
|
int
|
2012-08-06 15:57:04 +04:00
|
|
|
weston_log(const char *fmt, ...)
|
|
|
|
__attribute__ ((format (printf, 1, 2)));
|
2012-08-01 08:00:57 +04:00
|
|
|
int
|
2012-08-06 15:57:04 +04:00
|
|
|
weston_log_continue(const char *fmt, ...)
|
|
|
|
__attribute__ ((format (printf, 1, 2)));
|
2012-08-01 08:00:57 +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
|
|
|
enum {
|
|
|
|
TTY_ENTER_VT,
|
|
|
|
TTY_LEAVE_VT
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tty *
|
2013-09-18 03:02:57 +04:00
|
|
|
tty_create(struct weston_compositor *compositor, int tty_nr);
|
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
|
|
|
|
|
|
|
void
|
|
|
|
tty_destroy(struct tty *tty);
|
|
|
|
|
2012-07-31 22:32:01 +04:00
|
|
|
void
|
|
|
|
tty_reset(struct tty *tty);
|
|
|
|
|
2012-04-10 08:11:50 +04:00
|
|
|
int
|
|
|
|
tty_activate_vt(struct tty *tty, int vt);
|
|
|
|
|
2013-12-12 02:45:11 +04:00
|
|
|
enum weston_screenshooter_outcome {
|
|
|
|
WESTON_SCREENSHOOTER_SUCCESS,
|
|
|
|
WESTON_SCREENSHOOTER_NO_MEMORY,
|
|
|
|
WESTON_SCREENSHOOTER_BAD_BUFFER
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef void (*weston_screenshooter_done_func_t)(void *data,
|
|
|
|
enum weston_screenshooter_outcome outcome);
|
|
|
|
int
|
|
|
|
weston_screenshooter_shoot(struct weston_output *output, struct weston_buffer *buffer,
|
|
|
|
weston_screenshooter_done_func_t done, void *data);
|
2016-06-02 21:48:09 +03:00
|
|
|
struct weston_recorder *
|
|
|
|
weston_recorder_start(struct weston_output *output, const char *filename);
|
|
|
|
void
|
|
|
|
weston_recorder_stop(struct weston_recorder *recorder);
|
2013-12-12 02:45:11 +04:00
|
|
|
|
2012-06-03 18:20:13 +04:00
|
|
|
struct clipboard *
|
|
|
|
clipboard_create(struct weston_seat *seat);
|
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view_animation;
|
|
|
|
typedef void (*weston_view_animation_done_func_t)(struct weston_view_animation *animation, void *data);
|
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
|
|
|
|
animation, shell: add kbd focus change animation
When enabled, this will make all but the keyboard-focused window dim.
Also the background gets dimmed, if there are any windows open. The
panel is not dimmed.
When the keyboard focus changes, the change in dimming is animated.
The dimming is implemented with transparent solid-color surfaces, two at
most. The net effect of two overlapping dim surfaces is kept constant
during animations (stable fade animation).
There is a new weston.ini option "focus-animation", that defaults to
none, and can be set to "dim-layer" to enable the focus change
animation.
[pq: Sliced, squashed, and rebased the patch series. Fixed surface alpha
interaction with the switcher. Wrote the commit message.]
[pochu: rebased, ported to weston_view]
2013-11-19 14:37:11 +04:00
|
|
|
void
|
|
|
|
weston_view_animation_destroy(struct weston_view_animation *animation);
|
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view_animation *
|
|
|
|
weston_zoom_run(struct weston_view *view, float start, float stop,
|
|
|
|
weston_view_animation_done_func_t done, void *data);
|
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
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view_animation *
|
|
|
|
weston_fade_run(struct weston_view *view,
|
2013-02-21 20:35:17 +04:00
|
|
|
float start, float end, float k,
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_view_animation_done_func_t done, void *data);
|
2013-11-19 14:37:13 +04:00
|
|
|
|
|
|
|
struct weston_view_animation *
|
|
|
|
weston_move_scale_run(struct weston_view *view, int dx, int dy,
|
2016-08-10 16:53:33 +03:00
|
|
|
float start, float end, bool reverse,
|
2013-11-19 14:37:13 +04:00
|
|
|
weston_view_animation_done_func_t done, void *data);
|
|
|
|
|
2016-08-10 16:53:33 +03:00
|
|
|
struct weston_view_animation *
|
|
|
|
weston_move_run(struct weston_view *view, int dx, int dy,
|
|
|
|
float start, float end, bool reverse,
|
|
|
|
weston_view_animation_done_func_t done, void *data);
|
|
|
|
|
2013-02-21 20:35:17 +04:00
|
|
|
void
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
weston_fade_update(struct weston_view_animation *fade, float target);
|
2013-02-21 20:35:17 +04:00
|
|
|
|
animation, shell: add kbd focus change animation
When enabled, this will make all but the keyboard-focused window dim.
Also the background gets dimmed, if there are any windows open. The
panel is not dimmed.
When the keyboard focus changes, the change in dimming is animated.
The dimming is implemented with transparent solid-color surfaces, two at
most. The net effect of two overlapping dim surfaces is kept constant
during animations (stable fade animation).
There is a new weston.ini option "focus-animation", that defaults to
none, and can be set to "dim-layer" to enable the focus change
animation.
[pq: Sliced, squashed, and rebased the patch series. Fixed surface alpha
interaction with the switcher. Wrote the commit message.]
[pochu: rebased, ported to weston_view]
2013-11-19 14:37:11 +04:00
|
|
|
struct weston_view_animation *
|
|
|
|
weston_stable_fade_run(struct weston_view *front_view, float start,
|
|
|
|
struct weston_view *back_view, float end,
|
|
|
|
weston_view_animation_done_func_t done, void *data);
|
|
|
|
|
Split the geometry information from weston_surface out into weston_view
The weston_surface structure is split into two structures:
* The weston_surface structure storres everything required for a
client-side or server-side surface. This includes buffers; callbacks;
backend private data; input, damage, and opaque regions; and a few other
bookkeeping bits.
* The weston_view structure represents an entity in the scenegraph and
storres all of the geometry information. This includes clip region,
alpha, position, and the transformation list as well as all of the
temporary information derived from the geometry state. Because a view,
and not a surface, is a scenegraph element, the view is what is placed
in layers and planes.
There are a few things worth noting about the surface/view split:
1. This is *not* a modification to the protocol. It is, instead, a
modification to Weston's internal scenegraph to allow a single surface
to exist in multiple places at a time. Clients are completely unaware
of how many views to a particular surface exist.
2. A view is considered a direct child of a surface and is destroyed when
the surface is destroyed. Because of this, the view.surface pointer is
always valid and non-null.
3. The compositor's surface_list is replaced with a view_list. Due to
subsurfaces, building the view list is a little more complicated than
it used to be and involves building a tree of views on the fly whenever
subsurfaces are used. However, this means that backends can remain
completely subsurface-agnostic.
4. Surfaces and views both keep track of which outputs they are on.
5. The weston_surface structure now has width and height fields. These
are populated when a new buffer is attached before surface.configure
is called. This is because there are many surface-based operations
that really require the width and height and digging through the views
didn't work well.
Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-10-13 07:38:11 +04:00
|
|
|
struct weston_view_animation *
|
|
|
|
weston_slide_run(struct weston_view *view, float start, float stop,
|
|
|
|
weston_view_animation_done_func_t done, void *data);
|
2012-04-25 15:09:52 +04:00
|
|
|
|
2012-02-28 14:07:54 +04:00
|
|
|
void
|
|
|
|
weston_surface_set_color(struct weston_surface *surface,
|
2012-09-30 04:57:21 +04:00
|
|
|
float red, float green, float blue, float alpha);
|
2012-02-28 14:07:54 +04:00
|
|
|
|
|
|
|
void
|
|
|
|
weston_surface_destroy(struct weston_surface *surface);
|
|
|
|
|
2012-04-17 13:20:47 +04:00
|
|
|
int
|
2014-11-04 19:47:33 +03:00
|
|
|
weston_output_mode_set_native(struct weston_output *output,
|
|
|
|
struct weston_mode *mode,
|
|
|
|
int32_t scale);
|
|
|
|
int
|
|
|
|
weston_output_mode_switch_to_temporary(struct weston_output *output,
|
|
|
|
struct weston_mode *mode,
|
|
|
|
int32_t scale);
|
|
|
|
int
|
|
|
|
weston_output_mode_switch_to_native(struct weston_output *output);
|
2012-04-17 13:20:47 +04:00
|
|
|
|
2012-10-29 20:19:24 +04:00
|
|
|
int
|
|
|
|
noop_renderer_init(struct weston_compositor *ec);
|
|
|
|
|
2014-10-22 23:21:17 +04:00
|
|
|
int
|
|
|
|
weston_input_init(struct weston_compositor *compositor);
|
|
|
|
|
2014-10-11 19:27:30 +04:00
|
|
|
int
|
2016-12-02 16:08:44 +03:00
|
|
|
weston_backend_init(struct weston_compositor *c,
|
|
|
|
struct weston_backend_config *config_base);
|
2012-09-11 22:06:27 +04:00
|
|
|
int
|
2016-12-02 16:20:35 +03:00
|
|
|
weston_module_init(struct weston_compositor *compositor);
|
2012-09-11 22:06:27 +04:00
|
|
|
|
2012-12-05 17:14:04 +04:00
|
|
|
void
|
|
|
|
weston_transformed_coord(int width, int height,
|
|
|
|
enum wl_output_transform transform,
|
2013-05-24 15:09:43 +04:00
|
|
|
int32_t scale,
|
2012-12-05 17:14:04 +04:00
|
|
|
float sx, float sy, float *bx, float *by);
|
|
|
|
pixman_box32_t
|
|
|
|
weston_transformed_rect(int width, int height,
|
|
|
|
enum wl_output_transform transform,
|
2013-05-24 15:09:43 +04:00
|
|
|
int32_t scale,
|
2012-12-05 17:14:04 +04:00
|
|
|
pixman_box32_t rect);
|
2013-10-28 07:25:01 +04:00
|
|
|
void
|
2015-11-19 01:32:30 +03:00
|
|
|
weston_matrix_transform_region(pixman_region32_t *dest,
|
|
|
|
struct weston_matrix *matrix,
|
|
|
|
pixman_region32_t *src);
|
|
|
|
void
|
2013-10-28 07:25:01 +04:00
|
|
|
weston_transformed_region(int width, int height,
|
|
|
|
enum wl_output_transform transform,
|
|
|
|
int32_t scale,
|
|
|
|
pixman_region32_t *src, pixman_region32_t *dest);
|
2012-12-05 17:14:04 +04:00
|
|
|
|
2013-10-14 16:57:11 +04:00
|
|
|
void *
|
|
|
|
weston_load_module(const char *name, const char *entrypoint);
|
|
|
|
|
2016-11-24 23:45:45 +03:00
|
|
|
size_t
|
|
|
|
weston_module_path_from_env(const char *name, char *path, size_t path_len);
|
|
|
|
|
2014-10-23 21:24:18 +04:00
|
|
|
int
|
|
|
|
weston_parse_transform(const char *transform, uint32_t *out);
|
|
|
|
|
|
|
|
const char *
|
|
|
|
weston_transform_to_string(uint32_t output_transform);
|
|
|
|
|
2015-08-01 00:55:32 +03:00
|
|
|
struct weston_keyboard *
|
|
|
|
weston_seat_get_keyboard(struct weston_seat *seat);
|
|
|
|
|
|
|
|
struct weston_pointer *
|
|
|
|
weston_seat_get_pointer(struct weston_seat *seat);
|
|
|
|
|
|
|
|
struct weston_touch *
|
|
|
|
weston_seat_get_touch(struct weston_seat *seat);
|
|
|
|
|
2016-06-30 05:04:07 +03:00
|
|
|
void
|
|
|
|
weston_seat_set_keyboard_focus(struct weston_seat *seat,
|
|
|
|
struct weston_surface *surface);
|
|
|
|
|
2017-06-28 19:41:43 +03:00
|
|
|
void
|
|
|
|
weston_keyboard_send_keymap(struct weston_keyboard *kbd,
|
|
|
|
struct wl_resource *resource);
|
|
|
|
|
2016-06-29 12:54:27 +03:00
|
|
|
int
|
|
|
|
weston_compositor_load_xwayland(struct weston_compositor *compositor);
|
|
|
|
|
2017-08-16 10:39:17 +03:00
|
|
|
void
|
|
|
|
weston_head_init(struct weston_head *head, const char *name);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_head_release(struct weston_head *head);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_compositor_add_head(struct weston_compositor *compositor,
|
|
|
|
struct weston_head *head);
|
|
|
|
|
2017-03-24 16:39:24 +03:00
|
|
|
void
|
|
|
|
weston_head_set_monitor_strings(struct weston_head *head,
|
|
|
|
const char *make,
|
|
|
|
const char *model,
|
|
|
|
const char *serialno);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_head_set_physical_size(struct weston_head *head,
|
|
|
|
int32_t mm_width, int32_t mm_height);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_head_set_subpixel(struct weston_head *head,
|
|
|
|
enum wl_output_subpixel sp);
|
|
|
|
|
2017-08-14 15:45:14 +03:00
|
|
|
void
|
|
|
|
weston_head_set_connection_status(struct weston_head *head, bool connected);
|
|
|
|
|
2017-03-24 16:39:24 +03:00
|
|
|
void
|
|
|
|
weston_head_set_internal(struct weston_head *head);
|
|
|
|
|
2017-08-14 15:45:14 +03:00
|
|
|
bool
|
|
|
|
weston_head_is_connected(struct weston_head *head);
|
|
|
|
|
2018-02-15 16:18:20 +03:00
|
|
|
bool
|
|
|
|
weston_head_is_enabled(struct weston_head *head);
|
|
|
|
|
2017-08-28 14:11:02 +03:00
|
|
|
bool
|
|
|
|
weston_head_is_device_changed(struct weston_head *head);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_head_reset_device_changed(struct weston_head *head);
|
|
|
|
|
2017-08-16 10:39:17 +03:00
|
|
|
const char *
|
|
|
|
weston_head_get_name(struct weston_head *head);
|
|
|
|
|
|
|
|
struct weston_output *
|
|
|
|
weston_head_get_output(struct weston_head *head);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_head_detach(struct weston_head *head);
|
|
|
|
|
2017-10-10 11:21:58 +03:00
|
|
|
void
|
|
|
|
weston_head_add_destroy_listener(struct weston_head *head,
|
|
|
|
struct wl_listener *listener);
|
|
|
|
|
|
|
|
struct wl_listener *
|
|
|
|
weston_head_get_destroy_listener(struct weston_head *head,
|
|
|
|
wl_notify_func_t notify);
|
|
|
|
|
2017-08-14 16:05:35 +03:00
|
|
|
struct weston_head *
|
|
|
|
weston_compositor_iterate_heads(struct weston_compositor *compositor,
|
|
|
|
struct weston_head *iter);
|
|
|
|
|
2017-08-15 13:00:02 +03:00
|
|
|
void
|
|
|
|
weston_compositor_add_heads_changed_listener(struct weston_compositor *compositor,
|
|
|
|
struct wl_listener *listener);
|
|
|
|
|
2017-11-02 15:11:53 +03:00
|
|
|
struct weston_output *
|
|
|
|
weston_compositor_find_output_by_name(struct weston_compositor *compositor,
|
|
|
|
const char *name);
|
|
|
|
|
|
|
|
struct weston_output *
|
|
|
|
weston_compositor_create_output(struct weston_compositor *compositor,
|
|
|
|
const char *name);
|
|
|
|
|
2017-08-16 10:39:17 +03:00
|
|
|
struct weston_output *
|
|
|
|
weston_compositor_create_output_with_head(struct weston_compositor *compositor,
|
|
|
|
struct weston_head *head);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_output_destroy(struct weston_output *output);
|
|
|
|
|
|
|
|
int
|
|
|
|
weston_output_attach_head(struct weston_output *output,
|
|
|
|
struct weston_head *head);
|
|
|
|
|
|
|
|
struct weston_head *
|
|
|
|
weston_output_iterate_heads(struct weston_output *output,
|
|
|
|
struct weston_head *iter);
|
|
|
|
|
2016-09-30 15:11:02 +03:00
|
|
|
void
|
|
|
|
weston_output_set_scale(struct weston_output *output,
|
|
|
|
int32_t scale);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_output_set_transform(struct weston_output *output,
|
|
|
|
uint32_t transform);
|
|
|
|
|
|
|
|
void
|
2016-09-30 15:11:12 +03:00
|
|
|
weston_output_init(struct weston_output *output,
|
2017-04-03 13:18:13 +03:00
|
|
|
struct weston_compositor *compositor,
|
|
|
|
const char *name);
|
2016-09-30 15:11:02 +03:00
|
|
|
|
|
|
|
void
|
|
|
|
weston_compositor_add_pending_output(struct weston_output *output,
|
|
|
|
struct weston_compositor *compositor);
|
|
|
|
|
|
|
|
int
|
|
|
|
weston_output_enable(struct weston_output *output);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_output_disable(struct weston_output *output);
|
|
|
|
|
|
|
|
void
|
2017-08-17 17:29:36 +03:00
|
|
|
weston_compositor_flush_heads_changed(struct weston_compositor *compositor);
|
2016-09-30 15:11:02 +03:00
|
|
|
|
2017-03-27 16:31:25 +03:00
|
|
|
struct weston_head *
|
|
|
|
weston_head_from_resource(struct wl_resource *resource);
|
2017-03-27 15:14:32 +03:00
|
|
|
|
2017-04-04 16:36:07 +03:00
|
|
|
struct weston_head *
|
|
|
|
weston_output_get_first_head(struct weston_output *output);
|
|
|
|
|
2017-11-29 04:42:47 +03:00
|
|
|
int
|
|
|
|
weston_compositor_enable_touch_calibrator(struct weston_compositor *compositor,
|
|
|
|
weston_touch_calibration_save_func save);
|
|
|
|
|
2017-10-12 14:13:42 +03:00
|
|
|
int
|
|
|
|
weston_debug_compositor_create(struct weston_compositor *compositor);
|
|
|
|
|
|
|
|
void
|
|
|
|
weston_debug_compositor_destroy(struct weston_compositor *compositor);
|
|
|
|
|
2013-03-28 21:02:42 +04:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
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
|
|
|
#endif
|