Compare commits
No commits in common. 'be9f5bd99331c61ff18644035bf5d51ce2e43276' and '2e543aef219b3efc80ce23660fcce64cbcfaed41' have entirely different histories.
be9f5bd993
...
2e543aef21
@ -1,20 +0,0 @@ |
||||
#!/bin/bash |
||||
|
||||
# When running Debian's Xwayland and fontconfig, we hit memory leaks which |
||||
# aren't visible on other setups. We do have suppressions for these tests, but |
||||
# regrettably ASan can't see through omitted frame pointers in Expat, so for |
||||
# Xwayland specifically, we disable fast-unwind. |
||||
# |
||||
# Doing it globally makes the other tests far, far, too slow to run. |
||||
case "$1" in |
||||
*xwayland*) |
||||
export ASAN_OPTIONS="detect_leaks=0,fast_unwind_on_malloc=0" |
||||
;; |
||||
*) |
||||
export ASAN_OPTIONS="detect_leaks=0" |
||||
;; |
||||
esac |
||||
|
||||
export ASAN_OPTIONS |
||||
|
||||
exec "$@" |
||||
@ -0,0 +1,504 @@ |
||||
/*
|
||||
* Copyright © 2008 Kristian Høgsberg |
||||
* |
||||
* 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: |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#include "config.h" |
||||
|
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <math.h> |
||||
#include <time.h> |
||||
#include <errno.h> |
||||
|
||||
#include <GL/gl.h> |
||||
#include <EGL/egl.h> |
||||
#include <EGL/eglext.h> |
||||
|
||||
#include <linux/input.h> |
||||
#include <wayland-client.h> |
||||
|
||||
#include "window.h" |
||||
|
||||
struct gears { |
||||
struct window *window; |
||||
struct widget *widget; |
||||
|
||||
struct display *d; |
||||
|
||||
EGLDisplay display; |
||||
EGLDisplay config; |
||||
EGLContext context; |
||||
GLfloat angle; |
||||
|
||||
struct { |
||||
GLfloat rotx; |
||||
GLfloat roty; |
||||
} view; |
||||
|
||||
int button_down; |
||||
int last_x, last_y; |
||||
|
||||
GLint gear_list[3]; |
||||
int fullscreen; |
||||
int frames; |
||||
uint32_t last_fps; |
||||
}; |
||||
|
||||
struct gear_template { |
||||
GLfloat material[4]; |
||||
GLfloat inner_radius; |
||||
GLfloat outer_radius; |
||||
GLfloat width; |
||||
GLint teeth; |
||||
GLfloat tooth_depth; |
||||
}; |
||||
|
||||
static const struct gear_template gear_templates[] = { |
||||
{ { 0.8, 0.1, 0.0, 1.0 }, 1.0, 4.0, 1.0, 20, 0.7 }, |
||||
{ { 0.0, 0.8, 0.2, 1.0 }, 0.5, 2.0, 2.0, 10, 0.7 }, |
||||
{ { 0.2, 0.2, 1.0, 1.0 }, 1.3, 2.0, 0.5, 10, 0.7 }, |
||||
}; |
||||
|
||||
static GLfloat light_pos[4] = {5.0, 5.0, 10.0, 0.0}; |
||||
|
||||
static void die(const char *msg) |
||||
{ |
||||
fprintf(stderr, "%s", msg); |
||||
exit(EXIT_FAILURE); |
||||
} |
||||
|
||||
static void |
||||
make_gear(const struct gear_template *t) |
||||
{ |
||||
GLint i; |
||||
GLfloat r0, r1, r2; |
||||
GLfloat angle, da; |
||||
GLfloat u, v, len; |
||||
|
||||
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, t->material); |
||||
|
||||
r0 = t->inner_radius; |
||||
r1 = t->outer_radius - t->tooth_depth / 2.0; |
||||
r2 = t->outer_radius + t->tooth_depth / 2.0; |
||||
|
||||
da = 2.0 * M_PI / t->teeth / 4.0; |
||||
|
||||
glShadeModel(GL_FLAT); |
||||
|
||||
glNormal3f(0.0, 0.0, 1.0); |
||||
|
||||
/* draw front face */ |
||||
glBegin(GL_QUAD_STRIP); |
||||
for (i = 0; i <= t->teeth; i++) { |
||||
angle = i * 2.0 * M_PI / t->teeth; |
||||
glVertex3f(r0 * cos(angle), r0 * sin(angle), t->width * 0.5); |
||||
glVertex3f(r1 * cos(angle), r1 * sin(angle), t->width * 0.5); |
||||
if (i < t->teeth) { |
||||
glVertex3f(r0 * cos(angle), r0 * sin(angle), t->width * 0.5); |
||||
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), t->width * 0.5); |
||||
} |
||||
} |
||||
glEnd(); |
||||
|
||||
/* draw front sides of teeth */ |
||||
glBegin(GL_QUADS); |
||||
da = 2.0 * M_PI / t->teeth / 4.0; |
||||
for (i = 0; i < t->teeth; i++) { |
||||
angle = i * 2.0 * M_PI / t->teeth; |
||||
|
||||
glVertex3f(r1 * cos(angle), r1 * sin(angle), t->width * 0.5); |
||||
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), t->width * 0.5); |
||||
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), t->width * 0.5); |
||||
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), t->width * 0.5); |
||||
} |
||||
glEnd(); |
||||
|
||||
glNormal3f(0.0, 0.0, -1.0); |
||||
|
||||
/* draw back face */ |
||||
glBegin(GL_QUAD_STRIP); |
||||
for (i = 0; i <= t->teeth; i++) { |
||||
angle = i * 2.0 * M_PI / t->teeth; |
||||
glVertex3f(r1 * cos(angle), r1 * sin(angle), -t->width * 0.5); |
||||
glVertex3f(r0 * cos(angle), r0 * sin(angle), -t->width * 0.5); |
||||
if (i < t->teeth) { |
||||
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -t->width * 0.5); |
||||
glVertex3f(r0 * cos(angle), r0 * sin(angle), -t->width * 0.5); |
||||
} |
||||
} |
||||
glEnd(); |
||||
|
||||
/* draw back sides of teeth */ |
||||
glBegin(GL_QUADS); |
||||
da = 2.0 * M_PI / t->teeth / 4.0; |
||||
for (i = 0; i < t->teeth; i++) { |
||||
angle = i * 2.0 * M_PI / t->teeth; |
||||
|
||||
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -t->width * 0.5); |
||||
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -t->width * 0.5); |
||||
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -t->width * 0.5); |
||||
glVertex3f(r1 * cos(angle), r1 * sin(angle), -t->width * 0.5); |
||||
} |
||||
glEnd(); |
||||
|
||||
/* draw outward faces of teeth */ |
||||
glBegin(GL_QUAD_STRIP); |
||||
for (i = 0; i < t->teeth; i++) { |
||||
angle = i * 2.0 * M_PI / t->teeth; |
||||
|
||||
glVertex3f(r1 * cos(angle), r1 * sin(angle), t->width * 0.5); |
||||
glVertex3f(r1 * cos(angle), r1 * sin(angle), -t->width * 0.5); |
||||
u = r2 * cos(angle + da) - r1 * cos(angle); |
||||
v = r2 * sin(angle + da) - r1 * sin(angle); |
||||
len = sqrt(u * u + v * v); |
||||
u /= len; |
||||
v /= len; |
||||
glNormal3f(v, -u, 0.0); |
||||
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), t->width * 0.5); |
||||
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -t->width * 0.5); |
||||
glNormal3f(cos(angle), sin(angle), 0.0); |
||||
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), t->width * 0.5); |
||||
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -t->width * 0.5); |
||||
u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da); |
||||
v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da); |
||||
glNormal3f(v, -u, 0.0); |
||||
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), t->width * 0.5); |
||||
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -t->width * 0.5); |
||||
glNormal3f(cos(angle), sin(angle), 0.0); |
||||
} |
||||
|
||||
glVertex3f(r1 * cos(0), r1 * sin(0), t->width * 0.5); |
||||
glVertex3f(r1 * cos(0), r1 * sin(0), -t->width * 0.5); |
||||
|
||||
glEnd(); |
||||
|
||||
glShadeModel(GL_SMOOTH); |
||||
|
||||
/* draw inside radius cylinder */ |
||||
glBegin(GL_QUAD_STRIP); |
||||
for (i = 0; i <= t->teeth; i++) { |
||||
angle = i * 2.0 * M_PI / t->teeth; |
||||
glNormal3f(-cos(angle), -sin(angle), 0.0); |
||||
glVertex3f(r0 * cos(angle), r0 * sin(angle), -t->width * 0.5); |
||||
glVertex3f(r0 * cos(angle), r0 * sin(angle), t->width * 0.5); |
||||
} |
||||
glEnd(); |
||||
} |
||||
|
||||
static void |
||||
update_fps(struct gears *gears, uint32_t time) |
||||
{ |
||||
long diff_ms; |
||||
static bool first_call = true; |
||||
|
||||
if (first_call) { |
||||
gears->last_fps = time; |
||||
first_call = false; |
||||
} else |
||||
gears->frames++; |
||||
|
||||
diff_ms = time - gears->last_fps; |
||||
|
||||
if (diff_ms > 5000) { |
||||
float seconds = diff_ms / 1000.0; |
||||
float fps = gears->frames / seconds; |
||||
|
||||
printf("%d frames in %6.3f seconds = %6.3f FPS\n", gears->frames, seconds, fps); |
||||
fflush(stdout); |
||||
|
||||
gears->frames = 0; |
||||
gears->last_fps = time; |
||||
} |
||||
} |
||||
|
||||
static void |
||||
frame_callback(void *data, struct wl_callback *callback, uint32_t time) |
||||
{ |
||||
struct gears *gears = data; |
||||
|
||||
update_fps(gears, time); |
||||
|
||||
gears->angle = (GLfloat) (time % 8192) * 360 / 8192.0; |
||||
|
||||
window_schedule_redraw(gears->window); |
||||
|
||||
if (callback) |
||||
wl_callback_destroy(callback); |
||||
} |
||||
|
||||
static const struct wl_callback_listener listener = { |
||||
frame_callback |
||||
}; |
||||
|
||||
static int |
||||
motion_handler(struct widget *widget, struct input *input, |
||||
uint32_t time, float x, float y, void *data) |
||||
{ |
||||
struct gears *gears = data; |
||||
int offset_x, offset_y; |
||||
float step = 0.5; |
||||
|
||||
if (gears->button_down) { |
||||
offset_x = x - gears->last_x; |
||||
offset_y = y - gears->last_y; |
||||
gears->last_x = x; |
||||
gears->last_y = y; |
||||
gears->view.roty += offset_x * step; |
||||
gears->view.rotx += offset_y * step; |
||||
if (gears->view.roty >= 360) |
||||
gears->view.roty = gears->view.roty - 360; |
||||
if (gears->view.roty <= 0) |
||||
gears->view.roty = gears->view.roty + 360; |
||||
if (gears->view.rotx >= 360) |
||||
gears->view.rotx = gears->view.rotx - 360; |
||||
if (gears->view.rotx <= 0) |
||||
gears->view.rotx = gears->view.rotx + 360; |
||||
} |
||||
|
||||
return CURSOR_LEFT_PTR; |
||||
} |
||||
|
||||
static void |
||||
button_handler(struct widget *widget, struct input *input, |
||||
uint32_t time, uint32_t button, |
||||
enum wl_pointer_button_state state, void *data) |
||||
{ |
||||
struct gears *gears = data; |
||||
|
||||
if (button == BTN_LEFT) { |
||||
if (state == WL_POINTER_BUTTON_STATE_PRESSED) { |
||||
gears->button_down = 1; |
||||
input_get_position(input, |
||||
&gears->last_x, &gears->last_y); |
||||
} else { |
||||
gears->button_down = 0; |
||||
} |
||||
} |
||||
} |
||||
|
||||
static void |
||||
redraw_handler(struct widget *widget, void *data) |
||||
{ |
||||
struct rectangle window_allocation; |
||||
struct rectangle allocation; |
||||
struct wl_callback *callback; |
||||
struct gears *gears = data; |
||||
|
||||
widget_get_allocation(gears->widget, &allocation); |
||||
window_get_allocation(gears->window, &window_allocation); |
||||
|
||||
if (display_acquire_window_surface(gears->d, |
||||
gears->window, |
||||
gears->context) < 0) { |
||||
die("Unable to acquire window surface, " |
||||
"compiled without cairo-egl?\n"); |
||||
} |
||||
|
||||
glViewport(allocation.x, |
||||
window_allocation.height - allocation.height - allocation.y, |
||||
allocation.width, allocation.height); |
||||
glScissor(allocation.x, |
||||
window_allocation.height - allocation.height - allocation.y, |
||||
allocation.width, allocation.height); |
||||
|
||||
glEnable(GL_SCISSOR_TEST); |
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); |
||||
|
||||
glPushMatrix(); |
||||
|
||||
glTranslatef(0.0, 0.0, -50); |
||||
|
||||
glRotatef(gears->view.rotx, 1.0, 0.0, 0.0); |
||||
glRotatef(gears->view.roty, 0.0, 1.0, 0.0); |
||||
|
||||
glPushMatrix(); |
||||
glTranslatef(-3.0, -2.0, 0.0); |
||||
glRotatef(gears->angle, 0.0, 0.0, 1.0); |
||||
glCallList(gears->gear_list[0]); |
||||
glPopMatrix(); |
||||
|
||||
glPushMatrix(); |
||||
glTranslatef(3.1, -2.0, 0.0); |
||||
glRotatef(-2.0 * gears->angle - 9.0, 0.0, 0.0, 1.0); |
||||
glCallList(gears->gear_list[1]); |
||||
glPopMatrix(); |
||||
|
||||
glPushMatrix(); |
||||
glTranslatef(-3.1, 4.2, 0.0); |
||||
glRotatef(-2.0 * gears->angle - 25.0, 0.0, 0.0, 1.0); |
||||
glCallList(gears->gear_list[2]); |
||||
glPopMatrix(); |
||||
|
||||
glPopMatrix(); |
||||
|
||||
glFlush(); |
||||
|
||||
display_release_window_surface(gears->d, gears->window); |
||||
|
||||
callback = wl_surface_frame(window_get_wl_surface(gears->window)); |
||||
wl_callback_add_listener(callback, &listener, gears); |
||||
} |
||||
|
||||
static void |
||||
resize_handler(struct widget *widget, |
||||
int32_t width, int32_t height, void *data) |
||||
{ |
||||
struct gears *gears = data; |
||||
int32_t size, big, small; |
||||
|
||||
/* Constrain child size to be square and at least 300x300 */ |
||||
if (width < height) { |
||||
small = width; |
||||
big = height; |
||||
} else { |
||||
small = height; |
||||
big = width; |
||||
} |
||||
|
||||
if (gears->fullscreen) |
||||
size = small; |
||||
else |
||||
size = big; |
||||
|
||||
widget_set_size(gears->widget, size, size); |
||||
} |
||||
|
||||
static void |
||||
keyboard_focus_handler(struct window *window, |
||||
struct input *device, void *data) |
||||
{ |
||||
window_schedule_redraw(window); |
||||
} |
||||
|
||||
static void |
||||
fullscreen_handler(struct window *window, void *data) |
||||
{ |
||||
struct gears *gears = data; |
||||
|
||||
gears->fullscreen ^= 1; |
||||
window_set_fullscreen(window, gears->fullscreen); |
||||
} |
||||
|
||||
static struct gears * |
||||
gears_create(struct display *display) |
||||
{ |
||||
const int width = 450, height = 500; |
||||
struct gears *gears; |
||||
int i; |
||||
|
||||
gears = zalloc(sizeof *gears); |
||||
gears->d = display; |
||||
gears->window = window_create(display); |
||||
gears->widget = window_frame_create(gears->window, gears); |
||||
window_set_title(gears->window, "Wayland Gears"); |
||||
window_set_appid(gears->window, "org.freedesktop.weston.wayland-gears"); |
||||
|
||||
gears->display = display_get_egl_display(gears->d); |
||||
if (gears->display == NULL) |
||||
die("failed to create egl display\n"); |
||||
|
||||
eglBindAPI(EGL_OPENGL_API); |
||||
|
||||
gears->config = display_get_argb_egl_config(gears->d); |
||||
|
||||
gears->context = eglCreateContext(gears->display, gears->config, |
||||
EGL_NO_CONTEXT, NULL); |
||||
if (gears->context == NULL) |
||||
die("failed to create context\n"); |
||||
|
||||
if (!eglMakeCurrent(gears->display, NULL, NULL, gears->context)) |
||||
die("failed to make context current\n"); |
||||
|
||||
for (i = 0; i < 3; i++) { |
||||
gears->gear_list[i] = glGenLists(1); |
||||
glNewList(gears->gear_list[i], GL_COMPILE); |
||||
make_gear(&gear_templates[i]); |
||||
glEndList(); |
||||
} |
||||
|
||||
gears->button_down = 0; |
||||
gears->last_x = 0; |
||||
gears->last_y = 0; |
||||
|
||||
gears->view.rotx = 20.0; |
||||
gears->view.roty = 30.0; |
||||
|
||||
printf("Warning: FPS count is limited by the wayland compositor or monitor refresh rate\n"); |
||||
|
||||
glEnable(GL_NORMALIZE); |
||||
|
||||
glMatrixMode(GL_PROJECTION); |
||||
glLoadIdentity(); |
||||
glFrustum(-1.0, 1.0, -1.0, 1.0, 5.0, 200.0); |
||||
glMatrixMode(GL_MODELVIEW); |
||||
|
||||
glLightfv(GL_LIGHT0, GL_POSITION, light_pos); |
||||
glEnable(GL_CULL_FACE); |
||||
glEnable(GL_LIGHTING); |
||||
glEnable(GL_LIGHT0); |
||||
glEnable(GL_DEPTH_TEST); |
||||
glClearColor(0, 0, 0, 0.92); |
||||
|
||||
window_set_user_data(gears->window, gears); |
||||
widget_set_resize_handler(gears->widget, resize_handler); |
||||
widget_set_redraw_handler(gears->widget, redraw_handler); |
||||
widget_set_button_handler(gears->widget, button_handler); |
||||
widget_set_motion_handler(gears->widget, motion_handler); |
||||
window_set_keyboard_focus_handler(gears->window, |
||||
keyboard_focus_handler); |
||||
window_set_fullscreen_handler(gears->window, fullscreen_handler); |
||||
|
||||
window_schedule_resize(gears->window, width, height); |
||||
|
||||
return gears; |
||||
} |
||||
|
||||
static void |
||||
gears_destroy(struct gears *gears) |
||||
{ |
||||
widget_destroy(gears->widget); |
||||
window_destroy(gears->window); |
||||
free(gears); |
||||
} |
||||
|
||||
int main(int argc, char *argv[]) |
||||
{ |
||||
struct display *d; |
||||
struct gears *gears; |
||||
|
||||
d = display_create(&argc, argv); |
||||
if (d == NULL) { |
||||
fprintf(stderr, "failed to create display: %s\n", |
||||
strerror(errno)); |
||||
return -1; |
||||
} |
||||
gears = gears_create(d); |
||||
display_run(d); |
||||
|
||||
gears_destroy(gears); |
||||
display_destroy(d); |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,374 @@ |
||||
/*
|
||||
* Copyright © 2013 Intel Corporation |
||||
* |
||||
* 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: |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#include "config.h" |
||||
|
||||
#include <stdint.h> |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#include <wayland-egl.h> |
||||
#include <wayland-cursor.h> |
||||
|
||||
#include <GLES2/gl2.h> |
||||
#include <EGL/egl.h> |
||||
|
||||
#include "shared/platform.h" |
||||
|
||||
struct window; |
||||
struct seat; |
||||
|
||||
struct nested_client { |
||||
struct wl_display *display; |
||||
struct wl_registry *registry; |
||||
struct wl_compositor *compositor; |
||||
|
||||
EGLDisplay egl_display; |
||||
EGLContext egl_context; |
||||
EGLConfig egl_config; |
||||
EGLSurface egl_surface; |
||||
struct program *color_program; |
||||
|
||||
GLuint vert, frag, program; |
||||
GLuint rotation; |
||||
GLuint pos; |
||||
GLuint col; |
||||
|
||||
struct wl_surface *surface; |
||||
struct wl_egl_window *native; |
||||
int width, height; |
||||
}; |
||||
|
||||
#define POS 0 |
||||
#define COL 1 |
||||
|
||||
static GLuint |
||||
create_shader(const char *source, GLenum shader_type) |
||||
{ |
||||
GLuint shader; |
||||
GLint status; |
||||
|
||||
shader = glCreateShader(shader_type); |
||||
if (shader == 0) |
||||
return 0; |
||||
|
||||
glShaderSource(shader, 1, (const char **) &source, NULL); |
||||
glCompileShader(shader); |
||||
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &status); |
||||
if (!status) { |
||||
char log[1000]; |
||||
GLsizei len; |
||||
glGetShaderInfoLog(shader, 1000, &len, log); |
||||
fprintf(stderr, "Error: compiling %s: %.*s\n", |
||||
shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment", |
||||
len, log); |
||||
return 0; |
||||
} |
||||
|
||||
return shader; |
||||
} |
||||
|
||||
static void |
||||
create_program(struct nested_client *client, |
||||
const char *vert, const char *frag) |
||||
{ |
||||
GLint status; |
||||
|
||||
client->vert = create_shader(vert, GL_VERTEX_SHADER); |
||||
client->frag = create_shader(frag, GL_FRAGMENT_SHADER); |
||||
|
||||
client->program = glCreateProgram(); |
||||
glAttachShader(client->program, client->frag); |
||||
glAttachShader(client->program, client->vert); |
||||
glBindAttribLocation(client->program, POS, "pos"); |
||||
glBindAttribLocation(client->program, COL, "color"); |
||||
glLinkProgram(client->program); |
||||
|
||||
glGetProgramiv(client->program, GL_LINK_STATUS, &status); |
||||
if (!status) { |
||||
char log[1000]; |
||||
GLsizei len; |
||||
glGetProgramInfoLog(client->program, 1000, &len, log); |
||||
fprintf(stderr, "Error: linking:\n%.*s\n", len, log); |
||||
exit(1); |
||||
} |
||||
|
||||
client->rotation = |
||||
glGetUniformLocation(client->program, "rotation"); |
||||
} |
||||
|
||||
static const char vertex_shader_text[] = |
||||
"uniform mat4 rotation;\n" |
||||
"attribute vec4 pos;\n" |
||||
"attribute vec4 color;\n" |
||||
"varying vec4 v_color;\n" |
||||
"void main() {\n" |
||||
" gl_Position = rotation * pos;\n" |
||||
" v_color = color;\n" |
||||
"}\n"; |
||||
|
||||
static const char color_fragment_shader_text[] = |
||||
"precision mediump float;\n" |
||||
"varying vec4 v_color;\n" |
||||
"void main() {\n" |
||||
" gl_FragColor = v_color;\n" |
||||
"}\n"; |
||||
|
||||
static void |
||||
render_triangle(struct nested_client *client, uint32_t time) |
||||
{ |
||||
static const GLfloat verts[3][2] = { |
||||
{ -0.5, -0.5 }, |
||||
{ 0.5, -0.5 }, |
||||
{ 0, 0.5 } |
||||
}; |
||||
static const GLfloat colors[3][3] = { |
||||
{ 1, 0, 0 }, |
||||
{ 0, 1, 0 }, |
||||
{ 0, 0, 1 } |
||||
}; |
||||
GLfloat angle; |
||||
GLfloat rotation[4][4] = { |
||||
{ 1, 0, 0, 0 }, |
||||
{ 0, 1, 0, 0 }, |
||||
{ 0, 0, 1, 0 }, |
||||
{ 0, 0, 0, 1 } |
||||
}; |
||||
static const int32_t speed_div = 5; |
||||
static uint32_t start_time = 0; |
||||
|
||||
if (client->program == 0) |
||||
create_program(client, vertex_shader_text, |
||||
color_fragment_shader_text); |
||||
|
||||
if (start_time == 0) |
||||
start_time = time; |
||||
|
||||
angle = ((time - start_time) / speed_div) % 360 * M_PI / 180.0; |
||||
rotation[0][0] = cos(angle); |
||||
rotation[0][2] = sin(angle); |
||||
rotation[2][0] = -sin(angle); |
||||
rotation[2][2] = cos(angle); |
||||
|
||||
glClearColor(0.4, 0.4, 0.4, 1.0); |
||||
glClear(GL_COLOR_BUFFER_BIT); |
||||
|
||||
glUseProgram(client->program); |
||||
|
||||
glViewport(0, 0, client->width, client->height); |
||||
|
||||
glUniformMatrix4fv(client->rotation, 1, GL_FALSE, |
||||
(GLfloat *) rotation); |
||||
|
||||
glVertexAttribPointer(POS, 2, GL_FLOAT, GL_FALSE, 0, verts); |
||||
glVertexAttribPointer(COL, 3, GL_FLOAT, GL_FALSE, 0, colors); |
||||
glEnableVertexAttribArray(POS); |
||||
glEnableVertexAttribArray(COL); |
||||
|
||||
glDrawArrays(GL_TRIANGLES, 0, 3); |
||||
|
||||
glDisableVertexAttribArray(POS); |
||||
glDisableVertexAttribArray(COL); |
||||
|
||||
glFlush(); |
||||
} |
||||
|
||||
static void |
||||
frame_callback(void *data, struct wl_callback *callback, uint32_t time); |
||||
|
||||
static const struct wl_callback_listener frame_listener = { |
||||
frame_callback |
||||
}; |
||||
|
||||
static void |
||||
frame_callback(void *data, struct wl_callback *callback, uint32_t time) |
||||
{ |
||||
struct nested_client *client = data; |
||||
|
||||
if (callback) |
||||
wl_callback_destroy(callback); |
||||
|
||||
callback = wl_surface_frame(client->surface); |
||||
wl_callback_add_listener(callback, &frame_listener, client); |
||||
|
||||
render_triangle(client, time); |
||||
|
||||
eglSwapBuffers(client->egl_display, client->egl_surface); |
||||
} |
||||
|
||||
static void |
||||
registry_handle_global(void *data, struct wl_registry *registry, |
||||
uint32_t name, const char *interface, uint32_t version) |
||||
{ |
||||
struct nested_client *client = data; |
||||
|
||||
if (strcmp(interface, "wl_compositor") == 0) { |
||||
client->compositor = |
||||
wl_registry_bind(registry, name, |
||||
&wl_compositor_interface, 1); |
||||
} |
||||
} |
||||
|
||||
static void |
||||
registry_handle_global_remove(void *data, struct wl_registry *registry, |
||||
uint32_t name) |
||||
{ |
||||
} |
||||
|
||||
static const struct wl_registry_listener registry_listener = { |
||||
registry_handle_global, |
||||
registry_handle_global_remove |
||||
}; |
||||
|
||||
static struct nested_client * |
||||
nested_client_create(void) |
||||
{ |
||||
static const EGLint context_attribs[] = { |
||||
EGL_CONTEXT_CLIENT_VERSION, 2, |
||||
EGL_NONE |
||||
}; |
||||
|
||||
static const EGLint config_attribs[] = { |
||||
EGL_SURFACE_TYPE, EGL_WINDOW_BIT, |
||||
EGL_RED_SIZE, 1, |
||||
EGL_GREEN_SIZE, 1, |
||||
EGL_BLUE_SIZE, 1, |
||||
EGL_ALPHA_SIZE, 1, |
||||
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, |
||||
EGL_NONE |
||||
}; |
||||
|
||||
EGLint major, minor, n; |
||||
EGLBoolean ret; |
||||
|
||||
struct nested_client *client; |
||||
|
||||
client = malloc(sizeof *client); |
||||
if (client == NULL) |
||||
return NULL; |
||||
|
||||
client->width = 250; |
||||
client->height = 250; |
||||
|
||||
client->display = wl_display_connect(NULL); |
||||
|
||||
client->registry = wl_display_get_registry(client->display); |
||||
wl_registry_add_listener(client->registry, |
||||
®istry_listener, client); |
||||
|
||||
/* get globals */ |
||||
wl_display_roundtrip(client->display); |
||||
|
||||
client->egl_display = |
||||
weston_platform_get_egl_display(EGL_PLATFORM_WAYLAND_KHR, |
||||
client->display, NULL); |
||||
if (client->egl_display == NULL) |
||||
return NULL; |
||||
|
||||
ret = eglInitialize(client->egl_display, &major, &minor); |
||||
if (!ret) |
||||
return NULL; |
||||
ret = eglBindAPI(EGL_OPENGL_ES_API); |
||||
if (!ret) |
||||
return NULL; |
||||
|
||||
ret = eglChooseConfig(client->egl_display, config_attribs, |
||||
&client->egl_config, 1, &n); |
||||
if (!ret || n != 1) |
||||
return NULL; |
||||
|
||||
client->egl_context = eglCreateContext(client->egl_display, |
||||
client->egl_config, |
||||
EGL_NO_CONTEXT, |
||||
context_attribs); |
||||
if (!client->egl_context) |
||||
return NULL; |
||||
|
||||
client->surface = wl_compositor_create_surface(client->compositor); |
||||
|
||||
client->native = wl_egl_window_create(client->surface, |
||||
client->width, client->height); |
||||
|
||||
client->egl_surface = weston_platform_create_egl_surface(client->egl_display, |
||||
client->egl_config, |
||||
client->native, NULL); |
||||
|
||||
eglMakeCurrent(client->egl_display, client->egl_surface, |
||||
client->egl_surface, client->egl_context); |
||||
|
||||
wl_egl_window_resize(client->native, |
||||
client->width, client->height, 0, 0); |
||||
|
||||
frame_callback(client, NULL, 0); |
||||
|
||||
return client; |
||||
} |
||||
|
||||
static void |
||||
nested_client_destroy(struct nested_client *client) |
||||
{ |
||||
eglMakeCurrent(client->egl_display, |
||||
EGL_NO_SURFACE, EGL_NO_SURFACE, |
||||
EGL_NO_CONTEXT); |
||||
|
||||
weston_platform_destroy_egl_surface(client->egl_display, |
||||
client->egl_surface); |
||||
wl_egl_window_destroy(client->native); |
||||
|
||||
wl_surface_destroy(client->surface); |
||||
|
||||
if (client->compositor) |
||||
wl_compositor_destroy(client->compositor); |
||||
|
||||
wl_registry_destroy(client->registry); |
||||
eglTerminate(client->egl_display); |
||||
eglReleaseThread(); |
||||
wl_display_flush(client->display); |
||||
wl_display_disconnect(client->display); |
||||
} |
||||
|
||||
int |
||||
main(int argc, char **argv) |
||||
{ |
||||
struct nested_client *client; |
||||
int ret = 0; |
||||
|
||||
if (getenv("WAYLAND_SOCKET") == NULL) { |
||||
fprintf(stderr, |
||||
"must be run by nested, don't run standalone\n"); |
||||
return EXIT_FAILURE; |
||||
} |
||||
|
||||
client = nested_client_create(); |
||||
if (client == NULL) |
||||
return EXIT_FAILURE; |
||||
|
||||
while (ret != -1) |
||||
ret = wl_display_dispatch(client->display); |
||||
|
||||
nested_client_destroy(client); |
||||
|
||||
return 0; |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,737 @@ |
||||
/*
|
||||
* Copyright © 2010-2012 Intel Corporation |
||||
* Copyright © 2011-2012 Collabora, Ltd. |
||||
* Copyright © 2013 Raspberry Pi Foundation |
||||
* |
||||
* 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: |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#include "config.h" |
||||
|
||||
#include <stdint.h> |
||||
#include <linux/input.h> |
||||
|
||||
#include "shell.h" |
||||
#include "shared/helpers.h" |
||||
|
||||
struct exposay_surface { |
||||
struct desktop_shell *shell; |
||||
struct exposay_output *eoutput; |
||||
struct weston_surface *surface; |
||||
struct weston_view *view; |
||||
struct wl_listener view_destroy_listener; |
||||
struct wl_list link; |
||||
|
||||
int x; |
||||
int y; |
||||
int width; |
||||
int height; |
||||
double scale; |
||||
|
||||
int row; |
||||
int column; |
||||
|
||||
/* The animations only apply a transformation for their own lifetime,
|
||||
* and don't have an option to indefinitely maintain the |
||||
* transformation in a steady state - so, we apply our own once the |
||||
* animation has finished. */ |
||||
struct weston_transform transform; |
||||
}; |
||||
|
||||
static void exposay_set_state(struct desktop_shell *shell, |
||||
enum exposay_target_state state, |
||||
struct weston_seat *seat); |
||||
static void exposay_check_state(struct desktop_shell *shell); |
||||
|
||||
static void |
||||
exposay_surface_destroy(struct exposay_surface *esurface) |
||||
{ |
||||
wl_list_remove(&esurface->link); |
||||
wl_list_remove(&esurface->view_destroy_listener.link); |
||||
|
||||
if (esurface->shell->exposay.focus_current == esurface->view) |
||||
esurface->shell->exposay.focus_current = NULL; |
||||
if (esurface->shell->exposay.focus_prev == esurface->view) |
||||
esurface->shell->exposay.focus_prev = NULL; |
||||
|
||||
free(esurface); |
||||
} |
||||
|
||||
static void |
||||
exposay_in_flight_inc(struct desktop_shell *shell) |
||||
{ |
||||
shell->exposay.in_flight++; |
||||
} |
||||
|
||||
static void |
||||
exposay_in_flight_dec(struct desktop_shell *shell) |
||||
{ |
||||
if (--shell->exposay.in_flight > 0) |
||||
return; |
||||
|
||||
exposay_check_state(shell); |
||||
} |
||||
|
||||
static void |
||||
exposay_animate_in_done(struct weston_view_animation *animation, void *data) |
||||
{ |
||||
struct exposay_surface *esurface = data; |
||||
|
||||
wl_list_insert(&esurface->view->geometry.transformation_list, |
||||
&esurface->transform.link); |
||||
weston_matrix_init(&esurface->transform.matrix); |
||||
weston_matrix_scale(&esurface->transform.matrix, |
||||
esurface->scale, esurface->scale, 1.0f); |
||||
weston_matrix_translate(&esurface->transform.matrix, |
||||
esurface->x - esurface->view->geometry.x, |
||||
esurface->y - esurface->view->geometry.y, |
||||
0); |
||||
|
||||
weston_view_geometry_dirty(esurface->view); |
||||
weston_compositor_schedule_repaint(esurface->view->surface->compositor); |
||||
|
||||
exposay_in_flight_dec(esurface->shell); |
||||
} |
||||
|
||||
static void |
||||
exposay_animate_in(struct exposay_surface *esurface) |
||||
{ |
||||
exposay_in_flight_inc(esurface->shell); |
||||
|
||||
weston_move_scale_run(esurface->view, |
||||
esurface->x - esurface->view->geometry.x, |
||||
esurface->y - esurface->view->geometry.y, |
||||
1.0, esurface->scale, 0, |
||||
exposay_animate_in_done, esurface); |
||||
} |
||||
|
||||
static void |
||||
exposay_animate_out_done(struct weston_view_animation *animation, void *data) |
||||
{ |
||||
struct exposay_surface *esurface = data; |
||||
struct desktop_shell *shell = esurface->shell; |
||||
|
||||
exposay_surface_destroy(esurface); |
||||
|
||||
exposay_in_flight_dec(shell); |
||||
} |
||||
|
||||
static void |
||||
exposay_animate_out(struct exposay_surface *esurface) |
||||
{ |
||||
exposay_in_flight_inc(esurface->shell); |
||||
|
||||
/* Remove the static transformation set up by
|
||||
* exposay_transform_in_done(). */ |
||||
wl_list_remove(&esurface->transform.link); |
||||
weston_view_geometry_dirty(esurface->view); |
||||
|
||||
weston_move_scale_run(esurface->view, |
||||
esurface->x - esurface->view->geometry.x, |
||||
esurface->y - esurface->view->geometry.y, |
||||
1.0, esurface->scale, 1, |
||||
exposay_animate_out_done, esurface); |
||||
} |
||||
|
||||
static void |
||||
exposay_highlight_surface(struct desktop_shell *shell, |
||||
struct exposay_surface *esurface) |
||||
{ |
||||
struct weston_view *view = esurface->view; |
||||
|
||||
if (shell->exposay.focus_current == view) |
||||
return; |
||||
|
||||
shell->exposay.row_current = esurface->row; |
||||
shell->exposay.column_current = esurface->column; |
||||
shell->exposay.cur_output = esurface->eoutput; |
||||
|
||||
activate(shell, view, shell->exposay.seat, |
||||
WESTON_ACTIVATE_FLAG_NONE); |
||||
shell->exposay.focus_current = view; |
||||
} |
||||
|
||||
static int |
||||
exposay_is_animating(struct desktop_shell *shell) |
||||
{ |
||||
if (shell->exposay.state_cur == EXPOSAY_LAYOUT_INACTIVE || |
||||
shell->exposay.state_cur == EXPOSAY_LAYOUT_OVERVIEW) |
||||
return 0; |
||||
|
||||
return (shell->exposay.in_flight > 0); |
||||
} |
||||
|
||||
static void |
||||
exposay_pick(struct desktop_shell *shell, int x, int y) |
||||
{ |
||||
struct exposay_surface *esurface; |
||||
|
||||
if (exposay_is_animating(shell)) |
||||
return; |
||||
|
||||
wl_list_for_each(esurface, &shell->exposay.surface_list, link) { |
||||
if (x < esurface->x || x > esurface->x + esurface->width) |
||||
continue; |
||||
if (y < esurface->y || y > esurface->y + esurface->height) |
||||
continue; |
||||
|
||||
exposay_highlight_surface(shell, esurface); |
||||
return; |
||||
} |
||||
} |
||||
|
||||
static void |
||||
handle_view_destroy(struct wl_listener *listener, void *data) |
||||
{ |
||||
struct exposay_surface *esurface = container_of(listener, |
||||
struct exposay_surface, |
||||
view_destroy_listener); |
||||
|
||||
exposay_surface_destroy(esurface); |
||||
} |
||||
|
||||
/* Compute each surface size and then inner pad (10% of surface size).
|
||||
* After that, it's necessary to recompute surface size (90% of its |
||||
* original size). Also, each surface can't be bigger than half the |
||||
* exposay area width and height. |
||||
*/ |
||||
static void |
||||
exposay_surface_and_inner_pad_size(pixman_rectangle32_t exposay_area, struct exposay_output *eoutput) |
||||
{ |
||||
if (exposay_area.height < exposay_area.width) |
||||
eoutput->surface_size = exposay_area.height / eoutput->grid_size; |
||||
else |
||||
eoutput->surface_size = exposay_area.width / eoutput->grid_size; |
||||
|
||||
eoutput->padding_inner = eoutput->surface_size / 10; |
||||
eoutput->surface_size -= eoutput->padding_inner; |
||||
|
||||
if ((uint32_t)eoutput->surface_size > (exposay_area.width / 2)) |
||||
eoutput->surface_size = exposay_area.width / 2; |
||||
if ((uint32_t)eoutput->surface_size > (exposay_area.height / 2)) |
||||
eoutput->surface_size = exposay_area.height / 2; |
||||
} |
||||
|
||||
/* Compute the exposay top/left margin in order to centralize it */ |
||||
static void |
||||
exposay_margin_size(struct desktop_shell *shell, pixman_rectangle32_t exposay_area, |
||||
int row_size, int column_size, int *left_margin, int *top_margin) |
||||
{ |
||||
(*left_margin) = exposay_area.x + (exposay_area.width - row_size) / 2; |
||||
(*top_margin) = exposay_area.y + (exposay_area.height - column_size) / 2; |
||||
} |
||||
|
||||
/* Pretty lame layout for now; just tries to make a square. Should take
|
||||
* aspect ratio into account really. Also needs to be notified of surface |
||||
* addition and removal and adjust layout/animate accordingly. |
||||
* |
||||
* Lay the grid out as square as possible, losing surfaces from the |
||||
* bottom row if required. Start with fixed padding of a 10% margin |
||||
* around the outside, and maximise the area made available to surfaces |
||||
* after this. Also, add an inner padding between surfaces that varies |
||||
* with the surface size (10% of its size). |
||||
* |
||||
* If we can't make a square grid, add one extra row at the bottom which |
||||
* will have a smaller number of columns. |
||||
*/ |
||||
static enum exposay_layout_state |
||||
exposay_layout(struct desktop_shell *shell, struct shell_output *shell_output) |
||||
{ |
||||
struct workspace *workspace = shell->exposay.workspace; |
||||
struct weston_output *output = shell_output->output; |
||||
struct exposay_output *eoutput = &shell_output->eoutput; |
||||
struct weston_view *view; |
||||
struct exposay_surface *esurface, *highlight = NULL; |
||||
pixman_rectangle32_t exposay_area; |
||||
int pad, row_size, column_size, left_margin, top_margin; |
||||
int last_row_size, last_row_margin_increase; |
||||
int populated_rows; |
||||
int i; |
||||
|
||||
eoutput->num_surfaces = 0; |
||||
wl_list_for_each(view, &workspace->layer.view_list.link, layer_link.link) { |
||||
if (!get_shell_surface(view->surface)) |
||||
continue; |
||||
if (view->output != output) |
||||
continue; |
||||
eoutput->num_surfaces++; |
||||
} |
||||
|
||||
if (eoutput->num_surfaces == 0) { |
||||
eoutput->grid_size = 0; |
||||
eoutput->padding_inner = 0; |
||||
eoutput->surface_size = 0; |
||||
return EXPOSAY_LAYOUT_OVERVIEW; |
||||
} |
||||
|
||||
/* Get exposay area and position, taking into account
|
||||
* the shell panel position and size */ |
||||
get_output_work_area(shell, output, &exposay_area); |
||||
|
||||
/* Compute grid size */ |
||||
eoutput->grid_size = floor(sqrtf(eoutput->num_surfaces)); |
||||
if (pow(eoutput->grid_size, 2) != eoutput->num_surfaces) |
||||
eoutput->grid_size++; |
||||
|
||||
/* Compute each surface size and the inner padding between them */ |
||||
exposay_surface_and_inner_pad_size(exposay_area, eoutput); |
||||
|
||||
/* Compute each row/column size */ |
||||
pad = eoutput->surface_size + eoutput->padding_inner; |
||||
row_size = (pad * eoutput->grid_size) - eoutput->padding_inner; |
||||
/* We may have empty rows that should be desconsidered to compute
|
||||
* column size */ |
||||
populated_rows = ceil(eoutput->num_surfaces / (float) eoutput->grid_size); |
||||
column_size = (pad * populated_rows) - eoutput->padding_inner; |
||||
|
||||
/* The last row size can be different, since it may have less surfaces
|
||||
* than the grid size. Also, its margin may be increased to centralize |
||||
* its surfaces, in the case where we don't have a perfect grid. */ |
||||
last_row_size = ((eoutput->num_surfaces % eoutput->grid_size) * pad) - eoutput->padding_inner; |
||||
if (eoutput->num_surfaces % eoutput->grid_size) |
||||
last_row_margin_increase = (row_size - last_row_size) / 2; |
||||
else |
||||
last_row_margin_increase = 0; |
||||
|
||||
/* Compute a top/left margin to centralize the exposay */ |
||||
exposay_margin_size(shell, exposay_area, row_size, column_size, &left_margin, &top_margin); |
||||
|
||||
i = 0; |
||||
wl_list_for_each(view, &workspace->layer.view_list.link, layer_link.link) { |
||||
|
||||
if (!get_shell_surface(view->surface)) |
||||
continue; |
||||
if (view->output != output) |
||||
continue; |
||||
|
||||
esurface = malloc(sizeof(*esurface)); |
||||
if (!esurface) { |
||||
exposay_set_state(shell, EXPOSAY_TARGET_CANCEL, |
||||
shell->exposay.seat); |
||||
break; |
||||
} |
||||
|
||||
wl_list_insert(&shell->exposay.surface_list, &esurface->link); |
||||
esurface->shell = shell; |
||||
esurface->eoutput = eoutput; |
||||
esurface->view = view; |
||||
|
||||
esurface->row = i / eoutput->grid_size; |
||||
esurface->column = i % eoutput->grid_size; |
||||
|
||||
esurface->x = left_margin + (pad * esurface->column); |
||||
esurface->y = top_margin + (pad * esurface->row); |
||||
|
||||
/* If this is the last row, increase left margin (it sums 0 if
|
||||
* we have a perfect square) to centralize the surfaces */ |
||||
if (eoutput->num_surfaces / eoutput->grid_size == esurface->row) |
||||
esurface->x += last_row_margin_increase; |
||||
|
||||
if (view->surface->width > view->surface->height) |
||||
esurface->scale = eoutput->surface_size / (float) view->surface->width; |
||||
else |
||||
esurface->scale = eoutput->surface_size / (float) view->surface->height; |
||||
esurface->width = view->surface->width * esurface->scale; |
||||
esurface->height = view->surface->height * esurface->scale; |
||||
|
||||
/* Surfaces are usually rectangular, but their exposay surfaces
|
||||
* are square. centralize them in their own square */ |
||||
if (esurface->width > esurface->height) |
||||
esurface->y += (esurface->width - esurface->height) / 2; |
||||
else |
||||
esurface->x += (esurface->height - esurface->width) / 2; |
||||
|
||||
if (shell->exposay.focus_current == esurface->view) |
||||
highlight = esurface; |
||||
|
||||
exposay_animate_in(esurface); |
||||
|
||||
/* We want our destroy handler to be after the animation
|
||||
* destroy handler in the list, this way when the view is |
||||
* destroyed, the animation can safely call the animation |
||||
* completion callback before we free the esurface in our |
||||
* destroy handler. |
||||
*/ |
||||
esurface->view_destroy_listener.notify = handle_view_destroy; |
||||
wl_signal_add(&view->destroy_signal, &esurface->view_destroy_listener); |
||||
|
||||
i++; |
||||
} |
||||
|
||||
if (highlight) { |
||||
shell->exposay.focus_current = NULL; |
||||
exposay_highlight_surface(shell, highlight); |
||||
} |
||||
|
||||
weston_compositor_schedule_repaint(shell->compositor); |
||||
|
||||
return EXPOSAY_LAYOUT_ANIMATE_TO_OVERVIEW; |
||||
} |
||||
|
||||
static void |
||||
exposay_focus(struct weston_pointer_grab *grab) |
||||
{ |
||||
} |
||||
|
||||
static void |
||||
exposay_motion(struct weston_pointer_grab *grab, |
||||
const struct timespec *time, |
||||
struct weston_pointer_motion_event *event) |
||||
{ |
||||
struct desktop_shell *shell = |
||||
container_of(grab, struct desktop_shell, exposay.grab_ptr); |
||||
|
||||
weston_pointer_move(grab->pointer, event); |
||||
|
||||
exposay_pick(shell, |
||||
wl_fixed_to_int(grab->pointer->x), |
||||
wl_fixed_to_int(grab->pointer->y)); |
||||
} |
||||
|
||||
static void |
||||
exposay_button(struct weston_pointer_grab *grab, const struct timespec *time, |
||||
uint32_t button, uint32_t state_w) |
||||
{ |
||||
struct desktop_shell *shell = |
||||
container_of(grab, struct desktop_shell, exposay.grab_ptr); |
||||
struct weston_seat *seat = grab->pointer->seat; |
||||
enum wl_pointer_button_state state = state_w; |
||||
|
||||
if (button != BTN_LEFT) |
||||
return; |
||||
|
||||
/* Store the surface we clicked on, and don't do anything if we end up
|
||||
* releasing on a different surface. */ |
||||
if (state == WL_POINTER_BUTTON_STATE_PRESSED) { |
||||
shell->exposay.clicked = shell->exposay.focus_current; |
||||
return; |
||||
} |
||||
|
||||
if (shell->exposay.focus_current == shell->exposay.clicked) |
||||
exposay_set_state(shell, EXPOSAY_TARGET_SWITCH, seat); |
||||
else |
||||
shell->exposay.clicked = NULL; |
||||
} |
||||
|
||||
static void |
||||
exposay_axis(struct weston_pointer_grab *grab, |
||||
const struct timespec *time, |
||||
struct weston_pointer_axis_event *event) |
||||
{ |
||||
} |
||||
|
||||
static void |
||||
exposay_axis_source(struct weston_pointer_grab *grab, uint32_t source) |
||||
{ |
||||
} |
||||
|
||||
static void |
||||
exposay_frame(struct weston_pointer_grab *grab) |
||||
{ |
||||
} |
||||
|
||||
static void |
||||
exposay_pointer_grab_cancel(struct weston_pointer_grab *grab) |
||||
{ |
||||
struct desktop_shell *shell = |
||||
container_of(grab, struct desktop_shell, exposay.grab_ptr); |
||||
|
||||
exposay_set_state(shell, EXPOSAY_TARGET_CANCEL, shell->exposay.seat); |
||||
} |
||||
|
||||
static const struct weston_pointer_grab_interface exposay_ptr_grab = { |
||||
exposay_focus, |
||||
exposay_motion, |
||||
exposay_button, |
||||
exposay_axis, |
||||
exposay_axis_source, |
||||
exposay_frame, |
||||
exposay_pointer_grab_cancel, |
||||
}; |
||||
|
||||
static int |
||||
exposay_maybe_move(struct desktop_shell *shell, int row, int column) |
||||
{ |
||||
struct exposay_surface *esurface; |
||||
|
||||
wl_list_for_each(esurface, &shell->exposay.surface_list, link) { |
||||
if (esurface->eoutput != shell->exposay.cur_output || |
||||
esurface->row != row || esurface->column != column) |
||||
continue; |
||||
|
||||
exposay_highlight_surface(shell, esurface); |
||||
return 1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void |
||||
exposay_key(struct weston_keyboard_grab *grab, const struct timespec *time, |
||||
uint32_t key, uint32_t state_w) |
||||
{ |
||||
struct weston_seat *seat = grab->keyboard->seat; |
||||
struct desktop_shell *shell = |
||||
container_of(grab, struct desktop_shell, exposay.grab_kbd); |
||||
enum wl_keyboard_key_state state = state_w; |
||||
|
||||
if (state != WL_KEYBOARD_KEY_STATE_RELEASED) |
||||
return; |
||||
|
||||
switch (key) { |
||||
case KEY_ESC: |
||||
exposay_set_state(shell, EXPOSAY_TARGET_CANCEL, seat); |
||||
break; |
||||
case KEY_ENTER: |
||||
exposay_set_state(shell, EXPOSAY_TARGET_SWITCH, seat); |
||||
break; |
||||
case KEY_UP: |
||||
exposay_maybe_move(shell, shell->exposay.row_current - 1, |
||||
shell->exposay.column_current); |
||||
break; |
||||
case KEY_DOWN: |
||||
/* Special case for trying to move to the bottom row when it
|
||||
* has fewer items than all the others. */ |
||||
if (!exposay_maybe_move(shell, shell->exposay.row_current + 1, |
||||
shell->exposay.column_current) && |
||||
shell->exposay.row_current < (shell->exposay.cur_output->grid_size - 1)) { |
||||
exposay_maybe_move(shell, shell->exposay.row_current + 1, |
||||
(shell->exposay.cur_output->num_surfaces % |
||||
shell->exposay.cur_output->grid_size) - 1); |
||||
} |
||||
break; |
||||
case KEY_LEFT: |
||||
exposay_maybe_move(shell, shell->exposay.row_current, |
||||
shell->exposay.column_current - 1); |
||||
break; |
||||
case KEY_RIGHT: |
||||
exposay_maybe_move(shell, shell->exposay.row_current, |
||||
shell->exposay.column_current + 1); |
||||
break; |
||||
case KEY_TAB: |
||||
/* Try to move right, then down (and to the leftmost column),
|
||||
* then if all else fails, to the top left. */ |
||||
if (!exposay_maybe_move(shell, shell->exposay.row_current, |
||||
shell->exposay.column_current + 1) && |
||||
!exposay_maybe_move(shell, shell->exposay.row_current + 1, 0)) |
||||
exposay_maybe_move(shell, 0, 0); |
||||
break; |
||||
default: |
||||
break; |
||||
} |
||||
} |
||||
|
||||
static void |
||||
exposay_modifier(struct weston_keyboard_grab *grab, uint32_t serial, |
||||
uint32_t mods_depressed, uint32_t mods_latched, |
||||
uint32_t mods_locked, uint32_t group) |
||||
{ |
||||
struct desktop_shell *shell = |
||||
container_of(grab, struct desktop_shell, exposay.grab_kbd); |
||||
struct weston_seat *seat = (struct weston_seat *) grab->keyboard->seat; |
||||
|
||||
/* We want to know when mod has been pressed and released.
|
||||
* FIXME: There is a problem here: if mod is pressed, then a key |
||||
* is pressed and released, then mod is released, we will treat that |
||||
* as if only mod had been pressed and released. */ |
||||
if (seat->modifier_state) { |
||||
if (seat->modifier_state == shell->binding_modifier) { |
||||
shell->exposay.mod_pressed = true; |
||||
} else { |
||||
shell->exposay.mod_invalid = true; |
||||
} |
||||
} else { |
||||
if (shell->exposay.mod_pressed && !shell->exposay.mod_invalid) |
||||
exposay_set_state(shell, EXPOSAY_TARGET_CANCEL, seat); |
||||
|
||||
shell->exposay.mod_invalid = false; |
||||
shell->exposay.mod_pressed = false; |
||||
} |
||||
|
||||
return; |
||||
} |
||||
|
||||
static void |
||||
exposay_cancel(struct weston_keyboard_grab *grab) |
||||
{ |
||||
struct desktop_shell *shell = |
||||
container_of(grab, struct desktop_shell, exposay.grab_kbd); |
||||
|
||||
exposay_set_state(shell, EXPOSAY_TARGET_CANCEL, shell->exposay.seat); |
||||
} |
||||
|
||||
static const struct weston_keyboard_grab_interface exposay_kbd_grab = { |
||||
exposay_key, |
||||
exposay_modifier, |
||||
exposay_cancel, |
||||
}; |
||||
|
||||
/**
|
||||
* Called when the transition from overview -> inactive has completed. |
||||
*/ |
||||
static enum exposay_layout_state |
||||
exposay_set_inactive(struct desktop_shell *shell) |
||||
{ |
||||
struct weston_seat *seat = shell->exposay.seat; |
||||
struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat); |
||||
struct weston_pointer *pointer = weston_seat_get_pointer(seat); |
||||
|
||||
if (pointer) |
||||
weston_pointer_end_grab(pointer); |
||||
|
||||
if (keyboard) { |
||||
weston_keyboard_end_grab(keyboard); |
||||
if (keyboard->input_method_resource) |
||||
keyboard->grab = &keyboard->input_method_grab; |
||||
} |
||||
|
||||
return EXPOSAY_LAYOUT_INACTIVE; |
||||
} |
||||
|
||||
/**
|
||||
* Begins the transition from overview to inactive. */ |
||||
static enum exposay_layout_state |
||||
exposay_transition_inactive(struct desktop_shell *shell, int switch_focus) |
||||
{ |
||||
struct exposay_surface *esurface; |
||||
|
||||
/* Call activate() before we start the animations to avoid
|
||||
* animating back the old state and then immediately transitioning |
||||
* to the new. */ |
||||
if (switch_focus && shell->exposay.focus_current) |
||||
activate(shell, shell->exposay.focus_current, |
||||
shell->exposay.seat, |
||||
WESTON_ACTIVATE_FLAG_CONFIGURE); |
||||
else if (shell->exposay.focus_prev) |
||||
activate(shell, shell->exposay.focus_prev, |
||||
shell->exposay.seat, |
||||
WESTON_ACTIVATE_FLAG_CONFIGURE); |
||||
|
||||
wl_list_for_each(esurface, &shell->exposay.surface_list, link) |
||||
exposay_animate_out(esurface); |
||||
weston_compositor_schedule_repaint(shell->compositor); |
||||
|
||||
return EXPOSAY_LAYOUT_ANIMATE_TO_INACTIVE; |
||||
} |
||||
|
||||
static enum exposay_layout_state |
||||
exposay_transition_active(struct desktop_shell *shell) |
||||
{ |
||||
struct weston_seat *seat = shell->exposay.seat; |
||||
struct weston_pointer *pointer = weston_seat_get_pointer(seat); |
||||
struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat); |
||||
struct shell_output *shell_output; |
||||
bool animate = false; |
||||
|
||||
shell->exposay.workspace = get_current_workspace(shell); |
||||
shell->exposay.focus_prev = get_default_view(keyboard->focus); |
||||
shell->exposay.focus_current = get_default_view(keyboard->focus); |
||||
shell->exposay.clicked = NULL; |
||||
wl_list_init(&shell->exposay.surface_list); |
||||
|
||||
lower_fullscreen_layer(shell, NULL); |
||||
shell->exposay.grab_kbd.interface = &exposay_kbd_grab; |
||||
weston_keyboard_start_grab(keyboard, |
||||
&shell->exposay.grab_kbd); |
||||
weston_keyboard_set_focus(keyboard, NULL); |
||||
|
||||
shell->exposay.grab_ptr.interface = &exposay_ptr_grab; |
||||
if (pointer) { |
||||
weston_pointer_start_grab(pointer, |
||||
&shell->exposay.grab_ptr); |
||||
weston_pointer_clear_focus(pointer); |
||||
} |
||||
wl_list_for_each(shell_output, &shell->output_list, link) { |
||||
enum exposay_layout_state state; |
||||
|
||||
state = exposay_layout(shell, shell_output); |
||||
|
||||
if (state == EXPOSAY_LAYOUT_ANIMATE_TO_OVERVIEW) |
||||
animate = true; |
||||
} |
||||
|
||||
return animate ? EXPOSAY_LAYOUT_ANIMATE_TO_OVERVIEW |
||||
: EXPOSAY_LAYOUT_OVERVIEW; |
||||
} |
||||
|
||||
static void |
||||
exposay_check_state(struct desktop_shell *shell) |
||||
{ |
||||
enum exposay_layout_state state_new = shell->exposay.state_cur; |
||||
int do_switch = 0; |
||||
|
||||
/* Don't do anything whilst animations are running, just store up
|
||||
* target state changes and only act on them when the animations have |
||||
* completed. */ |
||||
if (exposay_is_animating(shell)) |
||||
return; |
||||
|
||||
switch (shell->exposay.state_target) { |
||||
case EXPOSAY_TARGET_OVERVIEW: |
||||
switch (shell->exposay.state_cur) { |
||||
case EXPOSAY_LAYOUT_OVERVIEW: |
||||
goto out; |
||||
case EXPOSAY_LAYOUT_ANIMATE_TO_OVERVIEW: |
||||
state_new = EXPOSAY_LAYOUT_OVERVIEW; |
||||
break; |
||||
default: |
||||
state_new = exposay_transition_active(shell); |
||||
break; |
||||
} |
||||
break; |
||||
|
||||
case EXPOSAY_TARGET_SWITCH: |
||||
do_switch = 1; /* fallthrough */ |
||||
case EXPOSAY_TARGET_CANCEL: |
||||
switch (shell->exposay.state_cur) { |
||||
case EXPOSAY_LAYOUT_INACTIVE: |
||||
goto out; |
||||
case EXPOSAY_LAYOUT_ANIMATE_TO_INACTIVE: |
||||
state_new = exposay_set_inactive(shell); |
||||
break; |
||||
default: |
||||
state_new = exposay_transition_inactive(shell, do_switch); |
||||
break; |
||||
} |
||||
|
||||
break; |
||||
} |
||||
|
||||
out: |
||||
shell->exposay.state_cur = state_new; |
||||
} |
||||
|
||||
static void |
||||
exposay_set_state(struct desktop_shell *shell, enum exposay_target_state state, |
||||
struct weston_seat *seat) |
||||
{ |
||||
shell->exposay.state_target = state; |
||||
shell->exposay.seat = seat; |
||||
exposay_check_state(shell); |
||||
} |
||||
|
||||
void |
||||
exposay_binding(struct weston_keyboard *keyboard, enum weston_keyboard_modifier modifier, |
||||
void *data) |
||||
{ |
||||
struct desktop_shell *shell = data; |
||||
|
||||
exposay_set_state(shell, EXPOSAY_TARGET_OVERVIEW, keyboard->seat); |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
|
Before Width: | Height: | Size: 108 KiB |
@ -1,9 +0,0 @@ |
||||
# Sphinx does not know look for these files in the source directory, so |
||||
# they must be copied to the build directory. |
||||
files = [ |
||||
'ivi-shell.png', |
||||
] |
||||
|
||||
foreach file : files |
||||
configure_file(input: file, output: file, copy: true) |
||||
endforeach |
||||
@ -1,111 +0,0 @@ |
||||
Weston IVI-shell |
||||
================ |
||||
|
||||
Weston's IVI-shell is a highly customizable shell targeted at use cases which |
||||
need custom control over the shell's window layout with one or more applications |
||||
without interactive configuration of the layout by the user. |
||||
|
||||
Example use cases for the IVI-shell are IVI applications or industrial human |
||||
machine interfaces. In general, whenever the user interface requires the exact |
||||
positioning of multiple application surfaces on one or more screens. |
||||
|
||||
The IVI-shell also provides a means for applications to identify themselves to |
||||
the shell by application IDs via the ivi_application Wayland protocol. |
||||
|
||||
IVI-shell client protocol |
||||
------------------------- |
||||
|
||||
Wayland clients can implement the ``ivi_application`` Wayland protocol, which |
||||
allows them to specify an ``ivi_id`` to allow the IVI controller to identify the |
||||
application. This allows the controller to implement special behavior for |
||||
well-known applications. |
||||
|
||||
The IVI-shell is able to also handle clients that use the ``xdg-shell`` |
||||
protocol, but in these cases the IVI-shell needs other means to identify client |
||||
applications. |
||||
|
||||
See ``ivi-application.xml`` for the protocol specification. |
||||
|
||||
IVI-shell Weston modules |
||||
------------------------ |
||||
|
||||
The IVI-shell consists of two main components: The ``ivi-shell.so`` and custom |
||||
IVI controller (with the ``hmi-controller.so`` example implementation). |
||||
|
||||
The ``ivi-shell.so`` is responsible for handling the application IDs and for |
||||
providing abstractions to configure the window layout via the |
||||
``ivi_layout_interface``. This interface is discussed in `IVI-shell compositor |
||||
implementation`. |
||||
|
||||
The IVI controller uses the ``ivi_layout_interface`` to implement a window |
||||
manager and is responsible for configuring the window layout, i.e. the position |
||||
of the applications on the screens. |
||||
|
||||
Due to this separation, both modules must be loaded in your ``weston.ini`` to |
||||
use the IVI-shell. |
||||
|
||||
.. code-block:: ini |
||||
|
||||
[core] |
||||
shell=ivi-shell.so |
||||
modules=hmi-controller.so |
||||
|
||||
If you are using your custom controller, replace ``hmi-controller.so`` with the |
||||
name of your own controller module. |
||||
|
||||
.. figure:: images/ivi-shell.png |
||||
:alt: IVI-shell architecture overview |
||||
|
||||
Controlling the IVI-shell |
||||
------------------------- |
||||
|
||||
The IVI-shell provides the ``ivi_layout_interface`` API that a controller must |
||||
use to control the window layout of the IVI-shell. See |
||||
``ivi-shell/ivi-layout-export.h`` for the definition of this API. |
||||
|
||||
For the initial configuration, the controller has to create at least one |
||||
``ivi_layout_layer`` and add the ``ivi_layout_layer`` to a ``weston_output``. |
||||
The layers allow to group multiple applications surfaces and control them |
||||
together and are the main mechanism to group and organize surfaces. These are |
||||
always necessary to show something using the IVI-shell. The IVI-shell will |
||||
internally create an ``ivi_layout_screen``, but a controller always uses the |
||||
``weston_output`` directly. |
||||
|
||||
To get control over the client surfaces, the controller must use notifiers that |
||||
trigger whenever there are changes to the client surfaces. The client surfaces |
||||
then show up as ``ivi_layout_surface``. These have an ID, which allows the |
||||
controller to identify the surface and reconfigure the window layout |
||||
accordingly. |
||||
|
||||
The controller must add the ``ivi_layout_surface`` to an ``ivi_layout_layer`` |
||||
and configure it's position and z-order wrt. the other surfaces in the layer. |
||||
Otherwise, the newly added surface will not show up on the screen. |
||||
|
||||
The IVI-shell will internally create an ``ivi_layout_view`` for each layer that |
||||
the surface was added to. However, the views are not provided to the IVI |
||||
controller. |
||||
|
||||
After configuring all expected changes, the controller must call the |
||||
``commit_changes`` to atomically update the display layout. |
||||
|
||||
IVI-shell example implementation |
||||
-------------------------------- |
||||
|
||||
The IVI-shell comes with an example implementation of an IVI controller -- the |
||||
`hmi-controller`. The hmi-controller will usually replaced by a custom |
||||
implementation that implements the use-case-specific behavior. |
||||
|
||||
The hmi-controller is split into two parts: |
||||
|
||||
The ``hmi-controller.so`` is a Weston Plugin that uses the |
||||
``ivi_layout_interface`` to perform the window manager tasks. It allows some |
||||
reconfiguration of the window layout via the ``ivi_hmi_controller`` protocol. |
||||
Other implementations may keep all window management inside the module or may |
||||
expose even more window management via a custom protocol to an external process. |
||||
|
||||
The ``weston-ivi-shell-user-interface`` is an example hmi-controller helper |
||||
client that serves as a user interface for controlling the hmi-controller. |
||||
|
||||
The hmi-controller can be customized using the ``[ivi-shell]`` section in the |
||||
``weston.ini``. An example configuration will be generated in |
||||
``<build_dir>/ivi-shell/weston.ini``. |
||||
@ -0,0 +1,70 @@ |
||||
/*
|
||||
* Copyright © 2016 Benoit Gschwind |
||||
* |
||||
* 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: |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#ifndef WESTON_COMPOSITOR_FBDEV_H |
||||
#define WESTON_COMPOSITOR_FBDEV_H |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include <libweston/libweston.h> |
||||
|
||||
#define WESTON_FBDEV_BACKEND_CONFIG_VERSION 2 |
||||
|
||||
struct libinput_device; |
||||
|
||||
struct weston_fbdev_backend_config { |
||||
struct weston_backend_config base; |
||||
|
||||
int tty; |
||||
char *device; |
||||
|
||||
/** Callback used to configure input devices.
|
||||
* |
||||
* This function will be called by the backend when a new input device |
||||
* needs to be configured. |
||||
* If NULL the device will use the default configuration. |
||||
*/ |
||||
void (*configure_device)(struct weston_compositor *compositor, |
||||
struct libinput_device *device); |
||||
|
||||
/** The seat to be used for input and output.
|
||||
* |
||||
* If seat_id is NULL, the seat is taken from XDG_SEAT environment |
||||
* variable. If neither is set, "seat0" is used. The backend will |
||||
* take ownership of the seat_id pointer and will free it on |
||||
* backend destruction. |
||||
*/ |
||||
char *seat_id; |
||||
}; |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* WESTON_COMPOSITOR_FBDEV_H */ |
||||
@ -0,0 +1,78 @@ |
||||
In-vehicle infotainment (information and entertainment) |
||||
graphical environment support modules for Weston |
||||
|
||||
|
||||
IVI-shell is an alternative shell for Weston, a Wayland display server. |
||||
Window management and application interaction with the display server |
||||
are very different to that of a normal desktop, which is why this is |
||||
a separate shell and not an extension to the desktop-shell suite with |
||||
xdg_shell. As such, applications need to be specifically written to use |
||||
IVI-shell. |
||||
|
||||
IVI-shell contains two main features: |
||||
- Common layout library for surface, which allow ivi-shell developer |
||||
to develop own shell, linking Common layout library. |
||||
For the time being, the library refers Genivi ilm interface. |
||||
|
||||
https://at.projects.genivi.org/wiki/display/WIE/Wayland+IVI+Extension+Home |
||||
|
||||
- Extension protocol; ivi-application to tie wl_surface and a given ID. |
||||
With this ID, shell can identify which wl_surface is drawn by which |
||||
application. In in-vehicle infortainment system, a shell has to update |
||||
a property of a wl_surface. E.g. there may be a use case when vehicle |
||||
starts to move, the wl_surface drawn by Car navigation is expected to |
||||
move top of surfaces. |
||||
|
||||
The actual software components delivered with Weston are: |
||||
|
||||
- ivi-application.xml: |
||||
Wayland protocol extension for IVI-applications; the public |
||||
shell protocol (the same concept as xdg_shell). |
||||
Implemented by ivi-shell.so. |
||||
|
||||
- ivi-shell.so: |
||||
A Weston shell module that implements ivi-application.xml interfaces. |
||||
Loads ivi-layout.so. |
||||
|
||||
- ivi-layout.so: |
||||
Implements the IVI window management concepts: Screen, Layer, |
||||
Surface, groups of Layers, groups of Surfaces, see: |
||||
https://at.projects.genivi.org/wiki/display/WIE/Summary+of+Layer+manager+APIs |
||||
Offers a stable API for writing IVI-controller modules like |
||||
hmi-controller.so against the IVI concepts. In other words, |
||||
it offers an API to write IVI window manager modules. |
||||
|
||||
- hmi-controller.so: |
||||
A sample implementation of an IVI-controller module, usually |
||||
replaced by IVI system vendors. |
||||
Uses ivi-layout.so to perform essentially window manager tasks. |
||||
This implementation keeps all window management inside the module, |
||||
while IVI-systems may use another module that exposes all window |
||||
management via Wayland or other protocol for an external process |
||||
to control. |
||||
|
||||
- ivi-hmi-controller.xml: |
||||
Wayland protocol extension for IVI display control; the private |
||||
shell protocol for weston-ivi-shell-user-interface client |
||||
(the same concept as desktop-shell.xml). |
||||
Implemented by hmi-controller.so, and usually replaced by IVI |
||||
system vendors. |
||||
|
||||
- weston-ivi-shell-user-interface: |
||||
A sample implementation of an IVI shell helper client, usually |
||||
replaced by IVI system vendors. |
||||
A helper client for basic display content, similar to |
||||
weston-desktop-shell. |
||||
|
||||
|
||||
How to compile: |
||||
same as weston. To disable, use option: --disable-ivi-shell for configure. |
||||
|
||||
How to configure weston.ini: |
||||
reference ini file will be generated in <build_dir>/ivi-shell. |
||||
|
||||
How to run: |
||||
same as weston. exec weston. |
||||
|
||||
How to use UI: |
||||
http://lists.freedesktop.org/archives/wayland-devel/attachments/20140625/abbfc064/attachment-0001.png |
||||
@ -0,0 +1,36 @@ |
||||
srcs_libdesktop = [ |
||||
'libweston-desktop.c', |
||||
'client.c', |
||||
'seat.c', |
||||
'surface.c', |
||||
'xwayland.c', |
||||
'wl-shell.c', |
||||
'xdg-shell.c', |
||||
'xdg-shell-v6.c', |
||||
xdg_shell_unstable_v6_server_protocol_h, |
||||
xdg_shell_unstable_v6_protocol_c, |
||||
xdg_shell_server_protocol_h, |
||||
xdg_shell_protocol_c, |
||||
] |
||||
lib_desktop = shared_library( |
||||
'weston-desktop-@0@'.format(libweston_major), |
||||
srcs_libdesktop, |
||||
include_directories: common_inc, |
||||
install: true, |
||||
version: '0.0.@0@'.format(libweston_revision), |
||||
dependencies: dep_libweston_public |
||||
) |
||||
dep_lib_desktop = declare_dependency( |
||||
link_with: lib_desktop, |
||||
dependencies: dep_libweston_public |
||||
) |
||||
|
||||
pkgconfig.generate( |
||||
lib_desktop, |
||||
filebase: 'libweston-desktop-@0@'.format(libweston_major), |
||||
name: 'libweston-desktop', |
||||
version: version_weston, |
||||
description: 'Desktop shells abstraction library for libweston compositors', |
||||
requires_private: [ lib_weston, dep_wayland_server ], |
||||
subdirs: dir_include_libweston |
||||
) |
||||
@ -0,0 +1,497 @@ |
||||
/*
|
||||
* Copyright © 2010-2012 Intel Corporation |
||||
* Copyright © 2011-2012 Collabora, Ltd. |
||||
* Copyright © 2013 Raspberry Pi Foundation |
||||
* Copyright © 2016 Quentin "Sardem FF7" Glidic |
||||
* |
||||
* 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: |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#include "config.h" |
||||
|
||||
#include <assert.h> |
||||
|
||||
#include <wayland-server.h> |
||||
|
||||
#include <libweston/libweston.h> |
||||
#include <libweston/zalloc.h> |
||||
|
||||
#include <libweston-desktop/libweston-desktop.h> |
||||
#include "internal.h" |
||||
|
||||
#define WD_WL_SHELL_PROTOCOL_VERSION 1 |
||||
|
||||
enum weston_desktop_wl_shell_surface_state { |
||||
NONE, |
||||
TOPLEVEL, |
||||
MAXIMIZED, |
||||
FULLSCREEN, |
||||
TRANSIENT, |
||||
POPUP, |
||||
}; |
||||
|
||||
struct weston_desktop_wl_shell_surface { |
||||
struct wl_resource *resource; |
||||
struct weston_desktop *desktop; |
||||
struct wl_display *display; |
||||
struct weston_desktop_surface *surface; |
||||
struct weston_desktop_surface *parent; |
||||
bool added; |
||||
struct weston_desktop_seat *popup_seat; |
||||
enum weston_desktop_wl_shell_surface_state state; |
||||
struct wl_listener wl_surface_resource_destroy_listener; |
||||
}; |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_set_size(struct weston_desktop_surface *dsurface, |
||||
void *user_data, |
||||
int32_t width, int32_t height) |
||||
{ |
||||
struct weston_desktop_wl_shell_surface *surface = user_data; |
||||
struct weston_surface *wsurface = |
||||
weston_desktop_surface_get_surface(surface->surface); |
||||
|
||||
if ((wsurface->width == width && wsurface->height == height) || |
||||
(width == 0 && height == 0)) |
||||
return; |
||||
|
||||
wl_shell_surface_send_configure(surface->resource, |
||||
WL_SHELL_SURFACE_RESIZE_NONE, |
||||
width, height); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_maybe_ungrab(struct weston_desktop_wl_shell_surface *surface) |
||||
{ |
||||
if (surface->state != POPUP || |
||||
!weston_desktop_surface_get_grab(surface->surface)) |
||||
return; |
||||
|
||||
weston_desktop_surface_popup_ungrab(surface->surface, |
||||
surface->popup_seat); |
||||
surface->popup_seat = NULL; |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_committed(struct weston_desktop_surface *dsurface, |
||||
void *user_data, |
||||
int32_t sx, int32_t sy) |
||||
{ |
||||
struct weston_desktop_wl_shell_surface *surface = user_data; |
||||
struct weston_surface *wsurface = |
||||
weston_desktop_surface_get_surface(dsurface); |
||||
|
||||
if (wsurface->buffer_ref.buffer == NULL) |
||||
weston_desktop_wl_shell_surface_maybe_ungrab(surface); |
||||
|
||||
if (surface->added) |
||||
weston_desktop_api_committed(surface->desktop, surface->surface, |
||||
sx, sy); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_ping(struct weston_desktop_surface *dsurface, |
||||
uint32_t serial, void *user_data) |
||||
{ |
||||
struct weston_desktop_wl_shell_surface *surface = user_data; |
||||
|
||||
wl_shell_surface_send_ping(surface->resource, serial); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_close(struct weston_desktop_surface *dsurface, |
||||
void *user_data) |
||||
{ |
||||
struct weston_desktop_wl_shell_surface *surface = user_data; |
||||
|
||||
if (surface->state == POPUP) |
||||
wl_shell_surface_send_popup_done(surface->resource); |
||||
} |
||||
|
||||
static bool |
||||
weston_desktop_wl_shell_surface_get_maximized(struct weston_desktop_surface *dsurface, |
||||
void *user_data) |
||||
{ |
||||
struct weston_desktop_wl_shell_surface *surface = user_data; |
||||
|
||||
return surface->state == MAXIMIZED; |
||||
} |
||||
|
||||
static bool |
||||
weston_desktop_wl_shell_surface_get_fullscreen(struct weston_desktop_surface *dsurface, |
||||
void *user_data) |
||||
{ |
||||
struct weston_desktop_wl_shell_surface *surface = user_data; |
||||
|
||||
return surface->state == FULLSCREEN; |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_change_state(struct weston_desktop_wl_shell_surface *surface, |
||||
enum weston_desktop_wl_shell_surface_state state, |
||||
struct weston_desktop_surface *parent, |
||||
int32_t x, int32_t y) |
||||
{ |
||||
bool to_add = (parent == NULL); |
||||
|
||||
assert(state != NONE); |
||||
|
||||
if (to_add && surface->added) { |
||||
surface->state = state; |
||||
return; |
||||
} |
||||
|
||||
if (surface->state != state) { |
||||
if (surface->state == POPUP) |
||||
weston_desktop_wl_shell_surface_maybe_ungrab(surface); |
||||
|
||||
if (to_add) { |
||||
weston_desktop_surface_unset_relative_to(surface->surface); |
||||
weston_desktop_api_surface_added(surface->desktop, |
||||
surface->surface); |
||||
} else if (surface->added) { |
||||
weston_desktop_api_surface_removed(surface->desktop, |
||||
surface->surface); |
||||
} |
||||
|
||||
surface->state = state; |
||||
surface->added = to_add; |
||||
} |
||||
|
||||
if (parent != NULL) |
||||
weston_desktop_surface_set_relative_to(surface->surface, parent, |
||||
x, y, false); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_destroy(struct weston_desktop_surface *dsurface, |
||||
void *user_data) |
||||
{ |
||||
struct weston_desktop_wl_shell_surface *surface = user_data; |
||||
|
||||
wl_list_remove(&surface->wl_surface_resource_destroy_listener.link); |
||||
|
||||
weston_desktop_wl_shell_surface_maybe_ungrab(surface); |
||||
weston_desktop_surface_unset_relative_to(surface->surface); |
||||
if (surface->added) |
||||
weston_desktop_api_surface_removed(surface->desktop, |
||||
surface->surface); |
||||
|
||||
free(surface); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_protocol_pong(struct wl_client *wl_client, |
||||
struct wl_resource *resource, |
||||
uint32_t serial) |
||||
{ |
||||
struct weston_desktop_surface *surface = wl_resource_get_user_data(resource); |
||||
|
||||
weston_desktop_client_pong(weston_desktop_surface_get_client(surface), serial); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_protocol_move(struct wl_client *wl_client, |
||||
struct wl_resource *resource, |
||||
struct wl_resource *seat_resource, |
||||
uint32_t serial) |
||||
{ |
||||
struct weston_desktop_surface *dsurface = |
||||
wl_resource_get_user_data(resource); |
||||
struct weston_seat *seat = |
||||
wl_resource_get_user_data(seat_resource); |
||||
struct weston_desktop_wl_shell_surface *surface = |
||||
weston_desktop_surface_get_implementation_data(dsurface); |
||||
|
||||
if (seat == NULL) |
||||
return; |
||||
|
||||
weston_desktop_api_move(surface->desktop, dsurface, seat, serial); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_protocol_resize(struct wl_client *wl_client, |
||||
struct wl_resource *resource, |
||||
struct wl_resource *seat_resource, |
||||
uint32_t serial, |
||||
enum wl_shell_surface_resize edges) |
||||
{ |
||||
struct weston_desktop_surface *dsurface = |
||||
wl_resource_get_user_data(resource); |
||||
struct weston_seat *seat = wl_resource_get_user_data(seat_resource); |
||||
struct weston_desktop_wl_shell_surface *surface = |
||||
weston_desktop_surface_get_implementation_data(dsurface); |
||||
enum weston_desktop_surface_edge surf_edges = |
||||
(enum weston_desktop_surface_edge) edges; |
||||
|
||||
if (seat == NULL) |
||||
return; |
||||
|
||||
weston_desktop_api_resize(surface->desktop, dsurface, seat, serial, surf_edges); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_protocol_set_toplevel(struct wl_client *wl_client, |
||||
struct wl_resource *resource) |
||||
{ |
||||
struct weston_desktop_surface *dsurface = |
||||
wl_resource_get_user_data(resource); |
||||
struct weston_desktop_wl_shell_surface *surface = |
||||
weston_desktop_surface_get_implementation_data(dsurface); |
||||
|
||||
weston_desktop_wl_shell_change_state(surface, TOPLEVEL, NULL, 0, 0); |
||||
if (surface->parent == NULL) |
||||
return; |
||||
surface->parent = NULL; |
||||
weston_desktop_api_set_parent(surface->desktop, surface->surface, NULL); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_protocol_set_transient(struct wl_client *wl_client, |
||||
struct wl_resource *resource, |
||||
struct wl_resource *parent_resource, |
||||
int32_t x, int32_t y, |
||||
enum wl_shell_surface_transient flags) |
||||
{ |
||||
struct weston_desktop_surface *dsurface = |
||||
wl_resource_get_user_data(resource); |
||||
struct weston_surface *wparent = |
||||
wl_resource_get_user_data(parent_resource); |
||||
struct weston_desktop_surface *parent; |
||||
struct weston_desktop_wl_shell_surface *surface = |
||||
weston_desktop_surface_get_implementation_data(dsurface); |
||||
|
||||
if (!weston_surface_is_desktop_surface(wparent)) |
||||
return; |
||||
|
||||
parent = weston_surface_get_desktop_surface(wparent); |
||||
if (flags & WL_SHELL_SURFACE_TRANSIENT_INACTIVE) { |
||||
weston_desktop_wl_shell_change_state(surface, TRANSIENT, parent, |
||||
x, y); |
||||
} else { |
||||
weston_desktop_wl_shell_change_state(surface, TOPLEVEL, NULL, |
||||
0, 0); |
||||
surface->parent = parent; |
||||
weston_desktop_api_set_parent(surface->desktop, |
||||
surface->surface, parent); |
||||
} |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_protocol_set_fullscreen(struct wl_client *wl_client, |
||||
struct wl_resource *resource, |
||||
enum wl_shell_surface_fullscreen_method method, |
||||
uint32_t framerate, |
||||
struct wl_resource *output_resource) |
||||
{ |
||||
struct weston_desktop_surface *dsurface = |
||||
wl_resource_get_user_data(resource); |
||||
struct weston_desktop_wl_shell_surface *surface = |
||||
weston_desktop_surface_get_implementation_data(dsurface); |
||||
struct weston_output *output = NULL; |
||||
|
||||
if (output_resource != NULL) |
||||
output = weston_head_from_resource(output_resource)->output; |
||||
|
||||
weston_desktop_wl_shell_change_state(surface, FULLSCREEN, NULL, 0, 0); |
||||
weston_desktop_api_fullscreen_requested(surface->desktop, dsurface, |
||||
true, output); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_protocol_set_popup(struct wl_client *wl_client, |
||||
struct wl_resource *resource, |
||||
struct wl_resource *seat_resource, |
||||
uint32_t serial, |
||||
struct wl_resource *parent_resource, |
||||
int32_t x, int32_t y, |
||||
enum wl_shell_surface_transient flags) |
||||
{ |
||||
struct weston_desktop_surface *dsurface = |
||||
wl_resource_get_user_data(resource); |
||||
struct weston_seat *wseat = wl_resource_get_user_data(seat_resource); |
||||
struct weston_desktop_seat *seat = weston_desktop_seat_from_seat(wseat); |
||||
struct weston_surface *parent = |
||||
wl_resource_get_user_data(parent_resource); |
||||
struct weston_desktop_surface *parent_surface; |
||||
struct weston_desktop_wl_shell_surface *surface = |
||||
weston_desktop_surface_get_implementation_data(dsurface); |
||||
|
||||
/* Check that if we have a valid wseat we also got a valid desktop seat */ |
||||
if (wseat != NULL && seat == NULL) { |
||||
wl_client_post_no_memory(wl_client); |
||||
return; |
||||
} |
||||
|
||||
if (!weston_surface_is_desktop_surface(parent)) |
||||
return; |
||||
|
||||
parent_surface = weston_surface_get_desktop_surface(parent); |
||||
|
||||
weston_desktop_wl_shell_change_state(surface, POPUP, |
||||
parent_surface, x, y); |
||||
weston_desktop_surface_popup_grab(surface->surface, seat, serial); |
||||
surface->popup_seat = seat; |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_protocol_set_maximized(struct wl_client *wl_client, |
||||
struct wl_resource *resource, |
||||
struct wl_resource *output_resource) |
||||
{ |
||||
struct weston_desktop_surface *dsurface = |
||||
wl_resource_get_user_data(resource); |
||||
struct weston_desktop_wl_shell_surface *surface = |
||||
weston_desktop_surface_get_implementation_data(dsurface); |
||||
|
||||
weston_desktop_wl_shell_change_state(surface, MAXIMIZED, NULL, 0, 0); |
||||
weston_desktop_api_maximized_requested(surface->desktop, dsurface, true); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_protocol_set_title(struct wl_client *wl_client, |
||||
struct wl_resource *resource, |
||||
const char *title) |
||||
{ |
||||
struct weston_desktop_surface *surface = |
||||
wl_resource_get_user_data(resource); |
||||
|
||||
weston_desktop_surface_set_title(surface, title); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_surface_protocol_set_class(struct wl_client *wl_client, |
||||
struct wl_resource *resource, |
||||
const char *class_) |
||||
{ |
||||
struct weston_desktop_surface *surface = |
||||
wl_resource_get_user_data(resource); |
||||
|
||||
weston_desktop_surface_set_app_id(surface, class_); |
||||
} |
||||
|
||||
|
||||
static const struct wl_shell_surface_interface weston_desktop_wl_shell_surface_implementation = { |
||||
.pong = weston_desktop_wl_shell_surface_protocol_pong, |
||||
.move = weston_desktop_wl_shell_surface_protocol_move, |
||||
.resize = weston_desktop_wl_shell_surface_protocol_resize, |
||||
.set_toplevel = weston_desktop_wl_shell_surface_protocol_set_toplevel, |
||||
.set_transient = weston_desktop_wl_shell_surface_protocol_set_transient, |
||||
.set_fullscreen = weston_desktop_wl_shell_surface_protocol_set_fullscreen, |
||||
.set_popup = weston_desktop_wl_shell_surface_protocol_set_popup, |
||||
.set_maximized = weston_desktop_wl_shell_surface_protocol_set_maximized, |
||||
.set_title = weston_desktop_wl_shell_surface_protocol_set_title, |
||||
.set_class = weston_desktop_wl_shell_surface_protocol_set_class, |
||||
}; |
||||
|
||||
static const struct weston_desktop_surface_implementation weston_desktop_wl_shell_surface_internal_implementation = { |
||||
.set_size = weston_desktop_wl_shell_surface_set_size, |
||||
.committed = weston_desktop_wl_shell_surface_committed, |
||||
.ping = weston_desktop_wl_shell_surface_ping, |
||||
.close = weston_desktop_wl_shell_surface_close, |
||||
|
||||
.get_maximized = weston_desktop_wl_shell_surface_get_maximized, |
||||
.get_fullscreen = weston_desktop_wl_shell_surface_get_fullscreen, |
||||
|
||||
.destroy = weston_desktop_wl_shell_surface_destroy, |
||||
}; |
||||
|
||||
static void |
||||
wl_surface_resource_destroyed(struct wl_listener *listener, |
||||
void *data) |
||||
{ |
||||
struct weston_desktop_wl_shell_surface *surface = |
||||
wl_container_of(listener, surface, |
||||
wl_surface_resource_destroy_listener); |
||||
|
||||
/* the wl_shell_surface spec says that wl_shell_surfaces are to be
|
||||
* destroyed automatically when the wl_surface is destroyed. */ |
||||
weston_desktop_surface_destroy(surface->surface); |
||||
} |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_protocol_get_shell_surface(struct wl_client *wl_client, |
||||
struct wl_resource *resource, |
||||
uint32_t id, |
||||
struct wl_resource *surface_resource) |
||||
{ |
||||
struct weston_desktop_client *client = wl_resource_get_user_data(resource); |
||||
struct weston_surface *wsurface = wl_resource_get_user_data(surface_resource); |
||||
struct weston_desktop_wl_shell_surface *surface; |
||||
|
||||
|
||||
if (weston_surface_set_role(wsurface, "wl_shell_surface", resource, WL_SHELL_ERROR_ROLE) < 0) |
||||
return; |
||||
|
||||
surface = zalloc(sizeof(struct weston_desktop_wl_shell_surface)); |
||||
if (surface == NULL) { |
||||
wl_client_post_no_memory(wl_client); |
||||
return; |
||||
} |
||||
|
||||
surface->desktop = weston_desktop_client_get_desktop(client); |
||||
surface->display = weston_desktop_get_display(surface->desktop); |
||||
|
||||
surface->surface = |
||||
weston_desktop_surface_create(surface->desktop, client, wsurface, |
||||
&weston_desktop_wl_shell_surface_internal_implementation, |
||||
surface); |
||||
if (surface->surface == NULL) { |
||||
free(surface); |
||||
return; |
||||
} |
||||
|
||||
surface->wl_surface_resource_destroy_listener.notify = |
||||
wl_surface_resource_destroyed; |
||||
wl_resource_add_destroy_listener(wsurface->resource, |
||||
&surface->wl_surface_resource_destroy_listener); |
||||
|
||||
surface->resource = |
||||
weston_desktop_surface_add_resource(surface->surface, |
||||
&wl_shell_surface_interface, |
||||
&weston_desktop_wl_shell_surface_implementation, |
||||
id, NULL); |
||||
} |
||||
|
||||
|
||||
static const struct wl_shell_interface weston_desktop_wl_shell_implementation = { |
||||
.get_shell_surface = weston_desktop_wl_shell_protocol_get_shell_surface, |
||||
}; |
||||
|
||||
static void |
||||
weston_desktop_wl_shell_bind(struct wl_client *client, void *data, |
||||
uint32_t version, uint32_t id) |
||||
{ |
||||
struct weston_desktop *desktop = data; |
||||
|
||||
weston_desktop_client_create(desktop, client, NULL, &wl_shell_interface, |
||||
&weston_desktop_wl_shell_implementation, |
||||
version, id); |
||||
} |
||||
|
||||
struct wl_global * |
||||
weston_desktop_wl_shell_create(struct weston_desktop *desktop, |
||||
struct wl_display *display) |
||||
{ |
||||
return wl_global_create(display, |
||||
&wl_shell_interface, |
||||
WD_WL_SHELL_PROTOCOL_VERSION, desktop, |
||||
weston_desktop_wl_shell_bind); |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,178 +0,0 @@ |
||||
/*
|
||||
* Copyright 2021-2022 Collabora, Ltd. |
||||
* |
||||
* 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: |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#include "config.h" |
||||
|
||||
#include <stdint.h> |
||||
#include <libweston/libweston.h> |
||||
#include <assert.h> |
||||
#include <string.h> |
||||
#include <math.h> |
||||
|
||||
#include "drm-internal.h" |
||||
|
||||
static inline uint16_t |
||||
color_xy_to_u16(float v) |
||||
{ |
||||
assert(v >= 0.0f); |
||||
assert(v <= 1.0f); |
||||
/*
|
||||
* CTA-861-G |
||||
* 6.9.1 Static Metadata Type 1 |
||||
* chromaticity coordinate encoding |
||||
*/ |
||||
return (uint16_t)round(v * 50000.0); |
||||
} |
||||
|
||||
static inline uint16_t |
||||
nits_to_u16(float nits) |
||||
{ |
||||
assert(nits >= 1.0f); |
||||
assert(nits <= 65535.0f); |
||||
/*
|
||||
* CTA-861-G |
||||
* 6.9.1 Static Metadata Type 1 |
||||
* max display mastering luminance, max content light level, |
||||
* max frame-average light level |
||||
*/ |
||||
return (uint16_t)round(nits); |
||||
} |
||||
|
||||
static inline uint16_t |
||||
nits_to_u16_dark(float nits) |
||||
{ |
||||
assert(nits >= 0.0001f); |
||||
assert(nits <= 6.5535f); |
||||
/*
|
||||
* CTA-861-G |
||||
* 6.9.1 Static Metadata Type 1 |
||||
* min display mastering luminance |
||||
*/ |
||||
return (uint16_t)round(nits * 10000.0); |
||||
} |
||||
|
||||
static void |
||||
weston_hdr_metadata_type1_to_kms(struct hdr_metadata_infoframe *dst, |
||||
const struct weston_hdr_metadata_type1 *src) |
||||
{ |
||||
if (src->group_mask & WESTON_HDR_METADATA_TYPE1_GROUP_PRIMARIES) { |
||||
unsigned i; |
||||
|
||||
for (i = 0; i < 3; i++) { |
||||
dst->display_primaries[i].x = color_xy_to_u16(src->primary[i].x); |
||||
dst->display_primaries[i].y = color_xy_to_u16(src->primary[i].y); |
||||
} |
||||
} |
||||
|
||||
if (src->group_mask & WESTON_HDR_METADATA_TYPE1_GROUP_WHITE) { |
||||
dst->white_point.x = color_xy_to_u16(src->white.x); |
||||
dst->white_point.y = color_xy_to_u16(src->white.y); |
||||
} |
||||
|
||||
if (src->group_mask & WESTON_HDR_METADATA_TYPE1_GROUP_MAXDML) |
||||
dst->max_display_mastering_luminance = nits_to_u16(src->maxDML); |
||||
|
||||
if (src->group_mask & WESTON_HDR_METADATA_TYPE1_GROUP_MINDML) |
||||
dst->min_display_mastering_luminance = nits_to_u16_dark(src->minDML); |
||||
|
||||
if (src->group_mask & WESTON_HDR_METADATA_TYPE1_GROUP_MAXCLL) |
||||
dst->max_cll = nits_to_u16(src->maxCLL); |
||||
|
||||
if (src->group_mask & WESTON_HDR_METADATA_TYPE1_GROUP_MAXFALL) |
||||
dst->max_fall = nits_to_u16(src->maxFALL); |
||||
} |
||||
|
||||
int |
||||
drm_output_ensure_hdr_output_metadata_blob(struct drm_output *output) |
||||
{ |
||||
struct drm_device *device = output->device; |
||||
const struct weston_hdr_metadata_type1 *src; |
||||
struct hdr_output_metadata meta; |
||||
uint32_t blob_id = 0; |
||||
int ret; |
||||
|
||||
if (output->hdr_output_metadata_blob_id && |
||||
output->ackd_color_outcome_serial == output->base.color_outcome_serial) |
||||
return 0; |
||||
|
||||
src = weston_output_get_hdr_metadata_type1(&output->base); |
||||
|
||||
/*
|
||||
* Set up the data for Dynamic Range and Mastering InfoFrame, |
||||
* CTA-861-G, a.k.a the static HDR metadata. |
||||
*/ |
||||
|
||||
memset(&meta, 0, sizeof meta); |
||||
|
||||
meta.metadata_type = 0; /* Static Metadata Type 1 */ |
||||
|
||||
/* Duplicated field in UABI struct */ |
||||
meta.hdmi_metadata_type1.metadata_type = meta.metadata_type; |
||||
|
||||
switch (output->base.eotf_mode) { |
||||
case WESTON_EOTF_MODE_NONE: |
||||
assert(0 && "bad eotf_mode: none"); |
||||
return -1; |
||||
case WESTON_EOTF_MODE_SDR: |
||||
/*
|
||||
* Do not send any static HDR metadata. Video sinks should |
||||
* respond by switching to traditional SDR mode. If they |
||||
* do not, the kernel should fix that up. |
||||
*/ |
||||
assert(output->hdr_output_metadata_blob_id == 0); |
||||
return 0; |
||||
case WESTON_EOTF_MODE_TRADITIONAL_HDR: |
||||
meta.hdmi_metadata_type1.eotf = 1; /* from CTA-861-G */ |
||||
break; |
||||
case WESTON_EOTF_MODE_ST2084: |
||||
meta.hdmi_metadata_type1.eotf = 2; /* from CTA-861-G */ |
||||
weston_hdr_metadata_type1_to_kms(&meta.hdmi_metadata_type1, src); |
||||
break; |
||||
case WESTON_EOTF_MODE_HLG: |
||||
meta.hdmi_metadata_type1.eotf = 3; /* from CTA-861-G */ |
||||
break; |
||||
} |
||||
|
||||
if (meta.hdmi_metadata_type1.eotf == 0) { |
||||
assert(0 && "bad eotf_mode"); |
||||
return -1; |
||||
} |
||||
|
||||
ret = drmModeCreatePropertyBlob(device->drm.fd, |
||||
&meta, sizeof meta, &blob_id); |
||||
if (ret != 0) { |
||||
weston_log("Error: failed to create KMS blob for HDR metadata on output '%s': %s\n", |
||||
output->base.name, strerror(-ret)); |
||||
return -1; |
||||
} |
||||
|
||||
drmModeDestroyPropertyBlob(device->drm.fd, |
||||
output->hdr_output_metadata_blob_id); |
||||
|
||||
output->hdr_output_metadata_blob_id = blob_id; |
||||
output->ackd_color_outcome_serial = output->base.color_outcome_serial; |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,998 @@ |
||||
/*
|
||||
* Copyright © 2008-2011 Kristian Høgsberg |
||||
* Copyright © 2011 Intel Corporation |
||||
* Copyright © 2012 Raspberry Pi Foundation |
||||
* Copyright © 2013 Philip Withnall |
||||
* |
||||
* 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: |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#include "config.h" |
||||
|
||||
#include <errno.h> |
||||
#include <stdlib.h> |
||||
#include <stdint.h> |
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <math.h> |
||||
#include <sys/mman.h> |
||||
#include <sys/types.h> |
||||
#include <fcntl.h> |
||||
#include <unistd.h> |
||||
#include <linux/fb.h> |
||||
#include <linux/input.h> |
||||
#include <assert.h> |
||||
|
||||
#include <libudev.h> |
||||
|
||||
#include "shared/helpers.h" |
||||
#include <libweston/libweston.h> |
||||
#include <libweston/backend-fbdev.h> |
||||
#include "launcher-util.h" |
||||
#include "pixman-renderer.h" |
||||
#include "libinput-seat.h" |
||||
#include "presentation-time-server-protocol.h" |
||||
|
||||
struct fbdev_backend { |
||||
struct weston_backend base; |
||||
struct weston_compositor *compositor; |
||||
uint32_t prev_state; |
||||
|
||||
struct udev *udev; |
||||
struct udev_input input; |
||||
uint32_t output_transform; |
||||
struct wl_listener session_listener; |
||||
}; |
||||
|
||||
struct fbdev_screeninfo { |
||||
unsigned int x_resolution; /* pixels, visible area */ |
||||
unsigned int y_resolution; /* pixels, visible area */ |
||||
unsigned int width_mm; /* visible screen width in mm */ |
||||
unsigned int height_mm; /* visible screen height in mm */ |
||||
unsigned int bits_per_pixel; |
||||
|
||||
size_t buffer_length; /* length of frame buffer memory in bytes */ |
||||
size_t line_length; /* length of a line in bytes */ |
||||
char id[16]; /* screen identifier */ |
||||
|
||||
pixman_format_code_t pixel_format; /* frame buffer pixel format */ |
||||
unsigned int refresh_rate; /* Hertz */ |
||||
}; |
||||
|
||||
struct fbdev_head { |
||||
struct weston_head base; |
||||
|
||||
/* Frame buffer details. */ |
||||
char *device; |
||||
struct fbdev_screeninfo fb_info; |
||||
}; |
||||
|
||||
struct fbdev_output { |
||||
struct fbdev_backend *backend; |
||||
struct weston_output base; |
||||
|
||||
struct weston_mode mode; |
||||
struct wl_event_source *finish_frame_timer; |
||||
|
||||
/* framebuffer mmap details */ |
||||
size_t buffer_length; |
||||
void *fb; |
||||
|
||||
/* pixman details. */ |
||||
pixman_image_t *hw_surface; |
||||
}; |
||||
|
||||
static const char default_seat[] = "seat0"; |
||||
|
||||
static inline struct fbdev_head * |
||||
to_fbdev_head(struct weston_head *base) |
||||
{ |
||||
return container_of(base, struct fbdev_head, base); |
||||
} |
||||
|
||||
static inline struct fbdev_output * |
||||
to_fbdev_output(struct weston_output *base) |
||||
{ |
||||
return container_of(base, struct fbdev_output, base); |
||||
} |
||||
|
||||
static inline struct fbdev_backend * |
||||
to_fbdev_backend(struct weston_compositor *base) |
||||
{ |
||||
return container_of(base->backend, struct fbdev_backend, base); |
||||
} |
||||
|
||||
static struct fbdev_head * |
||||
fbdev_output_get_head(struct fbdev_output *output) |
||||
{ |
||||
if (wl_list_length(&output->base.head_list) != 1) |
||||
return NULL; |
||||
|
||||
return container_of(output->base.head_list.next, |
||||
struct fbdev_head, base.output_link); |
||||
} |
||||
|
||||
static int |
||||
fbdev_output_start_repaint_loop(struct weston_output *output) |
||||
{ |
||||
struct timespec ts; |
||||
|
||||
weston_compositor_read_presentation_clock(output->compositor, &ts); |
||||
weston_output_finish_frame(output, &ts, WP_PRESENTATION_FEEDBACK_INVALID); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int |
||||
fbdev_output_repaint(struct weston_output *base, pixman_region32_t *damage, |
||||
void *repaint_data) |
||||
{ |
||||
struct fbdev_output *output = to_fbdev_output(base); |
||||
struct weston_compositor *ec = output->base.compositor; |
||||
|
||||
/* Repaint the damaged region onto the back buffer. */ |
||||
pixman_renderer_output_set_buffer(base, output->hw_surface); |
||||
ec->renderer->repaint_output(base, damage); |
||||
|
||||
/* Update the damage region. */ |
||||
pixman_region32_subtract(&ec->primary_plane.damage, |
||||
&ec->primary_plane.damage, damage); |
||||
|
||||
/* Schedule the end of the frame. We do not sync this to the frame
|
||||
* buffer clock because users who want that should be using the DRM |
||||
* compositor. FBIO_WAITFORVSYNC blocks and FB_ACTIVATE_VBL requires |
||||
* panning, which is broken in most kernel drivers. |
||||
* |
||||
* Finish the frame synchronised to the specified refresh rate. The |
||||
* refresh rate is given in mHz and the interval in ms. */ |
||||
wl_event_source_timer_update(output->finish_frame_timer, |
||||
1000000 / output->mode.refresh); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int |
||||
finish_frame_handler(void *data) |
||||
{ |
||||
struct fbdev_output *output = data; |
||||
struct timespec ts; |
||||
|
||||
weston_compositor_read_presentation_clock(output->base.compositor, &ts); |
||||
weston_output_finish_frame(&output->base, &ts, 0); |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
static pixman_format_code_t |
||||
calculate_pixman_format(struct fb_var_screeninfo *vinfo, |
||||
struct fb_fix_screeninfo *finfo) |
||||
{ |
||||
/* Calculate the pixman format supported by the frame buffer from the
|
||||
* buffer's metadata. Return 0 if no known pixman format is supported |
||||
* (since this has depth 0 it's guaranteed to not conflict with any |
||||
* actual pixman format). |
||||
* |
||||
* Documentation on the vinfo and finfo structures: |
||||
* http://www.mjmwired.net/kernel/Documentation/fb/api.txt
|
||||
* |
||||
* TODO: Try a bit harder to support other formats, including setting |
||||
* the preferred format in the hardware. */ |
||||
int type; |
||||
|
||||
weston_log("Calculating pixman format from:\n" |
||||
STAMP_SPACE " - type: %i (aux: %i)\n" |
||||
STAMP_SPACE " - visual: %i\n" |
||||
STAMP_SPACE " - bpp: %i (grayscale: %i)\n" |
||||
STAMP_SPACE " - red: offset: %i, length: %i, MSB: %i\n" |
||||
STAMP_SPACE " - green: offset: %i, length: %i, MSB: %i\n" |
||||
STAMP_SPACE " - blue: offset: %i, length: %i, MSB: %i\n" |
||||
STAMP_SPACE " - transp: offset: %i, length: %i, MSB: %i\n", |
||||
finfo->type, finfo->type_aux, finfo->visual, |
||||
vinfo->bits_per_pixel, vinfo->grayscale, |
||||
vinfo->red.offset, vinfo->red.length, vinfo->red.msb_right, |
||||
vinfo->green.offset, vinfo->green.length, |
||||
vinfo->green.msb_right, |
||||
vinfo->blue.offset, vinfo->blue.length, |
||||
vinfo->blue.msb_right, |
||||
vinfo->transp.offset, vinfo->transp.length, |
||||
vinfo->transp.msb_right); |
||||
|
||||
/* We only handle packed formats at the moment. */ |
||||
if (finfo->type != FB_TYPE_PACKED_PIXELS) |
||||
return 0; |
||||
|
||||
/* We only handle true-colour frame buffers at the moment. */ |
||||
switch(finfo->visual) { |
||||
case FB_VISUAL_TRUECOLOR: |
||||
case FB_VISUAL_DIRECTCOLOR: |
||||
if (vinfo->grayscale != 0) |
||||
return 0; |
||||
break; |
||||
default: |
||||
return 0; |
||||
} |
||||
|
||||
/* We only support formats with MSBs on the left. */ |
||||
if (vinfo->red.msb_right != 0 || vinfo->green.msb_right != 0 || |
||||
vinfo->blue.msb_right != 0) |
||||
return 0; |
||||
|
||||
/* Work out the format type from the offsets. We only support RGBA, ARGB
|
||||
* and ABGR at the moment. */ |
||||
type = PIXMAN_TYPE_OTHER; |
||||
|
||||
if ((vinfo->transp.offset >= vinfo->red.offset || |
||||
vinfo->transp.length == 0) && |
||||
vinfo->red.offset >= vinfo->green.offset && |
||||
vinfo->green.offset >= vinfo->blue.offset) |
||||
type = PIXMAN_TYPE_ARGB; |
||||
else if (vinfo->red.offset >= vinfo->green.offset && |
||||
vinfo->green.offset >= vinfo->blue.offset && |
||||
vinfo->blue.offset >= vinfo->transp.offset) |
||||
type = PIXMAN_TYPE_RGBA; |
||||
else if (vinfo->transp.offset >= vinfo->blue.offset && |
||||
vinfo->blue.offset >= vinfo->green.offset && |
||||
vinfo->green.offset >= vinfo->red.offset) |
||||
type = PIXMAN_TYPE_ABGR; |
||||
|
||||
if (type == PIXMAN_TYPE_OTHER) |
||||
return 0; |
||||
|
||||
/* Build the format. */ |
||||
return PIXMAN_FORMAT(vinfo->bits_per_pixel, type, |
||||
vinfo->transp.length, |
||||
vinfo->red.length, |
||||
vinfo->green.length, |
||||
vinfo->blue.length); |
||||
} |
||||
|
||||
static int |
||||
calculate_refresh_rate(struct fb_var_screeninfo *vinfo) |
||||
{ |
||||
uint64_t quot; |
||||
|
||||
/* Calculate monitor refresh rate. Default is 60 Hz. Units are mHz. */ |
||||
quot = (vinfo->upper_margin + vinfo->lower_margin + vinfo->yres); |
||||
quot *= (vinfo->left_margin + vinfo->right_margin + vinfo->xres); |
||||
quot *= vinfo->pixclock; |
||||
|
||||
if (quot > 0) { |
||||
uint64_t refresh_rate; |
||||
|
||||
refresh_rate = 1000000000000000LLU / quot; |
||||
if (refresh_rate > 200000) |
||||
refresh_rate = 200000; /* cap at 200 Hz */ |
||||
|
||||
if (refresh_rate >= 1000) /* at least 1 Hz */ |
||||
return refresh_rate; |
||||
} |
||||
|
||||
return 60 * 1000; /* default to 60 Hz */ |
||||
} |
||||
|
||||
static int |
||||
fbdev_query_screen_info(int fd, struct fbdev_screeninfo *info) |
||||
{ |
||||
struct fb_var_screeninfo varinfo; |
||||
struct fb_fix_screeninfo fixinfo; |
||||
|
||||
/* Probe the device for screen information. */ |
||||
if (ioctl(fd, FBIOGET_FSCREENINFO, &fixinfo) < 0 || |
||||
ioctl(fd, FBIOGET_VSCREENINFO, &varinfo) < 0) { |
||||
return -1; |
||||
} |
||||
|
||||
/* Store the pertinent data. */ |
||||
info->x_resolution = varinfo.xres; |
||||
info->y_resolution = varinfo.yres; |
||||
info->width_mm = varinfo.width; |
||||
info->height_mm = varinfo.height; |
||||
info->bits_per_pixel = varinfo.bits_per_pixel; |
||||
|
||||
info->buffer_length = fixinfo.smem_len; |
||||
info->line_length = fixinfo.line_length; |
||||
strncpy(info->id, fixinfo.id, sizeof(info->id)); |
||||
info->id[sizeof(info->id)-1] = '\0'; |
||||
|
||||
info->pixel_format = calculate_pixman_format(&varinfo, &fixinfo); |
||||
info->refresh_rate = calculate_refresh_rate(&varinfo); |
||||
|
||||
if (info->pixel_format == 0) { |
||||
weston_log("Frame buffer uses an unsupported format.\n"); |
||||
return -1; |
||||
} |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
static int |
||||
fbdev_set_screen_info(int fd, struct fbdev_screeninfo *info) |
||||
{ |
||||
struct fb_var_screeninfo varinfo; |
||||
|
||||
/* Grab the current screen information. */ |
||||
if (ioctl(fd, FBIOGET_VSCREENINFO, &varinfo) < 0) { |
||||
return -1; |
||||
} |
||||
|
||||
/* Update the information. */ |
||||
varinfo.xres = info->x_resolution; |
||||
varinfo.yres = info->y_resolution; |
||||
varinfo.width = info->width_mm; |
||||
varinfo.height = info->height_mm; |
||||
varinfo.bits_per_pixel = info->bits_per_pixel; |
||||
|
||||
/* Try to set up an ARGB (x8r8g8b8) pixel format. */ |
||||
varinfo.grayscale = 0; |
||||
varinfo.transp.offset = 24; |
||||
varinfo.transp.length = 0; |
||||
varinfo.transp.msb_right = 0; |
||||
varinfo.red.offset = 16; |
||||
varinfo.red.length = 8; |
||||
varinfo.red.msb_right = 0; |
||||
varinfo.green.offset = 8; |
||||
varinfo.green.length = 8; |
||||
varinfo.green.msb_right = 0; |
||||
varinfo.blue.offset = 0; |
||||
varinfo.blue.length = 8; |
||||
varinfo.blue.msb_right = 0; |
||||
|
||||
/* Set the device's screen information. */ |
||||
if (ioctl(fd, FBIOPUT_VSCREENINFO, &varinfo) < 0) { |
||||
return -1; |
||||
} |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
static int |
||||
fbdev_wakeup_screen(int fd, struct fbdev_screeninfo *info) |
||||
{ |
||||
struct fb_var_screeninfo varinfo; |
||||
|
||||
/* Grab the current screen information. */ |
||||
if (ioctl(fd, FBIOGET_VSCREENINFO, &varinfo) < 0) { |
||||
return -1; |
||||
} |
||||
|
||||
/* force the framebuffer to wake up */ |
||||
varinfo.activate = FB_ACTIVATE_NOW | FB_ACTIVATE_FORCE; |
||||
|
||||
/* Set the device's screen information. */ |
||||
if (ioctl(fd, FBIOPUT_VSCREENINFO, &varinfo) < 0) { |
||||
return -1; |
||||
} |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
/* Returns an FD for the frame buffer device. */ |
||||
static int |
||||
fbdev_frame_buffer_open(const char *fb_dev, |
||||
struct fbdev_screeninfo *screen_info) |
||||
{ |
||||
int fd = -1; |
||||
|
||||
weston_log("Opening fbdev frame buffer.\n"); |
||||
|
||||
/* Open the frame buffer device. */ |
||||
fd = open(fb_dev, O_RDWR | O_CLOEXEC); |
||||
if (fd < 0) { |
||||
weston_log("Failed to open frame buffer device ‘%s’: %s\n", |
||||
fb_dev, strerror(errno)); |
||||
return -1; |
||||
} |
||||
|
||||
/* Grab the screen info. */ |
||||
if (fbdev_query_screen_info(fd, screen_info) < 0) { |
||||
weston_log("Failed to get frame buffer info: %s\n", |
||||
strerror(errno)); |
||||
|
||||
close(fd); |
||||
return -1; |
||||
} |
||||
|
||||
/* Attempt to wake up the framebuffer device, needed for secondary
|
||||
* framebuffer devices */ |
||||
if (fbdev_wakeup_screen(fd, screen_info) < 0) { |
||||
weston_log("Failed to activate framebuffer display. " |
||||
"Attempting to open output anyway.\n"); |
||||
} |
||||
|
||||
|
||||
return fd; |
||||
} |
||||
|
||||
/* Closes the FD on success or failure. */ |
||||
static int |
||||
fbdev_frame_buffer_map(struct fbdev_output *output, int fd) |
||||
{ |
||||
struct fbdev_head *head; |
||||
int retval = -1; |
||||
|
||||
head = fbdev_output_get_head(output); |
||||
|
||||
weston_log("Mapping fbdev frame buffer.\n"); |
||||
|
||||
/* Map the frame buffer. Write-only mode, since we don't want to read
|
||||
* anything back (because it's slow). */ |
||||
output->buffer_length = head->fb_info.buffer_length; |
||||
output->fb = mmap(NULL, output->buffer_length, |
||||
PROT_WRITE, MAP_SHARED, fd, 0); |
||||
if (output->fb == MAP_FAILED) { |
||||
weston_log("Failed to mmap frame buffer: %s\n", |
||||
strerror(errno)); |
||||
output->fb = NULL; |
||||
goto out_close; |
||||
} |
||||
|
||||
/* Create a pixman image to wrap the memory mapped frame buffer. */ |
||||
output->hw_surface = |
||||
pixman_image_create_bits(head->fb_info.pixel_format, |
||||
head->fb_info.x_resolution, |
||||
head->fb_info.y_resolution, |
||||
output->fb, |
||||
head->fb_info.line_length); |
||||
if (output->hw_surface == NULL) { |
||||
weston_log("Failed to create surface for frame buffer.\n"); |
||||
goto out_unmap; |
||||
} |
||||
|
||||
/* Success! */ |
||||
retval = 0; |
||||
|
||||
out_unmap: |
||||
if (retval != 0 && output->fb != NULL) { |
||||
munmap(output->fb, output->buffer_length); |
||||
output->fb = NULL; |
||||
} |
||||
|
||||
out_close: |
||||
if (fd >= 0) |
||||
close(fd); |
||||
|
||||
return retval; |
||||
} |
||||
|
||||
static void |
||||
fbdev_frame_buffer_unmap(struct fbdev_output *output) |
||||
{ |
||||
if (!output->fb) { |
||||
assert(!output->hw_surface); |
||||
return; |
||||
} |
||||
|
||||
weston_log("Unmapping fbdev frame buffer.\n"); |
||||
|
||||
if (output->hw_surface) |
||||
pixman_image_unref(output->hw_surface); |
||||
output->hw_surface = NULL; |
||||
|
||||
if (munmap(output->fb, output->buffer_length) < 0) |
||||
weston_log("Failed to munmap frame buffer: %s\n", |
||||
strerror(errno)); |
||||
|
||||
output->fb = NULL; |
||||
} |
||||
|
||||
|
||||
static int |
||||
fbdev_output_attach_head(struct weston_output *output_base, |
||||
struct weston_head *head_base) |
||||
{ |
||||
struct fbdev_output *output = to_fbdev_output(output_base); |
||||
struct fbdev_head *head = to_fbdev_head(head_base); |
||||
|
||||
/* Clones not supported. */ |
||||
if (!wl_list_empty(&output->base.head_list)) |
||||
return -1; |
||||
|
||||
/* only one static mode in list */ |
||||
output->mode.flags = WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED; |
||||
output->mode.width = head->fb_info.x_resolution; |
||||
output->mode.height = head->fb_info.y_resolution; |
||||
output->mode.refresh = head->fb_info.refresh_rate; |
||||
wl_list_init(&output->base.mode_list); |
||||
wl_list_insert(&output->base.mode_list, &output->mode.link); |
||||
output->base.current_mode = &output->mode; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void fbdev_output_destroy(struct weston_output *base); |
||||
|
||||
static int |
||||
fbdev_output_enable(struct weston_output *base) |
||||
{ |
||||
struct fbdev_output *output = to_fbdev_output(base); |
||||
struct fbdev_backend *backend = to_fbdev_backend(base->compositor); |
||||
struct fbdev_head *head; |
||||
int fb_fd; |
||||
struct wl_event_loop *loop; |
||||
const struct pixman_renderer_output_options options = { |
||||
.use_shadow = true, |
||||
}; |
||||
|
||||
head = fbdev_output_get_head(output); |
||||
|
||||
/* Create the frame buffer. */ |
||||
fb_fd = fbdev_frame_buffer_open(head->device, &head->fb_info); |
||||
if (fb_fd < 0) { |
||||
weston_log("Creating frame buffer failed.\n"); |
||||
return -1; |
||||
} |
||||
|
||||
if (fbdev_frame_buffer_map(output, fb_fd) < 0) { |
||||
weston_log("Mapping frame buffer failed.\n"); |
||||
return -1; |
||||
} |
||||
|
||||
output->base.start_repaint_loop = fbdev_output_start_repaint_loop; |
||||
output->base.repaint = fbdev_output_repaint; |
||||
|
||||
if (pixman_renderer_output_create(&output->base, &options) < 0) |
||||
goto out_hw_surface; |
||||
|
||||
loop = wl_display_get_event_loop(backend->compositor->wl_display); |
||||
output->finish_frame_timer = |
||||
wl_event_loop_add_timer(loop, finish_frame_handler, output); |
||||
|
||||
weston_log("fbdev output %d×%d px\n", |
||||
output->mode.width, output->mode.height); |
||||
weston_log_continue(STAMP_SPACE "guessing %d Hz and 96 dpi\n", |
||||
output->mode.refresh / 1000); |
||||
|
||||
return 0; |
||||
|
||||
out_hw_surface: |
||||
fbdev_frame_buffer_unmap(output); |
||||
|
||||
return -1; |
||||
} |
||||
|
||||
static int |
||||
fbdev_output_disable(struct weston_output *base) |
||||
{ |
||||
struct fbdev_output *output = to_fbdev_output(base); |
||||
|
||||
if (!base->enabled) |
||||
return 0; |
||||
|
||||
wl_event_source_remove(output->finish_frame_timer); |
||||
output->finish_frame_timer = NULL; |
||||
|
||||
pixman_renderer_output_destroy(&output->base); |
||||
fbdev_frame_buffer_unmap(output); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static struct fbdev_head * |
||||
fbdev_head_create(struct fbdev_backend *backend, const char *device) |
||||
{ |
||||
struct fbdev_head *head; |
||||
int fb_fd; |
||||
|
||||
head = zalloc(sizeof *head); |
||||
if (!head) |
||||
return NULL; |
||||
|
||||
head->device = strdup(device); |
||||
|
||||
/* Create the frame buffer. */ |
||||
fb_fd = fbdev_frame_buffer_open(head->device, &head->fb_info); |
||||
if (fb_fd < 0) { |
||||
weston_log("Creating frame buffer head failed.\n"); |
||||
goto out_free; |
||||
} |
||||
close(fb_fd); |
||||
|
||||
weston_head_init(&head->base, "fbdev"); |
||||
weston_head_set_connection_status(&head->base, true); |
||||
weston_head_set_monitor_strings(&head->base, "unknown", |
||||
head->fb_info.id, NULL); |
||||
weston_head_set_subpixel(&head->base, WL_OUTPUT_SUBPIXEL_UNKNOWN); |
||||
weston_head_set_physical_size(&head->base, head->fb_info.width_mm, |
||||
head->fb_info.height_mm); |
||||
|
||||
weston_compositor_add_head(backend->compositor, &head->base); |
||||
|
||||
weston_log("Created head '%s' for device %s (%s)\n", |
||||
head->base.name, head->device, head->base.model); |
||||
|
||||
return head; |
||||
|
||||
out_free: |
||||
free(head->device); |
||||
free(head); |
||||
|
||||
return NULL; |
||||
} |
||||
|
||||
static void |
||||
fbdev_head_destroy(struct fbdev_head *head) |
||||
{ |
||||
weston_head_release(&head->base); |
||||
free(head->device); |
||||
free(head); |
||||
} |
||||
|
||||
static struct weston_output * |
||||
fbdev_output_create(struct weston_compositor *compositor, |
||||
const char *name) |
||||
{ |
||||
struct fbdev_output *output; |
||||
|
||||
weston_log("Creating fbdev output.\n"); |
||||
|
||||
output = zalloc(sizeof *output); |
||||
if (output == NULL) |
||||
return NULL; |
||||
|
||||
output->backend = to_fbdev_backend(compositor); |
||||
|
||||
weston_output_init(&output->base, compositor, name); |
||||
|
||||
output->base.destroy = fbdev_output_destroy; |
||||
output->base.disable = fbdev_output_disable; |
||||
output->base.enable = fbdev_output_enable; |
||||
output->base.attach_head = fbdev_output_attach_head; |
||||
|
||||
weston_compositor_add_pending_output(&output->base, compositor); |
||||
|
||||
return &output->base; |
||||
} |
||||
|
||||
static void |
||||
fbdev_output_destroy(struct weston_output *base) |
||||
{ |
||||
struct fbdev_output *output = to_fbdev_output(base); |
||||
|
||||
weston_log("Destroying fbdev output.\n"); |
||||
|
||||
fbdev_output_disable(base); |
||||
|
||||
/* Remove the output. */ |
||||
weston_output_release(&output->base); |
||||
|
||||
free(output); |
||||
} |
||||
|
||||
/* strcmp()-style return values. */ |
||||
static int |
||||
compare_screen_info (const struct fbdev_screeninfo *a, |
||||
const struct fbdev_screeninfo *b) |
||||
{ |
||||
if (a->x_resolution == b->x_resolution && |
||||
a->y_resolution == b->y_resolution && |
||||
a->width_mm == b->width_mm && |
||||
a->height_mm == b->height_mm && |
||||
a->bits_per_pixel == b->bits_per_pixel && |
||||
a->pixel_format == b->pixel_format && |
||||
a->refresh_rate == b->refresh_rate) |
||||
return 0; |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
static int |
||||
fbdev_output_reenable(struct fbdev_backend *backend, |
||||
struct weston_output *base) |
||||
{ |
||||
struct fbdev_output *output = to_fbdev_output(base); |
||||
struct fbdev_head *head; |
||||
struct fbdev_screeninfo new_screen_info; |
||||
int fb_fd; |
||||
|
||||
head = fbdev_output_get_head(output); |
||||
|
||||
weston_log("Re-enabling fbdev output.\n"); |
||||
assert(output->base.enabled); |
||||
|
||||
/* Create the frame buffer. */ |
||||
fb_fd = fbdev_frame_buffer_open(head->device, &new_screen_info); |
||||
if (fb_fd < 0) { |
||||
weston_log("Creating frame buffer failed.\n"); |
||||
return -1; |
||||
} |
||||
|
||||
/* Check whether the frame buffer details have changed since we were
|
||||
* disabled. */ |
||||
if (compare_screen_info(&head->fb_info, &new_screen_info) != 0) { |
||||
/* Perform a mode-set to restore the old mode. */ |
||||
if (fbdev_set_screen_info(fb_fd, &head->fb_info) < 0) { |
||||
weston_log("Failed to restore mode settings. " |
||||
"Attempting to re-open output anyway.\n"); |
||||
} |
||||
|
||||
close(fb_fd); |
||||
|
||||
/* Disable and enable the output so that resources depending on
|
||||
* the frame buffer X/Y resolution (such as the shadow buffer) |
||||
* are re-initialised. */ |
||||
fbdev_output_disable(&output->base); |
||||
return fbdev_output_enable(&output->base); |
||||
} |
||||
|
||||
/* Map the device if it has the same details as before. */ |
||||
if (fbdev_frame_buffer_map(output, fb_fd) < 0) { |
||||
weston_log("Mapping frame buffer failed.\n"); |
||||
return -1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void |
||||
fbdev_backend_destroy(struct weston_compositor *base) |
||||
{ |
||||
struct fbdev_backend *backend = to_fbdev_backend(base); |
||||
struct weston_head *head, *next; |
||||
|
||||
udev_input_destroy(&backend->input); |
||||
|
||||
/* Destroy the output. */ |
||||
weston_compositor_shutdown(base); |
||||
|
||||
wl_list_for_each_safe(head, next, &base->head_list, compositor_link) |
||||
fbdev_head_destroy(to_fbdev_head(head)); |
||||
|
||||
/* Chain up. */ |
||||
weston_launcher_destroy(base->launcher); |
||||
|
||||
udev_unref(backend->udev); |
||||
|
||||
free(backend); |
||||
} |
||||
|
||||
static void |
||||
session_notify(struct wl_listener *listener, void *data) |
||||
{ |
||||
struct weston_compositor *compositor = data; |
||||
struct fbdev_backend *backend = to_fbdev_backend(compositor); |
||||
struct weston_output *output; |
||||
|
||||
if (compositor->session_active) { |
||||
weston_log("entering VT\n"); |
||||
compositor->state = backend->prev_state; |
||||
|
||||
wl_list_for_each(output, &compositor->output_list, link) { |
||||
fbdev_output_reenable(backend, output); |
||||
} |
||||
|
||||
weston_compositor_damage_all(compositor); |
||||
|
||||
udev_input_enable(&backend->input); |
||||
} else { |
||||
weston_log("leaving VT\n"); |
||||
udev_input_disable(&backend->input); |
||||
|
||||
wl_list_for_each(output, &compositor->output_list, link) { |
||||
fbdev_frame_buffer_unmap(to_fbdev_output(output)); |
||||
} |
||||
|
||||
backend->prev_state = compositor->state; |
||||
weston_compositor_offscreen(compositor); |
||||
|
||||
/* If we have a repaint scheduled (from the idle handler), make
|
||||
* sure we cancel that so we don't try to pageflip when we're |
||||
* vt switched away. The OFFSCREEN state will prevent |
||||
* further attempts at repainting. When we switch |
||||
* back, we schedule a repaint, which will process |
||||
* pending frame callbacks. */ |
||||
|
||||
wl_list_for_each(output, |
||||
&compositor->output_list, link) { |
||||
output->repaint_needed = false; |
||||
} |
||||
} |
||||
} |
||||
|
||||
static char * |
||||
find_framebuffer_device(struct fbdev_backend *b, const char *seat) |
||||
{ |
||||
struct udev_enumerate *e; |
||||
struct udev_list_entry *entry; |
||||
const char *path, *device_seat, *id; |
||||
char *fb_device_path = NULL; |
||||
struct udev_device *device, *fb_device, *pci; |
||||
|
||||
e = udev_enumerate_new(b->udev); |
||||
udev_enumerate_add_match_subsystem(e, "graphics"); |
||||
udev_enumerate_add_match_sysname(e, "fb[0-9]*"); |
||||
|
||||
udev_enumerate_scan_devices(e); |
||||
fb_device = NULL; |
||||
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) { |
||||
bool is_boot_vga = false; |
||||
|
||||
path = udev_list_entry_get_name(entry); |
||||
device = udev_device_new_from_syspath(b->udev, path); |
||||
if (!device) |
||||
continue; |
||||
device_seat = udev_device_get_property_value(device, "ID_SEAT"); |
||||
if (!device_seat) |
||||
device_seat = default_seat; |
||||
if (strcmp(device_seat, seat)) { |
||||
udev_device_unref(device); |
||||
continue; |
||||
} |
||||
|
||||
pci = udev_device_get_parent_with_subsystem_devtype(device, |
||||
"pci", NULL); |
||||
if (pci) { |
||||
id = udev_device_get_sysattr_value(pci, "boot_vga"); |
||||
if (id && !strcmp(id, "1")) |
||||
is_boot_vga = true; |
||||
} |
||||
|
||||
/* If a framebuffer device was found, and this device isn't
|
||||
* the boot-VGA device, don't use it. */ |
||||
if (!is_boot_vga && fb_device) { |
||||
udev_device_unref(device); |
||||
continue; |
||||
} |
||||
|
||||
/* There can only be one boot_vga device. Try to use it
|
||||
* at all costs. */ |
||||
if (is_boot_vga) { |
||||
if (fb_device) |
||||
udev_device_unref(fb_device); |
||||
fb_device = device; |
||||
break; |
||||
} |
||||
|
||||
/* Per the (!is_boot_vga && fb_device) test above, only
|
||||
* trump existing saved devices with boot-VGA devices, so if |
||||
* the test ends up here, this must be the first device seen. */ |
||||
assert(!fb_device); |
||||
fb_device = device; |
||||
} |
||||
|
||||
udev_enumerate_unref(e); |
||||
|
||||
if (fb_device) { |
||||
fb_device_path = strdup(udev_device_get_devnode(fb_device)); |
||||
udev_device_unref(fb_device); |
||||
} |
||||
|
||||
return fb_device_path; |
||||
} |
||||
|
||||
static struct fbdev_backend * |
||||
fbdev_backend_create(struct weston_compositor *compositor, |
||||
struct weston_fbdev_backend_config *param) |
||||
{ |
||||
struct fbdev_backend *backend; |
||||
const char *seat_id = default_seat; |
||||
const char *session_seat; |
||||
|
||||
session_seat = getenv("XDG_SEAT"); |
||||
if (session_seat) |
||||
seat_id = session_seat; |
||||
if (param->seat_id) |
||||
seat_id = param->seat_id; |
||||
|
||||
weston_log("initializing fbdev backend\n"); |
||||
weston_log("warning: the fbdev backend is deprecated, please migrate " |
||||
"to the DRM backend\n"); |
||||
|
||||
backend = zalloc(sizeof *backend); |
||||
if (backend == NULL) |
||||
return NULL; |
||||
|
||||
backend->compositor = compositor; |
||||
compositor->backend = &backend->base; |
||||
if (weston_compositor_set_presentation_clock_software( |
||||
compositor) < 0) |
||||
goto out_compositor; |
||||
|
||||
backend->udev = udev_new(); |
||||
if (backend->udev == NULL) { |
||||
weston_log("Failed to initialize udev context.\n"); |
||||
goto out_compositor; |
||||
} |
||||
|
||||
if (!param->device) |
||||
param->device = find_framebuffer_device(backend, seat_id); |
||||
if (!param->device) { |
||||
weston_log("fatal: no framebuffer devices detected.\n"); |
||||
goto out_udev; |
||||
} |
||||
|
||||
/* Set up the TTY. */ |
||||
backend->session_listener.notify = session_notify; |
||||
wl_signal_add(&compositor->session_signal, |
||||
&backend->session_listener); |
||||
compositor->launcher = |
||||
weston_launcher_connect(compositor, param->tty, seat_id, false); |
||||
if (!compositor->launcher) { |
||||
weston_log("fatal: fbdev backend should be run using " |
||||
"weston-launch binary, or your system should " |
||||
"provide the logind D-Bus API.\n"); |
||||
goto out_udev; |
||||
} |
||||
|
||||
backend->base.destroy = fbdev_backend_destroy; |
||||
backend->base.create_output = fbdev_output_create; |
||||
|
||||
backend->prev_state = WESTON_COMPOSITOR_ACTIVE; |
||||
|
||||
weston_setup_vt_switch_bindings(compositor); |
||||
|
||||
if (pixman_renderer_init(compositor) < 0) |
||||
goto out_launcher; |
||||
|
||||
if (!fbdev_head_create(backend, param->device)) |
||||
goto out_launcher; |
||||
|
||||
free(param->device); |
||||
|
||||
udev_input_init(&backend->input, compositor, backend->udev, |
||||
seat_id, param->configure_device); |
||||
|
||||
return backend; |
||||
|
||||
out_launcher: |
||||
free(param->device); |
||||
weston_launcher_destroy(compositor->launcher); |
||||
|
||||
out_udev: |
||||
udev_unref(backend->udev); |
||||
|
||||
out_compositor: |
||||
weston_compositor_shutdown(compositor); |
||||
free(backend); |
||||
|
||||
return NULL; |
||||
} |
||||
|
||||
static void |
||||
config_init_to_defaults(struct weston_fbdev_backend_config *config) |
||||
{ |
||||
config->tty = 0; /* default to current tty */ |
||||
config->device = NULL; |
||||
config->seat_id = NULL; |
||||
} |
||||
|
||||
WL_EXPORT int |
||||
weston_backend_init(struct weston_compositor *compositor, |
||||
struct weston_backend_config *config_base) |
||||
{ |
||||
struct fbdev_backend *b; |
||||
struct weston_fbdev_backend_config config = {{ 0, }}; |
||||
|
||||
if (config_base == NULL || |
||||
config_base->struct_version != WESTON_FBDEV_BACKEND_CONFIG_VERSION || |
||||
config_base->struct_size > sizeof(struct weston_fbdev_backend_config)) { |
||||
weston_log("fbdev backend config structure is invalid\n"); |
||||
return -1; |
||||
} |
||||
|
||||
config_init_to_defaults(&config); |
||||
memcpy(&config, config_base, config_base->struct_size); |
||||
|
||||
b = fbdev_backend_create(compositor, &config); |
||||
if (b == NULL) |
||||
return -1; |
||||
return 0; |
||||
} |
||||
@ -0,0 +1,33 @@ |
||||
if not get_option('deprecated-backend-fbdev') |
||||
subdir_done() |
||||
endif |
||||
|
||||
warning('Support for the deprecated fbdev backend is enabled.') |
||||
warning('This feature will be removed in a future version.') |
||||
|
||||
config_h.set('BUILD_FBDEV_COMPOSITOR', '1') |
||||
|
||||
srcs_fbdev = [ |
||||
'fbdev.c', |
||||
presentation_time_server_protocol_h, |
||||
] |
||||
|
||||
deps_fbdev = [ |
||||
dep_libweston_private, |
||||
dep_session_helper, |
||||
dep_libinput_backend, |
||||
dependency('libudev', version: '>= 136'), |
||||
] |
||||
|
||||
plugin_fbdev = shared_library( |
||||
'fbdev-backend', |
||||
srcs_fbdev, |
||||
include_directories: common_inc, |
||||
dependencies: deps_fbdev, |
||||
name_prefix: '', |
||||
install: true, |
||||
install_dir: dir_module_libweston |
||||
) |
||||
env_modmap += 'fbdev-backend.so=@0@;'.format(plugin_fbdev.full_path()) |
||||
|
||||
install_headers(backend_fbdev_h, subdir: dir_include_libweston_install) |
||||
File diff suppressed because it is too large
Load Diff
@ -1,263 +0,0 @@ |
||||
/*
|
||||
* Copyright © 2013 Hardening <rdp.effort@gmail.com> |
||||
* Copyright © 2020 Microsoft |
||||
* |
||||
* 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: |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#ifndef RDP_H |
||||
#define RDP_H |
||||
|
||||
#include <freerdp/version.h> |
||||
|
||||
#include <freerdp/freerdp.h> |
||||
#include <freerdp/listener.h> |
||||
#include <freerdp/update.h> |
||||
#include <freerdp/input.h> |
||||
#include <freerdp/codec/color.h> |
||||
#include <freerdp/codec/rfx.h> |
||||
#include <freerdp/codec/nsc.h> |
||||
#include <freerdp/locale/keyboard.h> |
||||
#include <freerdp/channels/wtsvc.h> |
||||
#include <freerdp/server/cliprdr.h> |
||||
|
||||
#include <libweston/libweston.h> |
||||
#include <libweston/backend-rdp.h> |
||||
#include <libweston/weston-log.h> |
||||
|
||||
#include "backend.h" |
||||
|
||||
#include "shared/helpers.h" |
||||
#include "shared/string-helpers.h" |
||||
|
||||
#define MAX_FREERDP_FDS 32 |
||||
#define DEFAULT_AXIS_STEP_DISTANCE 10 |
||||
#define DEFAULT_PIXEL_FORMAT PIXEL_FORMAT_BGRA32 |
||||
|
||||
/* https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getkeyboardtype
|
||||
* defines a keyboard type that isn't currently defined in FreeRDP, but is |
||||
* available for RDP connections */ |
||||
#ifndef KBD_TYPE_KOREAN |
||||
#define KBD_TYPE_KOREAN 8 |
||||
#endif |
||||
|
||||
/* WinPR's GetVirtualKeyCodeFromVirtualScanCode() can't handle hangul/hanja keys */ |
||||
/* 0x1f1 and 0x1f2 keys are only exists on Korean 103 keyboard (Type 8:SubType 6) */ |
||||
|
||||
/* From Linux's keyboard driver at drivers/input/keyboard/atkbd.c */ |
||||
#define ATKBD_RET_HANJA 0xf1 |
||||
#define ATKBD_RET_HANGEUL 0xf2 |
||||
|
||||
struct rdp_output; |
||||
|
||||
struct rdp_backend { |
||||
struct weston_backend base; |
||||
struct weston_compositor *compositor; |
||||
|
||||
freerdp_listener *listener; |
||||
struct wl_event_source *listener_events[MAX_FREERDP_FDS]; |
||||
struct rdp_output *output; |
||||
struct weston_log_scope *debug; |
||||
struct weston_log_scope *verbose; |
||||
|
||||
struct weston_log_scope *clipboard_debug; |
||||
struct weston_log_scope *clipboard_verbose; |
||||
|
||||
struct wl_list peers; |
||||
|
||||
char *server_cert; |
||||
char *server_key; |
||||
char *rdp_key; |
||||
int tls_enabled; |
||||
int no_clients_resize; |
||||
int force_no_compression; |
||||
bool remotefx_codec; |
||||
int external_listener_fd; |
||||
int rdp_monitor_refresh_rate; |
||||
pid_t compositor_tid; |
||||
|
||||
rdp_audio_in_setup audio_in_setup; |
||||
rdp_audio_in_teardown audio_in_teardown; |
||||
rdp_audio_out_setup audio_out_setup; |
||||
rdp_audio_out_teardown audio_out_teardown; |
||||
}; |
||||
|
||||
enum peer_item_flags { |
||||
RDP_PEER_ACTIVATED = (1 << 0), |
||||
RDP_PEER_OUTPUT_ENABLED = (1 << 1), |
||||
}; |
||||
|
||||
struct rdp_peers_item { |
||||
int flags; |
||||
freerdp_peer *peer; |
||||
struct weston_seat *seat; |
||||
|
||||
struct wl_list link; |
||||
}; |
||||
|
||||
struct rdp_head { |
||||
struct weston_head base; |
||||
}; |
||||
|
||||
struct rdp_output { |
||||
struct weston_output base; |
||||
struct wl_event_source *finish_frame_timer; |
||||
pixman_image_t *shadow_surface; |
||||
}; |
||||
|
||||
struct rdp_peer_context { |
||||
rdpContext _p; |
||||
|
||||
struct rdp_backend *rdpBackend; |
||||
struct wl_event_source *events[MAX_FREERDP_FDS + 1]; /* +1 for WTSVirtualChannelManagerGetFileDescriptor */ |
||||
RFX_CONTEXT *rfx_context; |
||||
wStream *encode_stream; |
||||
RFX_RECT *rfx_rects; |
||||
NSC_CONTEXT *nsc_context; |
||||
|
||||
struct rdp_peers_item item; |
||||
|
||||
bool button_state[5]; |
||||
|
||||
int verticalAccumWheelRotationPrecise; |
||||
int verticalAccumWheelRotationDiscrete; |
||||
int horizontalAccumWheelRotationPrecise; |
||||
int horizontalAccumWheelRotationDiscrete; |
||||
|
||||
HANDLE vcm; |
||||
|
||||
/* list of outstanding event_source sent from FreeRDP thread to display loop.*/ |
||||
int loop_task_event_source_fd; |
||||
struct wl_event_source *loop_task_event_source; |
||||
pthread_mutex_t loop_task_list_mutex; |
||||
struct wl_list loop_task_list; /* struct rdp_loop_task::link */ |
||||
|
||||
/* Clipboard support */ |
||||
CliprdrServerContext *clipboard_server_context; |
||||
|
||||
void *audio_in_private; |
||||
void *audio_out_private; |
||||
|
||||
struct rdp_clipboard_data_source *clipboard_client_data_source; |
||||
struct rdp_clipboard_data_source *clipboard_inflight_client_data_source; |
||||
|
||||
struct wl_listener clipboard_selection_listener; |
||||
}; |
||||
|
||||
typedef struct rdp_peer_context RdpPeerContext; |
||||
|
||||
typedef void (*rdp_loop_task_func_t)(bool freeOnly, void *data); |
||||
|
||||
struct rdp_loop_task { |
||||
struct wl_list link; |
||||
RdpPeerContext *peerCtx; |
||||
rdp_loop_task_func_t func; |
||||
}; |
||||
|
||||
#define rdp_debug_verbose(b, ...) \ |
||||
rdp_debug_print(b->verbose, false, __VA_ARGS__) |
||||
#define rdp_debug_verbose_continue(b, ...) \ |
||||
rdp_debug_print(b->verbose, true, __VA_ARGS__) |
||||
#define rdp_debug(b, ...) \ |
||||
rdp_debug_print(b->debug, false, __VA_ARGS__) |
||||
#define rdp_debug_continue(b, ...) \ |
||||
rdp_debug_print(b->debug, true, __VA_ARGS__) |
||||
|
||||
#define rdp_debug_clipboard_verbose(b, ...) \ |
||||
rdp_debug_print(b->clipboard_verbose, false, __VA_ARGS__) |
||||
#define rdp_debug_clipboard_verbose_continue(b, ...) \ |
||||
rdp_debug_print(b->clipboard_verbose, true, __VA_ARGS__) |
||||
#define rdp_debug_clipboard(b, ...) \ |
||||
rdp_debug_print(b->clipboard_debug, false, __VA_ARGS__) |
||||
#define rdp_debug_clipboard_continue(b, ...) \ |
||||
rdp_debug_print(b->clipboard_debug, true, __VA_ARGS__) |
||||
|
||||
/* rdputil.c */ |
||||
void |
||||
rdp_debug_print(struct weston_log_scope *log_scope, bool cont, char *fmt, ...); |
||||
|
||||
int |
||||
rdp_wl_array_read_fd(struct wl_array *array, int fd); |
||||
|
||||
void |
||||
convert_rdp_keyboard_to_xkb_rule_names(UINT32 KeyboardType, UINT32 KeyboardSubType, UINT32 KeyboardLayout, struct xkb_rule_names *xkbRuleNames); |
||||
|
||||
void |
||||
assert_compositor_thread(struct rdp_backend *b); |
||||
|
||||
void |
||||
assert_not_compositor_thread(struct rdp_backend *b); |
||||
|
||||
bool |
||||
rdp_event_loop_add_fd(struct wl_event_loop *loop, |
||||
int fd, uint32_t mask, |
||||
wl_event_loop_fd_func_t func, |
||||
void *data, |
||||
struct wl_event_source **event_source); |
||||
|
||||
void |
||||
rdp_dispatch_task_to_display_loop(RdpPeerContext *peerCtx, |
||||
rdp_loop_task_func_t func, |
||||
struct rdp_loop_task *task); |
||||
|
||||
bool |
||||
rdp_initialize_dispatch_task_event_source(RdpPeerContext *peerCtx); |
||||
|
||||
void |
||||
rdp_destroy_dispatch_task_event_source(RdpPeerContext *peerCtx); |
||||
|
||||
/* rdpclip.c */ |
||||
int |
||||
rdp_clipboard_init(freerdp_peer *client); |
||||
|
||||
void |
||||
rdp_clipboard_destroy(RdpPeerContext *peerCtx); |
||||
|
||||
void |
||||
rdp_head_destroy(struct weston_head *base); |
||||
|
||||
static inline struct rdp_head * |
||||
to_rdp_head(struct weston_head *base) |
||||
{ |
||||
if (base->backend_id != rdp_head_destroy) |
||||
return NULL; |
||||
return container_of(base, struct rdp_head, base); |
||||
} |
||||
|
||||
void |
||||
rdp_output_destroy(struct weston_output *base); |
||||
|
||||
static inline struct rdp_output * |
||||
to_rdp_output(struct weston_output *base) |
||||
{ |
||||
if (base->destroy != rdp_output_destroy) |
||||
return NULL; |
||||
return container_of(base, struct rdp_output, base); |
||||
} |
||||
|
||||
static inline struct rdp_backend * |
||||
to_rdp_backend(struct weston_compositor *base) |
||||
{ |
||||
return container_of(base->backend, struct rdp_backend, base); |
||||
} |
||||
|
||||
#endif |
||||
File diff suppressed because it is too large
Load Diff
@ -1,262 +0,0 @@ |
||||
/*
|
||||
* Copyright © 2020 Microsoft |
||||
* |
||||
* 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: |
||||
* |
||||
* 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. |
||||
*/ |
||||
|
||||
#include "config.h" |
||||
|
||||
#include <assert.h> |
||||
#include <stdint.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
#include <pthread.h> |
||||
#include <sys/mman.h> |
||||
#include <sys/syscall.h> |
||||
#include <sys/types.h> |
||||
#include <sys/eventfd.h> |
||||
#include <sys/time.h> |
||||
#include <sys/stat.h> |
||||
#include <fcntl.h> |
||||
|
||||
#include "rdp.h" |
||||
|
||||
static int cached_tm_mday = -1; |
||||
|
||||
void rdp_debug_print(struct weston_log_scope *log_scope, bool cont, char *fmt, ...) |
||||
{ |
||||
char timestr[128]; |
||||
int len_va; |
||||
char *str; |
||||
|
||||
if (!log_scope || !weston_log_scope_is_enabled(log_scope)) |
||||
return; |
||||
|
||||
va_list ap; |
||||
va_start(ap, fmt); |
||||
|
||||
if (cont) { |
||||
weston_log_scope_vprintf(log_scope, fmt, ap); |
||||
goto end; |
||||
} |
||||
|
||||
weston_log_timestamp(timestr, sizeof(timestr), &cached_tm_mday); |
||||
len_va = vasprintf(&str, fmt, ap); |
||||
if (len_va >= 0) { |
||||
weston_log_scope_printf(log_scope, "%s %s", |
||||
timestr, str); |
||||
free(str); |
||||
} else { |
||||
const char *oom = "Out of memory"; |
||||
|
||||
weston_log_scope_printf(log_scope, "%s %s", |
||||
timestr, oom); |
||||
} |
||||
end: |
||||
va_end(ap); |
||||
} |
||||
|
||||
void |
||||
assert_compositor_thread(struct rdp_backend *b) |
||||
{ |
||||
assert(b->compositor_tid == gettid()); |
||||
} |
||||
|
||||
void |
||||
assert_not_compositor_thread(struct rdp_backend *b) |
||||
{ |
||||
assert(b->compositor_tid != gettid()); |
||||
} |
||||
|
||||
bool |
||||
rdp_event_loop_add_fd(struct wl_event_loop *loop, |
||||
int fd, uint32_t mask, |
||||
wl_event_loop_fd_func_t func, |
||||
void *data, struct wl_event_source **event_source) |
||||
{ |
||||
*event_source = wl_event_loop_add_fd(loop, fd, 0, func, data); |
||||
if (!*event_source) { |
||||
weston_log("%s: wl_event_loop_add_fd failed.\n", __func__); |
||||
return false; |
||||
} |
||||
|
||||
wl_event_source_fd_update(*event_source, mask); |
||||
return true; |
||||
} |
||||
|
||||
void |
||||
rdp_dispatch_task_to_display_loop(RdpPeerContext *peerCtx, |
||||
rdp_loop_task_func_t func, |
||||
struct rdp_loop_task *task) |
||||
{ |
||||
/* this function is ONLY used to queue the task from FreeRDP thread,
|
||||
* and the task to be processed at wayland display loop thread. */ |
||||
assert_not_compositor_thread(peerCtx->rdpBackend); |
||||
|
||||
task->peerCtx = peerCtx; |
||||
task->func = func; |
||||
|
||||
pthread_mutex_lock(&peerCtx->loop_task_list_mutex); |
||||
/* this inserts at head */ |
||||
wl_list_insert(&peerCtx->loop_task_list, &task->link); |
||||
pthread_mutex_unlock(&peerCtx->loop_task_list_mutex); |
||||
|
||||
eventfd_write(peerCtx->loop_task_event_source_fd, 1); |
||||
} |
||||
|
||||
static int |
||||
rdp_dispatch_task(int fd, uint32_t mask, void *arg) |
||||
{ |
||||
RdpPeerContext *peerCtx = (RdpPeerContext *)arg; |
||||
struct rdp_loop_task *task, *tmp; |
||||
eventfd_t dummy; |
||||
|
||||
/* this must be called back at wayland display loop thread */ |
||||
assert_compositor_thread(peerCtx->rdpBackend); |
||||
|
||||
eventfd_read(peerCtx->loop_task_event_source_fd, &dummy); |
||||
|
||||
pthread_mutex_lock(&peerCtx->loop_task_list_mutex); |
||||
/* dequeue the first task which is at last, so use reverse. */ |
||||
assert(!wl_list_empty(&peerCtx->loop_task_list)); |
||||
wl_list_for_each_reverse_safe(task, tmp, &peerCtx->loop_task_list, link) { |
||||
wl_list_remove(&task->link); |
||||
break; |
||||
} |
||||
pthread_mutex_unlock(&peerCtx->loop_task_list_mutex); |
||||
|
||||
/* Dispatch and task will be freed by caller. */ |
||||
task->func(false, task); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
bool |
||||
rdp_initialize_dispatch_task_event_source(RdpPeerContext *peerCtx) |
||||
{ |
||||
struct rdp_backend *b = peerCtx->rdpBackend; |
||||
struct wl_event_loop *loop; |
||||
bool ret; |
||||
|
||||
if (pthread_mutex_init(&peerCtx->loop_task_list_mutex, NULL) == -1) { |
||||
weston_log("%s: pthread_mutex_init failed. %s\n", __func__, strerror(errno)); |
||||
goto error_mutex; |
||||
} |
||||
|
||||
assert(peerCtx->loop_task_event_source_fd == -1); |
||||
peerCtx->loop_task_event_source_fd = eventfd(0, EFD_SEMAPHORE | EFD_CLOEXEC); |
||||
if (peerCtx->loop_task_event_source_fd == -1) { |
||||
weston_log("%s: eventfd(EFD_SEMAPHORE) failed. %s\n", __func__, strerror(errno)); |
||||
goto error_event_source_fd; |
||||
} |
||||
|
||||
assert(wl_list_empty(&peerCtx->loop_task_list)); |
||||
|
||||
loop = wl_display_get_event_loop(b->compositor->wl_display); |
||||
assert(peerCtx->loop_task_event_source == NULL); |
||||
|
||||
ret = rdp_event_loop_add_fd(loop, |
||||
peerCtx->loop_task_event_source_fd, |
||||
WL_EVENT_READABLE, rdp_dispatch_task, |
||||
peerCtx, |
||||
&peerCtx->loop_task_event_source); |
||||
if (!ret) |
||||
goto error_event_loop_add_fd; |
||||
|
||||
return true; |
||||
|
||||
error_event_loop_add_fd: |
||||
close(peerCtx->loop_task_event_source_fd); |
||||
peerCtx->loop_task_event_source_fd = -1; |
||||
|
||||
error_event_source_fd: |
||||
pthread_mutex_destroy(&peerCtx->loop_task_list_mutex); |
||||
|
||||
error_mutex: |
||||
return false; |
||||
} |
||||
|
||||
void |
||||
rdp_destroy_dispatch_task_event_source(RdpPeerContext *peerCtx) |
||||
{ |
||||
struct rdp_loop_task *task, *tmp; |
||||
|
||||
/* This function must be called all virtual channel thread at FreeRDP is terminated,
|
||||
* that ensures no more incoming tasks. */ |
||||
|
||||
if (peerCtx->loop_task_event_source) { |
||||
wl_event_source_remove(peerCtx->loop_task_event_source); |
||||
peerCtx->loop_task_event_source = NULL; |
||||
} |
||||
|
||||
wl_list_for_each_reverse_safe(task, tmp, &peerCtx->loop_task_list, link) { |
||||
wl_list_remove(&task->link); |
||||
/* inform caller task is not really scheduled prior to context destruction,
|
||||
* inform them to clean them up. */ |
||||
task->func(true /* freeOnly */, task); |
||||
} |
||||
assert(wl_list_empty(&peerCtx->loop_task_list)); |
||||
|
||||
if (peerCtx->loop_task_event_source_fd != -1) { |
||||
close(peerCtx->loop_task_event_source_fd); |
||||
peerCtx->loop_task_event_source_fd = -1; |
||||
} |
||||
|
||||
pthread_mutex_destroy(&peerCtx->loop_task_list_mutex); |
||||
} |
||||
|
||||
/* This is a little tricky - it makes sure there's always at least
|
||||
* one spare byte in the array in case the caller needs to add a |
||||
* null terminator to it. We can't just null terminate the array |
||||
* here, because some callers won't want that - and some won't |
||||
* like having an odd number of bytes. |
||||
*/ |
||||
int |
||||
rdp_wl_array_read_fd(struct wl_array *array, int fd) |
||||
{ |
||||
int len, size; |
||||
char *data; |
||||
|
||||
/* Make sure we have at least 1024 bytes of space left */ |
||||
if (array->alloc - array->size < 1024) { |
||||
if (!wl_array_add(array, 1024)) { |
||||
errno = ENOMEM; |
||||
return -1; |
||||
} |
||||
array->size -= 1024; |
||||
} |
||||
data = (char *)array->data + array->size; |
||||
/* Leave one char in case the caller needs space for a
|
||||
* null terminator */ |
||||
size = array->alloc - array->size - 1; |
||||
do { |
||||
len = read(fd, data, size); |
||||
} while (len == -1 && errno == EINTR); |
||||
|
||||
if (len == -1) |
||||
return -1; |
||||
|
||||
array->size += len; |
||||
|
||||
return len; |
||||
} |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue