Merge branch 'master' into feature/data-device-selection
This commit is contained in:
commit
1dbe314937
|
@ -9,9 +9,9 @@
|
|||
#include <wlr/backend/session.h>
|
||||
#include <wlr/backend/interface.h>
|
||||
#include <wlr/interfaces/wlr_output.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <wlr/types/wlr_list.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include "backend/drm/drm.h"
|
||||
|
||||
static bool wlr_drm_backend_start(struct wlr_backend *backend) {
|
||||
|
@ -29,8 +29,8 @@ static void wlr_drm_backend_destroy(struct wlr_backend *backend) {
|
|||
|
||||
wlr_drm_restore_outputs(drm);
|
||||
|
||||
for (size_t i = 0; drm->outputs && i < drm->outputs->length; ++i) {
|
||||
struct wlr_drm_connector *conn = drm->outputs->items[i];
|
||||
struct wlr_drm_connector *conn;
|
||||
wl_list_for_each(conn, &drm->outputs, link) {
|
||||
wlr_output_destroy(&conn->output);
|
||||
}
|
||||
|
||||
|
@ -38,7 +38,6 @@ static void wlr_drm_backend_destroy(struct wlr_backend *backend) {
|
|||
wlr_drm_renderer_finish(&drm->renderer);
|
||||
wlr_session_close_file(drm->session, drm->fd);
|
||||
wl_event_source_remove(drm->drm_event);
|
||||
list_free(drm->outputs);
|
||||
free(drm);
|
||||
}
|
||||
|
||||
|
@ -63,10 +62,13 @@ static void session_signal(struct wl_listener *listener, void *data) {
|
|||
|
||||
if (session->active) {
|
||||
wlr_log(L_INFO, "DRM fd resumed");
|
||||
wlr_drm_scan_connectors(drm);
|
||||
|
||||
for (size_t i = 0; i < drm->outputs->length; ++i) {
|
||||
struct wlr_drm_connector *conn = drm->outputs->items[i];
|
||||
wlr_drm_connector_start_renderer(conn);
|
||||
struct wlr_drm_connector *conn;
|
||||
wl_list_for_each(conn, &drm->outputs, link){
|
||||
if (conn->output.current_mode) {
|
||||
wlr_output_set_mode(&conn->output, conn->output.current_mode);
|
||||
}
|
||||
|
||||
if (!conn->crtc) {
|
||||
continue;
|
||||
|
@ -110,11 +112,7 @@ struct wlr_backend *wlr_drm_backend_create(struct wl_display *display,
|
|||
wlr_backend_init(&drm->backend, &backend_impl);
|
||||
|
||||
drm->session = session;
|
||||
drm->outputs = list_create();
|
||||
if (!drm->outputs) {
|
||||
wlr_log(L_ERROR, "Failed to allocate list");
|
||||
goto error_backend;
|
||||
}
|
||||
wl_list_init(&drm->outputs);
|
||||
|
||||
drm->fd = gpu_fd;
|
||||
drm->parent = (struct wlr_drm_backend *)parent;
|
||||
|
@ -158,8 +156,6 @@ error_event:
|
|||
wl_event_source_remove(drm->drm_event);
|
||||
error_fd:
|
||||
wlr_session_close_file(drm->session, drm->fd);
|
||||
list_free(drm->outputs);
|
||||
error_backend:
|
||||
free(drm);
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
@ -177,9 +177,6 @@ void wlr_drm_resources_free(struct wlr_drm_backend *drm) {
|
|||
if (plane->wlr_tex) {
|
||||
wlr_texture_destroy(plane->wlr_tex);
|
||||
}
|
||||
if (plane->wlr_rend) {
|
||||
wlr_renderer_destroy(plane->wlr_rend);
|
||||
}
|
||||
}
|
||||
|
||||
free(drm->crtcs);
|
||||
|
@ -193,7 +190,7 @@ static void wlr_drm_connector_make_current(struct wlr_output *output) {
|
|||
|
||||
static void wlr_drm_connector_swap_buffers(struct wlr_output *output) {
|
||||
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
|
||||
struct wlr_drm_backend *drm = conn->drm;
|
||||
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
|
||||
|
||||
struct wlr_drm_crtc *crtc = conn->crtc;
|
||||
struct wlr_drm_plane *plane = crtc->primary;
|
||||
|
@ -214,12 +211,13 @@ static void wlr_drm_connector_swap_buffers(struct wlr_output *output) {
|
|||
}
|
||||
|
||||
static void wlr_drm_connector_set_gamma(struct wlr_output *output,
|
||||
uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b) {
|
||||
uint32_t size, uint16_t *r, uint16_t *g, uint16_t *b) {
|
||||
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
|
||||
drmModeCrtcSetGamma(conn->drm->fd, conn->crtc->id, size, r, g, b);
|
||||
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
|
||||
drmModeCrtcSetGamma(drm->fd, conn->crtc->id, size, r, g, b);
|
||||
}
|
||||
|
||||
static uint16_t wlr_drm_connector_get_gamma_size(struct wlr_output *output) {
|
||||
static uint32_t wlr_drm_connector_get_gamma_size(struct wlr_output *output) {
|
||||
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
|
||||
drmModeCrtc *crtc = conn->old_crtc;
|
||||
return crtc ? crtc->gamma_size : 0;
|
||||
|
@ -230,7 +228,7 @@ void wlr_drm_connector_start_renderer(struct wlr_drm_connector *conn) {
|
|||
return;
|
||||
}
|
||||
|
||||
struct wlr_drm_backend *drm = conn->drm;
|
||||
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend;
|
||||
struct wlr_drm_crtc *crtc = conn->crtc;
|
||||
struct wlr_drm_plane *plane = crtc->primary;
|
||||
|
||||
|
@ -253,7 +251,7 @@ static void wlr_drm_connector_enable(struct wlr_output *output, bool enable) {
|
|||
return;
|
||||
}
|
||||
|
||||
struct wlr_drm_backend *drm = conn->drm;
|
||||
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
|
||||
drm->iface->conn_enable(drm, conn, enable);
|
||||
|
||||
if (enable) {
|
||||
|
@ -261,7 +259,8 @@ static void wlr_drm_connector_enable(struct wlr_output *output, bool enable) {
|
|||
}
|
||||
}
|
||||
|
||||
static void realloc_planes(struct wlr_drm_backend *drm, const uint32_t *crtc_in) {
|
||||
static void realloc_planes(struct wlr_drm_backend *drm, const uint32_t *crtc_in,
|
||||
bool *changed_outputs) {
|
||||
// overlay, primary, cursor
|
||||
for (int type = 0; type < 3; ++type) {
|
||||
if (drm->num_type_planes[type] == 0) {
|
||||
|
@ -300,6 +299,7 @@ static void realloc_planes(struct wlr_drm_backend *drm, const uint32_t *crtc_in)
|
|||
struct wlr_drm_plane *new = &drm->type_planes[type][crtc_res[i]];
|
||||
|
||||
if (*old != new) {
|
||||
changed_outputs[crtc_res[i]] = true;
|
||||
if (*old) {
|
||||
wlr_drm_surface_finish(&(*old)->surf);
|
||||
}
|
||||
|
@ -310,10 +310,12 @@ static void realloc_planes(struct wlr_drm_backend *drm, const uint32_t *crtc_in)
|
|||
}
|
||||
}
|
||||
|
||||
static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector *conn) {
|
||||
static void realloc_crtcs(struct wlr_drm_backend *drm,
|
||||
struct wlr_drm_connector *conn, bool *changed_outputs) {
|
||||
uint32_t crtc[drm->num_crtcs];
|
||||
uint32_t crtc_res[drm->num_crtcs];
|
||||
uint32_t possible_crtc[drm->outputs->length];
|
||||
ssize_t num_outputs = wl_list_length(&drm->outputs);
|
||||
uint32_t possible_crtc[num_outputs];
|
||||
|
||||
for (size_t i = 0; i < drm->num_crtcs; ++i) {
|
||||
crtc[i] = UNMATCHED;
|
||||
|
@ -321,54 +323,71 @@ static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector
|
|||
|
||||
memset(possible_crtc, 0, sizeof(possible_crtc));
|
||||
|
||||
ssize_t index = -1;
|
||||
for (size_t i = 0; i < drm->outputs->length; ++i) {
|
||||
struct wlr_drm_connector *c = drm->outputs->items[i];
|
||||
ssize_t index = -1, i = -1;
|
||||
struct wlr_drm_connector *c;
|
||||
wl_list_for_each(c, &drm->outputs, link) {
|
||||
i++;
|
||||
if (c == conn) {
|
||||
index = i;
|
||||
}
|
||||
|
||||
if (c->state != WLR_DRM_CONN_CONNECTED) {
|
||||
continue;
|
||||
if (c->crtc) {
|
||||
crtc[c->crtc - drm->crtcs] = i;
|
||||
}
|
||||
|
||||
if (c->state == WLR_DRM_CONN_CONNECTED) {
|
||||
possible_crtc[i] = c->possible_crtc;
|
||||
}
|
||||
|
||||
possible_crtc[i] = c->possible_crtc;
|
||||
crtc[c->crtc - drm->crtcs] = i;
|
||||
}
|
||||
assert(index != -1);
|
||||
|
||||
possible_crtc[index] = conn->possible_crtc;
|
||||
match_obj(drm->outputs->length, possible_crtc, drm->num_crtcs,
|
||||
crtc, crtc_res);
|
||||
match_obj(wl_list_length(&drm->outputs), possible_crtc,
|
||||
drm->num_crtcs, crtc, crtc_res);
|
||||
|
||||
bool matched = false;
|
||||
bool matched[num_outputs];
|
||||
memset(matched, false, sizeof(matched));
|
||||
for (size_t i = 0; i < drm->num_crtcs; ++i) {
|
||||
// We don't want any of the current monitors to be deactivated.
|
||||
if (crtc[i] != UNMATCHED && crtc_res[i] == UNMATCHED) {
|
||||
return;
|
||||
}
|
||||
if (crtc_res[i] == index) {
|
||||
matched = true;
|
||||
if (crtc_res[i] != UNMATCHED) {
|
||||
matched[crtc_res[i]] = true;
|
||||
}
|
||||
}
|
||||
|
||||
// There is no point doing anything if this monitor doesn't get activated
|
||||
if (!matched) {
|
||||
if (!matched[index]) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < drm->num_crtcs; ++i) {
|
||||
// We don't want any of the current monitors to be deactivated.
|
||||
if (crtc[i] != UNMATCHED && !matched[crtc[i]]) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
changed_outputs[index] = true;
|
||||
|
||||
for (size_t i = 0; i < drm->num_crtcs; ++i) {
|
||||
if (crtc_res[i] == UNMATCHED) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (crtc_res[i] != crtc[i]) {
|
||||
struct wlr_drm_connector *c = drm->outputs->items[crtc_res[i]];
|
||||
changed_outputs[crtc_res[i]] = true;
|
||||
struct wlr_drm_connector *c;
|
||||
size_t pos = 0;
|
||||
wl_list_for_each(c, &drm->outputs, link) {
|
||||
if (pos == crtc_res[i]) {
|
||||
break;
|
||||
}
|
||||
pos++;
|
||||
}
|
||||
c->crtc = &drm->crtcs[i];
|
||||
}
|
||||
}
|
||||
|
||||
realloc_planes(drm, crtc_res);
|
||||
realloc_planes(drm, crtc_res, changed_outputs);
|
||||
}
|
||||
|
||||
static uint32_t get_possible_crtcs(int fd, uint32_t conn_id) {
|
||||
|
@ -406,7 +425,8 @@ error_conn:
|
|||
static bool wlr_drm_connector_set_mode(struct wlr_output *output,
|
||||
struct wlr_output_mode *mode) {
|
||||
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
|
||||
struct wlr_drm_backend *drm = conn->drm;
|
||||
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
|
||||
bool changed_outputs[wl_list_length(&drm->outputs)];
|
||||
|
||||
wlr_log(L_INFO, "Modesetting '%s' with '%ux%u@%u mHz'", conn->output.name,
|
||||
mode->width, mode->height, mode->refresh);
|
||||
|
@ -416,7 +436,8 @@ static bool wlr_drm_connector_set_mode(struct wlr_output *output,
|
|||
goto error_conn;
|
||||
}
|
||||
|
||||
realloc_crtcs(drm, conn);
|
||||
memset(changed_outputs, false, sizeof(changed_outputs));
|
||||
realloc_crtcs(drm, conn, changed_outputs);
|
||||
|
||||
if (!conn->crtc) {
|
||||
wlr_log(L_ERROR, "Unable to match %s with a CRTC", conn->output.name);
|
||||
|
@ -431,19 +452,23 @@ static bool wlr_drm_connector_set_mode(struct wlr_output *output,
|
|||
crtc->cursor ? crtc->cursor - drm->cursor_planes : -1);
|
||||
|
||||
conn->state = WLR_DRM_CONN_CONNECTED;
|
||||
conn->output.width = mode->width;
|
||||
conn->output.height = mode->height;
|
||||
conn->output.current_mode = mode;
|
||||
wl_signal_emit(&conn->output.events.resolution, &conn->output);
|
||||
if (conn->output.width != mode->width || conn->output.height != mode->height) {
|
||||
conn->output.width = mode->width;
|
||||
conn->output.height = mode->height;
|
||||
wl_signal_emit(&conn->output.events.resolution, &conn->output);
|
||||
}
|
||||
|
||||
// Since realloc_crtcs can deallocate planes on OTHER outputs,
|
||||
// we actually need to reinitalise all of them
|
||||
for (size_t i = 0; i < drm->outputs->length; ++i) {
|
||||
struct wlr_drm_connector *conn = drm->outputs->items[i];
|
||||
// we actually need to reinitalise any than has changed
|
||||
ssize_t output_index = -1;
|
||||
wl_list_for_each(conn, &drm->outputs, link) {
|
||||
output_index += 1;
|
||||
struct wlr_output_mode *mode = conn->output.current_mode;
|
||||
struct wlr_drm_crtc *crtc = conn->crtc;
|
||||
|
||||
if (conn->state != WLR_DRM_CONN_CONNECTED) {
|
||||
if (conn->state != WLR_DRM_CONN_CONNECTED ||
|
||||
!changed_outputs[output_index]) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
@ -472,7 +497,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
|
|||
const uint8_t *buf, int32_t stride, uint32_t width, uint32_t height,
|
||||
int32_t hotspot_x, int32_t hotspot_y, bool update_pixels) {
|
||||
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
|
||||
struct wlr_drm_backend *drm = conn->drm;
|
||||
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
|
||||
struct wlr_drm_renderer *renderer = &drm->renderer;
|
||||
|
||||
struct wlr_drm_crtc *crtc = conn->crtc;
|
||||
|
@ -525,12 +550,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
|
|||
|
||||
// TODO the image needs to be rotated depending on the output rotation
|
||||
|
||||
plane->wlr_rend = wlr_gles2_renderer_create(&drm->backend);
|
||||
if (!plane->wlr_rend) {
|
||||
return false;
|
||||
}
|
||||
|
||||
plane->wlr_tex = wlr_render_texture_create(plane->wlr_rend);
|
||||
plane->wlr_tex = wlr_render_texture_create(plane->surf.renderer->wlr_rend);
|
||||
if (!plane->wlr_tex) {
|
||||
return false;
|
||||
}
|
||||
|
@ -595,7 +615,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
|
|||
|
||||
float matrix[16];
|
||||
wlr_texture_get_matrix(plane->wlr_tex, &matrix, &plane->matrix, 0, 0);
|
||||
wlr_render_with_matrix(plane->wlr_rend, plane->wlr_tex, &matrix);
|
||||
wlr_render_with_matrix(plane->surf.renderer->wlr_rend, plane->wlr_tex, &matrix);
|
||||
|
||||
glFinish();
|
||||
glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, bo_stride);
|
||||
|
@ -612,7 +632,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
|
|||
static bool wlr_drm_connector_move_cursor(struct wlr_output *output,
|
||||
int x, int y) {
|
||||
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
|
||||
struct wlr_drm_backend *drm = conn->drm;
|
||||
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
|
||||
|
||||
int width, height, tmp;
|
||||
wlr_output_effective_resolution(output, &width, &height);
|
||||
|
@ -667,13 +687,6 @@ static int retry_pageflip(void *data) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int find_id(const void *item, const void *cmp_to) {
|
||||
const struct wlr_drm_connector *conn = item;
|
||||
const uint32_t *id = cmp_to;
|
||||
|
||||
return (int)conn->id - (int)*id;
|
||||
}
|
||||
|
||||
static const int32_t subpixel_map[] = {
|
||||
[DRM_MODE_SUBPIXEL_UNKNOWN] = WL_OUTPUT_SUBPIXEL_UNKNOWN,
|
||||
[DRM_MODE_SUBPIXEL_HORIZONTAL_RGB] = WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB,
|
||||
|
@ -692,8 +705,9 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
|
|||
return;
|
||||
}
|
||||
|
||||
size_t seen_len = drm->outputs->length;
|
||||
// +1 so it can never be 0
|
||||
size_t seen_len = wl_list_length(&drm->outputs);
|
||||
// +1 so length can never be 0, which is undefined behaviour.
|
||||
// Last element isn't used.
|
||||
bool seen[seen_len + 1];
|
||||
memset(seen, 0, sizeof(seen));
|
||||
|
||||
|
@ -704,33 +718,39 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
|
|||
wlr_log_errno(L_ERROR, "Failed to get DRM connector");
|
||||
continue;
|
||||
}
|
||||
drmModeEncoder *curr_enc = drmModeGetEncoder(drm->fd,
|
||||
drm_conn->encoder_id);
|
||||
|
||||
struct wlr_drm_connector *wlr_conn;
|
||||
int index = list_seq_find(drm->outputs, find_id, &drm_conn->connector_id);
|
||||
int index = -1;
|
||||
struct wlr_drm_connector *c, *wlr_conn = NULL;
|
||||
wl_list_for_each(c, &drm->outputs, link) {
|
||||
index++;
|
||||
if (c->id == drm_conn->connector_id) {
|
||||
wlr_conn = c;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (index == -1) {
|
||||
if (!wlr_conn) {
|
||||
wlr_conn = calloc(1, sizeof(*wlr_conn));
|
||||
if (!wlr_conn) {
|
||||
wlr_log_errno(L_ERROR, "Allocation failed");
|
||||
drmModeFreeEncoder(curr_enc);
|
||||
drmModeFreeConnector(drm_conn);
|
||||
continue;
|
||||
}
|
||||
wlr_output_init(&wlr_conn->output, &output_impl);
|
||||
wlr_output_init(&wlr_conn->output, &drm->backend, &output_impl);
|
||||
|
||||
struct wl_event_loop *ev = wl_display_get_event_loop(drm->display);
|
||||
wlr_conn->retry_pageflip = wl_event_loop_add_timer(ev, retry_pageflip,
|
||||
wlr_conn);
|
||||
|
||||
|
||||
wlr_conn->drm = drm;
|
||||
wlr_conn->state = WLR_DRM_CONN_DISCONNECTED;
|
||||
wlr_conn->id = drm_conn->connector_id;
|
||||
|
||||
drmModeEncoder *curr_enc = drmModeGetEncoder(drm->fd,
|
||||
drm_conn->encoder_id);
|
||||
if (curr_enc) {
|
||||
wlr_conn->old_crtc = drmModeGetCrtc(drm->fd, curr_enc->crtc_id);
|
||||
drmModeFreeEncoder(curr_enc);
|
||||
}
|
||||
|
||||
wlr_conn->output.phys_width = drm_conn->mmWidth;
|
||||
|
@ -749,23 +769,25 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
|
|||
parse_edid(&wlr_conn->output, edid_len, edid);
|
||||
free(edid);
|
||||
|
||||
if (list_add(drm->outputs, wlr_conn) == -1) {
|
||||
wlr_log_errno(L_ERROR, "Allocation failed");
|
||||
drmModeFreeConnector(drm_conn);
|
||||
wl_event_source_remove(wlr_conn->retry_pageflip);
|
||||
free(wlr_conn);
|
||||
continue;
|
||||
}
|
||||
wlr_output_create_global(&wlr_conn->output, drm->display);
|
||||
wl_list_insert(&drm->outputs, &wlr_conn->link);
|
||||
wlr_log(L_INFO, "Found display '%s'", wlr_conn->output.name);
|
||||
} else {
|
||||
wlr_conn = drm->outputs->items[index];
|
||||
seen[index] = true;
|
||||
}
|
||||
|
||||
if (curr_enc) {
|
||||
for (size_t i = 0; i < drm->num_crtcs; ++i) {
|
||||
if (drm->crtcs[i].id == curr_enc->crtc_id) {
|
||||
wlr_conn->crtc = &drm->crtcs[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
wlr_conn->crtc = NULL;
|
||||
}
|
||||
|
||||
if (wlr_conn->state == WLR_DRM_CONN_DISCONNECTED &&
|
||||
drm_conn->connection == DRM_MODE_CONNECTED) {
|
||||
|
||||
wlr_log(L_INFO, "'%s' connected", wlr_conn->output.name);
|
||||
wlr_log(L_INFO, "Detected modes:");
|
||||
|
||||
|
@ -784,51 +806,50 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
|
|||
mode->wlr_mode.width, mode->wlr_mode.height,
|
||||
mode->wlr_mode.refresh);
|
||||
|
||||
if (list_add(wlr_conn->output.modes, mode) == -1) {
|
||||
wlr_log_errno(L_ERROR, "Allocation failed");
|
||||
free(mode);
|
||||
continue;
|
||||
}
|
||||
wl_list_insert(&wlr_conn->output.modes, &mode->wlr_mode.link);
|
||||
}
|
||||
|
||||
wlr_output_create_global(&wlr_conn->output, drm->display);
|
||||
|
||||
wlr_conn->state = WLR_DRM_CONN_NEEDS_MODESET;
|
||||
wlr_log(L_INFO, "Sending modesetting signal for '%s'",
|
||||
wlr_conn->output.name);
|
||||
wl_signal_emit(&drm->backend.events.output_add, &wlr_conn->output);
|
||||
} else if (wlr_conn->state == WLR_DRM_CONN_CONNECTED &&
|
||||
drm_conn->connection != DRM_MODE_CONNECTED) {
|
||||
|
||||
wlr_log(L_INFO, "'%s' disconnected", wlr_conn->output.name);
|
||||
|
||||
wlr_output_destroy_global(&wlr_conn->output);
|
||||
wlr_drm_connector_cleanup(wlr_conn);
|
||||
}
|
||||
|
||||
drmModeFreeEncoder(curr_enc);
|
||||
drmModeFreeConnector(drm_conn);
|
||||
}
|
||||
|
||||
drmModeFreeResources(res);
|
||||
|
||||
for (size_t i = seen_len; i-- > 0;) {
|
||||
if (seen[i]) {
|
||||
struct wlr_drm_connector *conn, *tmp_conn;
|
||||
size_t index = wl_list_length(&drm->outputs);
|
||||
wl_list_for_each_safe(conn, tmp_conn, &drm->outputs, link) {
|
||||
index--;
|
||||
if (index >= seen_len || seen[index]) {
|
||||
continue;
|
||||
}
|
||||
|
||||
struct wlr_drm_connector *conn = drm->outputs->items[i];
|
||||
|
||||
wlr_log(L_INFO, "'%s' disappeared", conn->output.name);
|
||||
wlr_drm_connector_cleanup(conn);
|
||||
|
||||
drmModeFreeCrtc(conn->old_crtc);
|
||||
wl_event_source_remove(conn->retry_pageflip);
|
||||
free(conn);
|
||||
|
||||
list_del(drm->outputs, i);
|
||||
}
|
||||
}
|
||||
|
||||
static void page_flip_handler(int fd, unsigned seq,
|
||||
unsigned tv_sec, unsigned tv_usec, void *user) {
|
||||
struct wlr_drm_connector *conn = user;
|
||||
struct wlr_drm_backend *drm = conn->drm;
|
||||
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend;
|
||||
|
||||
conn->pageflip_pending = false;
|
||||
if (conn->state != WLR_DRM_CONN_CONNECTED) {
|
||||
|
@ -856,10 +877,10 @@ int wlr_drm_event(int fd, uint32_t mask, void *data) {
|
|||
}
|
||||
|
||||
void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
|
||||
uint64_t to_close = (1 << drm->outputs->length) - 1;
|
||||
uint64_t to_close = (1 << wl_list_length(&drm->outputs)) - 1;
|
||||
|
||||
for (size_t i = 0; i < drm->outputs->length; ++i) {
|
||||
struct wlr_drm_connector *conn = drm->outputs->items[i];
|
||||
struct wlr_drm_connector *conn;
|
||||
wl_list_for_each(conn, &drm->outputs, link) {
|
||||
if (conn->state == WLR_DRM_CONN_CONNECTED) {
|
||||
conn->state = WLR_DRM_CONN_CLEANUP;
|
||||
}
|
||||
|
@ -869,11 +890,13 @@ void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
|
|||
|
||||
while (to_close && time(NULL) < timeout) {
|
||||
wlr_drm_event(drm->fd, 0, NULL);
|
||||
for (size_t i = 0; i < drm->outputs->length; ++i) {
|
||||
struct wlr_drm_connector *conn = drm->outputs->items[i];
|
||||
size_t i = 0;
|
||||
struct wlr_drm_connector *conn;
|
||||
wl_list_for_each(conn, &drm->outputs, link) {
|
||||
if (conn->state != WLR_DRM_CONN_CLEANUP || !conn->pageflip_pending) {
|
||||
to_close &= ~(1 << i);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -881,8 +904,7 @@ void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
|
|||
wlr_log(L_ERROR, "Timed out stopping output renderers");
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < drm->outputs->length; ++i) {
|
||||
struct wlr_drm_connector *conn = drm->outputs->items[i];
|
||||
wl_list_for_each(conn, &drm->outputs, link) {
|
||||
drmModeCrtc *crtc = conn->old_crtc;
|
||||
if (!crtc) {
|
||||
continue;
|
||||
|
@ -899,7 +921,7 @@ void wlr_drm_connector_cleanup(struct wlr_drm_connector *conn) {
|
|||
return;
|
||||
}
|
||||
|
||||
struct wlr_drm_backend *drm = conn->drm;
|
||||
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend;
|
||||
|
||||
switch (conn->state) {
|
||||
case WLR_DRM_CONN_CONNECTED:
|
||||
|
|
|
@ -8,8 +8,8 @@
|
|||
#include <EGL/eglext.h>
|
||||
#include <wayland-util.h>
|
||||
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/render/matrix.h>
|
||||
#include <wlr/render/gles2.h>
|
||||
#include <wlr/render.h>
|
||||
|
|
|
@ -99,15 +99,15 @@ static void wlr_libinput_backend_destroy(struct wlr_backend *_backend) {
|
|||
}
|
||||
struct wlr_libinput_backend *backend = (struct wlr_libinput_backend *)_backend;
|
||||
for (size_t i = 0; i < backend->wlr_device_lists->length; i++) {
|
||||
list_t *wlr_devices = backend->wlr_device_lists->items[i];
|
||||
struct wlr_list *wlr_devices = backend->wlr_device_lists->items[i];
|
||||
for (size_t j = 0; j < wlr_devices->length; j++) {
|
||||
struct wlr_input_device *wlr_dev = wlr_devices->items[j];
|
||||
wl_signal_emit(&backend->backend.events.input_remove, wlr_dev);
|
||||
wlr_input_device_destroy(wlr_dev);
|
||||
}
|
||||
list_free(wlr_devices);
|
||||
wlr_list_free(wlr_devices);
|
||||
}
|
||||
list_free(backend->wlr_device_lists);
|
||||
wlr_list_free(backend->wlr_device_lists);
|
||||
wl_event_source_remove(backend->input_event);
|
||||
libinput_unref(backend->libinput_context);
|
||||
free(backend);
|
||||
|
@ -148,7 +148,7 @@ struct wlr_backend *wlr_libinput_backend_create(struct wl_display *display,
|
|||
}
|
||||
wlr_backend_init(&backend->backend, &backend_impl);
|
||||
|
||||
if (!(backend->wlr_device_lists = list_create())) {
|
||||
if (!(backend->wlr_device_lists = wlr_list_create())) {
|
||||
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
|
||||
goto error_backend;
|
||||
}
|
||||
|
|
|
@ -3,19 +3,19 @@
|
|||
#include <libinput.h>
|
||||
#include <wlr/backend/session.h>
|
||||
#include <wlr/interfaces/wlr_input_device.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include <wayland-util.h>
|
||||
#include "backend/libinput.h"
|
||||
|
||||
struct wlr_input_device *get_appropriate_device(
|
||||
enum wlr_input_device_type desired_type,
|
||||
struct libinput_device *libinput_dev) {
|
||||
list_t *wlr_devices = libinput_device_get_user_data(libinput_dev);
|
||||
struct wl_list *wlr_devices = libinput_device_get_user_data(libinput_dev);
|
||||
if (!wlr_devices) {
|
||||
return NULL;
|
||||
}
|
||||
for (size_t i = 0; i < wlr_devices->length; ++i) {
|
||||
struct wlr_input_device *dev = wlr_devices->items[i];
|
||||
struct wlr_input_device *dev;
|
||||
wl_list_for_each(dev, wlr_devices, link) {
|
||||
if (dev->type == desired_type) {
|
||||
return dev;
|
||||
}
|
||||
|
@ -35,7 +35,7 @@ static struct wlr_input_device_impl input_device_impl = {
|
|||
|
||||
static struct wlr_input_device *allocate_device(
|
||||
struct wlr_libinput_backend *backend, struct libinput_device *libinput_dev,
|
||||
list_t *wlr_devices, enum wlr_input_device_type type) {
|
||||
struct wl_list *wlr_devices, enum wlr_input_device_type type) {
|
||||
int vendor = libinput_device_get_id_vendor(libinput_dev);
|
||||
int product = libinput_device_get_id_product(libinput_dev);
|
||||
const char *name = libinput_device_get_name(libinput_dev);
|
||||
|
@ -44,10 +44,7 @@ static struct wlr_input_device *allocate_device(
|
|||
return NULL;
|
||||
}
|
||||
struct wlr_input_device *wlr_dev = &wlr_libinput_dev->wlr_input_device;
|
||||
if (list_add(wlr_devices, wlr_dev) == -1) {
|
||||
free(wlr_libinput_dev);
|
||||
return NULL;
|
||||
}
|
||||
wl_list_insert(wlr_devices, &wlr_dev->link);
|
||||
wlr_libinput_dev->handle = libinput_dev;
|
||||
libinput_device_ref(libinput_dev);
|
||||
wlr_input_device_init(wlr_dev, type, &input_device_impl,
|
||||
|
@ -67,7 +64,8 @@ static void handle_device_added(struct wlr_libinput_backend *backend,
|
|||
int vendor = libinput_device_get_id_vendor(libinput_dev);
|
||||
int product = libinput_device_get_id_product(libinput_dev);
|
||||
const char *name = libinput_device_get_name(libinput_dev);
|
||||
list_t *wlr_devices = list_create();
|
||||
struct wl_list *wlr_devices = calloc(1, sizeof(struct wl_list));
|
||||
wl_list_init(wlr_devices);
|
||||
if (!wlr_devices) {
|
||||
goto fail;
|
||||
}
|
||||
|
@ -145,23 +143,26 @@ static void handle_device_added(struct wlr_libinput_backend *backend,
|
|||
// TODO
|
||||
}
|
||||
|
||||
if (wlr_devices->length > 0) {
|
||||
if (wl_list_length(wlr_devices) > 0) {
|
||||
libinput_device_set_user_data(libinput_dev, wlr_devices);
|
||||
list_add(backend->wlr_device_lists, wlr_devices);
|
||||
wlr_list_add(backend->wlr_device_lists, wlr_devices);
|
||||
} else {
|
||||
list_free(wlr_devices);
|
||||
free(wlr_devices);
|
||||
}
|
||||
return;
|
||||
|
||||
fail:
|
||||
wlr_log(L_ERROR, "Could not allocate new device");
|
||||
list_foreach(wlr_devices, free);
|
||||
list_free(wlr_devices);
|
||||
struct wlr_input_device *dev, *tmp_dev;
|
||||
wl_list_for_each_safe(dev, tmp_dev, wlr_devices, link) {
|
||||
free(dev);
|
||||
}
|
||||
free(wlr_devices);
|
||||
}
|
||||
|
||||
static void handle_device_removed(struct wlr_libinput_backend *backend,
|
||||
struct libinput_device *libinput_dev) {
|
||||
list_t *wlr_devices = libinput_device_get_user_data(libinput_dev);
|
||||
struct wl_list *wlr_devices = libinput_device_get_user_data(libinput_dev);
|
||||
int vendor = libinput_device_get_id_vendor(libinput_dev);
|
||||
int product = libinput_device_get_id_product(libinput_dev);
|
||||
const char *name = libinput_device_get_name(libinput_dev);
|
||||
|
@ -169,18 +170,18 @@ static void handle_device_removed(struct wlr_libinput_backend *backend,
|
|||
if (!wlr_devices) {
|
||||
return;
|
||||
}
|
||||
for (size_t i = 0; i < wlr_devices->length; i++) {
|
||||
struct wlr_input_device *wlr_dev = wlr_devices->items[i];
|
||||
wl_signal_emit(&backend->backend.events.input_remove, wlr_dev);
|
||||
wlr_input_device_destroy(wlr_dev);
|
||||
struct wlr_input_device *dev, *tmp_dev;
|
||||
wl_list_for_each_safe(dev, tmp_dev, wlr_devices, link) {
|
||||
wl_signal_emit(&backend->backend.events.input_remove, dev);
|
||||
wlr_input_device_destroy(dev);
|
||||
}
|
||||
for (size_t i = 0; i < backend->wlr_device_lists->length; i++) {
|
||||
if (backend->wlr_device_lists->items[i] == wlr_devices) {
|
||||
list_del(backend->wlr_device_lists, i);
|
||||
wlr_list_del(backend->wlr_device_lists, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
list_free(wlr_devices);
|
||||
free(wlr_devices);
|
||||
}
|
||||
|
||||
void wlr_libinput_event(struct wlr_libinput_backend *backend,
|
||||
|
|
|
@ -13,14 +13,15 @@ struct subbackend_state {
|
|||
struct wl_listener input_remove;
|
||||
struct wl_listener output_add;
|
||||
struct wl_listener output_remove;
|
||||
struct wl_list link;
|
||||
};
|
||||
|
||||
static bool multi_backend_start(struct wlr_backend *_backend) {
|
||||
struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
|
||||
for (size_t i = 0; i < backend->backends->length; ++i) {
|
||||
struct subbackend_state *sub = backend->backends->items[i];
|
||||
struct subbackend_state *sub;
|
||||
wl_list_for_each(sub, &backend->backends, link) {
|
||||
if (!wlr_backend_start(sub->backend)) {
|
||||
wlr_log(L_ERROR, "Failed to initialize backend %zd", i);
|
||||
wlr_log(L_ERROR, "Failed to initialize backend.");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
@ -29,20 +30,19 @@ static bool multi_backend_start(struct wlr_backend *_backend) {
|
|||
|
||||
static void multi_backend_destroy(struct wlr_backend *_backend) {
|
||||
struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
|
||||
for (size_t i = 0; i < backend->backends->length; ++i) {
|
||||
struct subbackend_state *sub = backend->backends->items[i];
|
||||
struct subbackend_state *sub;
|
||||
wl_list_for_each(sub, &backend->backends, link) {
|
||||
wlr_backend_destroy(sub->backend);
|
||||
free(sub);
|
||||
}
|
||||
list_free(backend->backends);
|
||||
wlr_session_destroy(backend->session);
|
||||
free(backend);
|
||||
}
|
||||
|
||||
static struct wlr_egl *multi_backend_get_egl(struct wlr_backend *_backend) {
|
||||
struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
|
||||
for (size_t i = 0; i < backend->backends->length; ++i) {
|
||||
struct subbackend_state *sub = backend->backends->items[i];
|
||||
struct subbackend_state *sub;
|
||||
wl_list_for_each(sub, &backend->backends, link) {
|
||||
struct wlr_egl *egl = wlr_backend_get_egl(sub->backend);
|
||||
if (egl) {
|
||||
return egl;
|
||||
|
@ -65,13 +65,7 @@ struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
backend->backends = list_create();
|
||||
if (!backend->backends) {
|
||||
free(backend);
|
||||
wlr_log(L_ERROR, "Backend allocation failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
wl_list_init(&backend->backends);
|
||||
wlr_backend_init(&backend->backend, &backend_impl);
|
||||
|
||||
backend->session = session;
|
||||
|
@ -116,11 +110,7 @@ void wlr_multi_backend_add(struct wlr_backend *_multi,
|
|||
wlr_log(L_ERROR, "Could not add backend: allocation failed");
|
||||
return;
|
||||
}
|
||||
if (list_add(multi->backends, sub) == -1) {
|
||||
wlr_log(L_ERROR, "Could not add backend: allocation failed");
|
||||
free(sub);
|
||||
return;
|
||||
}
|
||||
wl_list_insert(&multi->backends, &sub->link);
|
||||
|
||||
sub->backend = backend;
|
||||
sub->container = &multi->backend;
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
#include <EGL/egl.h>
|
||||
#include <EGL/eglext.h>
|
||||
#include <wayland-server.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/backend/interface.h>
|
||||
#include <wlr/interfaces/wlr_output.h>
|
||||
#include <wlr/interfaces/wlr_input_device.h>
|
||||
|
@ -64,16 +64,16 @@ static void wlr_wl_backend_destroy(struct wlr_backend *_backend) {
|
|||
return;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < backend->outputs->length; ++i) {
|
||||
wlr_output_destroy(backend->outputs->items[i]);
|
||||
struct wlr_wl_backend_output *output, *tmp_output;
|
||||
wl_list_for_each_safe(output, tmp_output, &backend->outputs, link) {
|
||||
wlr_output_destroy(&output->wlr_output);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < backend->devices->length; ++i) {
|
||||
wlr_input_device_destroy(backend->devices->items[i]);
|
||||
struct wlr_input_device *input_device, *tmp_input_device;
|
||||
wl_list_for_each_safe(input_device, tmp_input_device, &backend->devices, link) {
|
||||
wlr_input_device_destroy(input_device);
|
||||
}
|
||||
|
||||
list_free(backend->devices);
|
||||
list_free(backend->outputs);
|
||||
free(backend->seat_name);
|
||||
|
||||
wl_event_source_remove(backend->remote_display_src);
|
||||
|
@ -104,8 +104,8 @@ bool wlr_backend_is_wl(struct wlr_backend *b) {
|
|||
|
||||
struct wlr_wl_backend_output *wlr_wl_output_for_surface(
|
||||
struct wlr_wl_backend *backend, struct wl_surface *surface) {
|
||||
for (size_t i = 0; i < backend->outputs->length; ++i) {
|
||||
struct wlr_wl_backend_output *output = backend->outputs->items[i];
|
||||
struct wlr_wl_backend_output *output;
|
||||
wl_list_for_each(output, &backend->outputs, link) {
|
||||
if (output->surface == surface) {
|
||||
return output;
|
||||
}
|
||||
|
@ -123,15 +123,8 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
|
|||
}
|
||||
wlr_backend_init(&backend->backend, &backend_impl);
|
||||
|
||||
if (!(backend->devices = list_create())) {
|
||||
wlr_log(L_ERROR, "Could not allocate devices list");
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (!(backend->outputs = list_create())) {
|
||||
wlr_log(L_ERROR, "Could not allocate outputs list");
|
||||
goto error;
|
||||
}
|
||||
wl_list_init(&backend->devices);
|
||||
wl_list_init(&backend->outputs);
|
||||
|
||||
backend->local_display = display;
|
||||
|
||||
|
@ -150,12 +143,4 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
|
|||
wlr_egl_bind_display(&backend->egl, backend->local_display);
|
||||
|
||||
return &backend->backend;
|
||||
|
||||
error:
|
||||
if (backend) {
|
||||
list_free(backend->devices);
|
||||
list_free(backend->outputs);
|
||||
}
|
||||
free(backend);
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
@ -210,9 +210,7 @@ static void xdg_toplevel_handle_configure(void *data, struct zxdg_toplevel_v6 *x
|
|||
}
|
||||
// loop over states for maximized etc?
|
||||
wl_egl_window_resize(output->egl_window, width, height, 0, 0);
|
||||
output->wlr_output.width = width;
|
||||
output->wlr_output.height = height;
|
||||
wlr_output_update_matrix(&output->wlr_output);
|
||||
wlr_output_update_size(&output->wlr_output, width, height);
|
||||
wl_signal_emit(&output->wlr_output.events.resolution, output);
|
||||
}
|
||||
|
||||
|
@ -241,16 +239,14 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
|
|||
wlr_log(L_ERROR, "Failed to allocate wlr_wl_backend_output");
|
||||
return NULL;
|
||||
}
|
||||
wlr_output_init(&output->wlr_output, &output_impl);
|
||||
wlr_output_init(&output->wlr_output, &backend->backend, &output_impl);
|
||||
struct wlr_output *wlr_output = &output->wlr_output;
|
||||
|
||||
wlr_output->width = 640;
|
||||
wlr_output->height = 480;
|
||||
wlr_output_update_size(wlr_output, 640, 480);
|
||||
strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make));
|
||||
strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model));
|
||||
snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%zd",
|
||||
backend->outputs->length + 1);
|
||||
wlr_output_update_matrix(wlr_output);
|
||||
snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%d",
|
||||
wl_list_length(&backend->outputs) + 1);
|
||||
|
||||
output->backend = backend;
|
||||
|
||||
|
@ -306,10 +302,7 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
|
|||
goto error;
|
||||
}
|
||||
|
||||
if (list_add(backend->outputs, wlr_output) == -1) {
|
||||
wlr_log(L_ERROR, "Allocation failed");
|
||||
goto error;
|
||||
}
|
||||
wl_list_insert(&backend->outputs, &output->link);
|
||||
wlr_output_create_global(wlr_output, backend->local_display);
|
||||
wl_signal_emit(&backend->backend.events.output_add, wlr_output);
|
||||
return wlr_output;
|
||||
|
|
|
@ -204,11 +204,7 @@ static struct wlr_input_device *allocate_device(struct wlr_wl_backend *backend,
|
|||
struct wlr_input_device *wlr_device = &wlr_wl_dev->wlr_input_device;
|
||||
wlr_input_device_init(wlr_device, type, &input_device_impl,
|
||||
name, vendor, product);
|
||||
if (list_add(backend->devices, wlr_device) == -1) {
|
||||
wlr_log_errno(L_ERROR, "Allocation failed");
|
||||
free(wlr_wl_dev);
|
||||
return NULL;
|
||||
}
|
||||
wl_list_insert(&backend->devices, &wlr_device->link);
|
||||
return wlr_device;
|
||||
}
|
||||
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
#endif
|
||||
#include <wlr/backend/interface.h>
|
||||
#include <wlr/backend/x11.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/interfaces/wlr_output.h>
|
||||
#include <wlr/interfaces/wlr_input_device.h>
|
||||
#include <wlr/interfaces/wlr_keyboard.h>
|
||||
|
@ -121,9 +121,7 @@ static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *e
|
|||
case XCB_CONFIGURE_NOTIFY: {
|
||||
xcb_configure_notify_event_t *ev = (xcb_configure_notify_event_t *)event;
|
||||
|
||||
output->wlr_output.width = ev->width;
|
||||
output->wlr_output.height = ev->height;
|
||||
wlr_output_update_matrix(&output->wlr_output);
|
||||
wlr_output_update_size(&output->wlr_output, ev->width, ev->height);
|
||||
wl_signal_emit(&output->wlr_output.events.resolution, output);
|
||||
|
||||
// Move the pointer to its new location
|
||||
|
@ -264,7 +262,7 @@ static bool wlr_x11_backend_start(struct wlr_backend *backend) {
|
|||
|
||||
output->x11 = x11;
|
||||
|
||||
wlr_output_init(&output->wlr_output, &output_impl);
|
||||
wlr_output_init(&output->wlr_output, &x11->backend, &output_impl);
|
||||
snprintf(output->wlr_output.name, sizeof(output->wlr_output.name), "X11-1");
|
||||
|
||||
output->win = xcb_generate_id(x11->xcb_conn);
|
||||
|
|
|
@ -21,6 +21,7 @@
|
|||
#include <wlr/xcursor.h>
|
||||
#include <wlr/types/wlr_cursor.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include <wlr/types/wlr_list.h>
|
||||
#include "shared.h"
|
||||
#include "config.h"
|
||||
#include "cat.h"
|
||||
|
@ -45,7 +46,7 @@ struct sample_state {
|
|||
struct wl_listener touch_up;
|
||||
struct wl_listener touch_down;
|
||||
struct wl_listener touch_cancel;
|
||||
list_t *touch_points;
|
||||
struct wlr_list *touch_points;
|
||||
|
||||
struct wl_listener tablet_tool_axis;
|
||||
struct wl_listener tablet_tool_proxmity;
|
||||
|
@ -212,7 +213,7 @@ static void handle_touch_up(struct wl_listener *listener, void *data) {
|
|||
for (size_t i = 0; i < sample->touch_points->length; ++i) {
|
||||
struct touch_point *point = sample->touch_points->items[i];
|
||||
if (point->slot == event->slot) {
|
||||
list_del(sample->touch_points, i);
|
||||
wlr_list_del(sample->touch_points, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -227,7 +228,7 @@ static void handle_touch_down(struct wl_listener *listener, void *data) {
|
|||
point->slot = event->slot;
|
||||
point->x = event->x_mm / event->width_mm;
|
||||
point->y = event->y_mm / event->height_mm;
|
||||
if (list_add(sample->touch_points, point) == -1) {
|
||||
if (wlr_list_add(sample->touch_points, point) == -1) {
|
||||
free(point);
|
||||
}
|
||||
|
||||
|
@ -269,7 +270,7 @@ int main(int argc, char *argv[]) {
|
|||
struct sample_state state = {
|
||||
.default_color = { 0.25f, 0.25f, 0.25f, 1 },
|
||||
.clear_color = { 0.25f, 0.25f, 0.25f, 1 },
|
||||
.touch_points = list_create(),
|
||||
.touch_points = wlr_list_create(),
|
||||
};
|
||||
|
||||
state.config = parse_args(argc, argv);
|
||||
|
|
|
@ -267,10 +267,6 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
struct screenshooter_output *output;
|
||||
wl_list_for_each(output, &output_list, link) {
|
||||
if (output->width == 0 || output->height == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
output->buffer = create_shm_buffer(output->width, output->height, &output->data);
|
||||
if (output->buffer == NULL) {
|
||||
return -1;
|
||||
|
|
|
@ -413,8 +413,10 @@ static void output_add_notify(struct wl_listener *listener, void *data) {
|
|||
wlr_log(L_DEBUG, "Output '%s' added", output->name);
|
||||
wlr_log(L_DEBUG, "%s %s %"PRId32"mm x %"PRId32"mm", output->make, output->model,
|
||||
output->phys_width, output->phys_height);
|
||||
if (output->modes->length > 0) {
|
||||
wlr_output_set_mode(output, output->modes->items[0]);
|
||||
if (wl_list_length(&output->modes) > 0) {
|
||||
struct wlr_output_mode *mode;
|
||||
mode = wl_container_of((&output->modes)->prev, mode, link);
|
||||
wlr_output_set_mode(output, mode);
|
||||
}
|
||||
struct output_state *ostate = calloc(1, sizeof(struct output_state));
|
||||
clock_gettime(CLOCK_MONOTONIC, &ostate->last_frame);
|
||||
|
|
|
@ -16,7 +16,7 @@
|
|||
#include <wlr/render.h>
|
||||
#include <wlr/backend.h>
|
||||
#include <wlr/backend/session.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <wlr/types/wlr_list.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include "shared.h"
|
||||
#include "cat.h"
|
||||
|
@ -24,7 +24,7 @@
|
|||
struct sample_state {
|
||||
struct wlr_renderer *renderer;
|
||||
struct wlr_texture *cat_texture;
|
||||
list_t *touch_points;
|
||||
struct wlr_list *touch_points;
|
||||
};
|
||||
|
||||
struct touch_point {
|
||||
|
@ -65,7 +65,7 @@ static void handle_touch_down(struct touch_state *tstate, int32_t slot,
|
|||
point->slot = slot;
|
||||
point->x = x / width;
|
||||
point->y = y / height;
|
||||
if (list_add(sample->touch_points, point) == -1) {
|
||||
if (wlr_list_add(sample->touch_points, point) == -1) {
|
||||
free(point);
|
||||
}
|
||||
}
|
||||
|
@ -75,7 +75,7 @@ static void handle_touch_up(struct touch_state *tstate, int32_t slot) {
|
|||
for (size_t i = 0; i < sample->touch_points->length; ++i) {
|
||||
struct touch_point *point = sample->touch_points->items[i];
|
||||
if (point->slot == slot) {
|
||||
list_del(sample->touch_points, i);
|
||||
wlr_list_del(sample->touch_points, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -96,7 +96,7 @@ static void handle_touch_motion(struct touch_state *tstate, int32_t slot,
|
|||
|
||||
int main(int argc, char *argv[]) {
|
||||
struct sample_state state = {
|
||||
.touch_points = list_create()
|
||||
.touch_points = wlr_list_create()
|
||||
};
|
||||
struct compositor_state compositor = { 0,
|
||||
.data = &state,
|
||||
|
|
|
@ -8,12 +8,13 @@
|
|||
#include <xf86drmMode.h>
|
||||
#include <EGL/egl.h>
|
||||
#include <gbm.h>
|
||||
#include <wayland-util.h>
|
||||
|
||||
#include <wlr/backend/session.h>
|
||||
#include <wlr/backend/drm.h>
|
||||
#include <wlr/types/wlr_output.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/types/wlr_list.h>
|
||||
|
||||
#include "iface.h"
|
||||
#include "properties.h"
|
||||
|
@ -30,7 +31,6 @@ struct wlr_drm_plane {
|
|||
|
||||
// Only used by cursor
|
||||
float matrix[16];
|
||||
struct wlr_renderer *wlr_rend;
|
||||
struct wlr_texture *wlr_tex;
|
||||
struct gbm_bo *cursor_bo;
|
||||
|
||||
|
@ -93,7 +93,7 @@ struct wlr_drm_backend {
|
|||
struct wl_listener session_signal;
|
||||
struct wl_listener drm_invalidated;
|
||||
|
||||
list_t *outputs;
|
||||
struct wl_list outputs;
|
||||
|
||||
struct wlr_drm_renderer renderer;
|
||||
struct wlr_session *session;
|
||||
|
@ -113,7 +113,6 @@ struct wlr_drm_mode {
|
|||
|
||||
struct wlr_drm_connector {
|
||||
struct wlr_output output;
|
||||
struct wlr_drm_backend *drm;
|
||||
|
||||
enum wlr_drm_connector_state state;
|
||||
uint32_t id;
|
||||
|
@ -130,6 +129,7 @@ struct wlr_drm_connector {
|
|||
|
||||
bool pageflip_pending;
|
||||
struct wl_event_source *retry_pageflip;
|
||||
struct wl_list link;
|
||||
};
|
||||
|
||||
bool wlr_drm_check_features(struct wlr_drm_backend *drm);
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
#include <wlr/types/wlr_input_device.h>
|
||||
#include <wlr/backend/interface.h>
|
||||
#include <wlr/interfaces/wlr_input_device.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <wlr/types/wlr_list.h>
|
||||
|
||||
struct wlr_libinput_backend {
|
||||
struct wlr_backend backend;
|
||||
|
@ -18,7 +18,7 @@ struct wlr_libinput_backend {
|
|||
|
||||
struct wl_listener session_signal;
|
||||
|
||||
list_t *wlr_device_lists;
|
||||
struct wlr_list *wlr_device_lists;
|
||||
};
|
||||
|
||||
struct wlr_libinput_input_device {
|
||||
|
|
|
@ -3,14 +3,14 @@
|
|||
|
||||
#include <wlr/backend/interface.h>
|
||||
#include <wlr/backend/multi.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <wlr/backend/session.h>
|
||||
#include <wayland-util.h>
|
||||
|
||||
struct wlr_multi_backend {
|
||||
struct wlr_backend backend;
|
||||
|
||||
struct wlr_session *session;
|
||||
list_t *backends;
|
||||
struct wl_list backends;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
@ -5,11 +5,11 @@
|
|||
#include <wayland-client.h>
|
||||
#include <wayland-server.h>
|
||||
#include <wayland-egl.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/backend/wayland.h>
|
||||
#include <wlr/types/wlr_output.h>
|
||||
#include <wlr/types/wlr_input_device.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <wayland-util.h>
|
||||
|
||||
struct wlr_wl_backend {
|
||||
struct wlr_backend backend;
|
||||
|
@ -17,8 +17,8 @@ struct wlr_wl_backend {
|
|||
/* local state */
|
||||
bool started;
|
||||
struct wl_display *local_display;
|
||||
list_t *devices;
|
||||
list_t *outputs;
|
||||
struct wl_list devices;
|
||||
struct wl_list outputs;
|
||||
struct wlr_egl egl;
|
||||
size_t requested_outputs;
|
||||
/* remote state */
|
||||
|
@ -51,6 +51,7 @@ struct wlr_wl_backend_output {
|
|||
uint32_t enter_serial;
|
||||
|
||||
void *egl_surface;
|
||||
struct wl_list link;
|
||||
};
|
||||
|
||||
struct wlr_wl_input_device {
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
#include <xcb/xcb.h>
|
||||
#include <X11/Xlib-xcb.h>
|
||||
#include <wayland-server.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/types/wlr_output.h>
|
||||
#include <wlr/types/wlr_input_device.h>
|
||||
|
||||
|
|
|
@ -8,9 +8,9 @@
|
|||
#include <GLES2/gl2ext.h>
|
||||
#include <EGL/egl.h>
|
||||
#include <EGL/eglext.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/backend.h>
|
||||
#include <wlr/render.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/render/interface.h>
|
||||
#include <wlr/util/log.h>
|
||||
|
||||
|
|
|
@ -9,7 +9,7 @@
|
|||
#include <wlr/types/wlr_xdg_shell_v6.h>
|
||||
#include <wlr/types/wlr_gamma_control.h>
|
||||
#include <wlr/types/wlr_screenshooter.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <wlr/types/wlr_list.h>
|
||||
#include "rootston/view.h"
|
||||
#include "rootston/config.h"
|
||||
|
||||
|
@ -22,7 +22,7 @@ struct roots_output {
|
|||
};
|
||||
|
||||
struct roots_desktop {
|
||||
list_t *views;
|
||||
struct wlr_list *views;
|
||||
|
||||
struct wl_list outputs;
|
||||
struct timespec last_frame;
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
|
||||
#include <wayland-server.h>
|
||||
#include <wlr/backend/session.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/render/egl.h>
|
||||
|
||||
struct wlr_backend_impl;
|
||||
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
|
||||
#include <stdbool.h>
|
||||
#include <wlr/backend.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/render/egl.h>
|
||||
|
||||
struct wlr_backend_impl {
|
||||
bool (*start)(struct wlr_backend *backend);
|
||||
|
|
|
@ -1,8 +1,9 @@
|
|||
#ifndef WLR_INTERFACES_WLR_OUTPUT_H
|
||||
#define WLR_INTERFACES_WLR_OUTPUT_H
|
||||
|
||||
#include <wlr/types/wlr_output.h>
|
||||
#include <stdbool.h>
|
||||
#include <wlr/types/wlr_output.h>
|
||||
#include <wlr/backend.h>
|
||||
|
||||
struct wlr_output_impl {
|
||||
void (*enable)(struct wlr_output *output, bool enable);
|
||||
|
@ -17,14 +18,17 @@ struct wlr_output_impl {
|
|||
void (*make_current)(struct wlr_output *output);
|
||||
void (*swap_buffers)(struct wlr_output *output);
|
||||
void (*set_gamma)(struct wlr_output *output,
|
||||
uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b);
|
||||
uint16_t (*get_gamma_size)(struct wlr_output *output);
|
||||
uint32_t size, uint16_t *r, uint16_t *g, uint16_t *b);
|
||||
uint32_t (*get_gamma_size)(struct wlr_output *output);
|
||||
};
|
||||
|
||||
void wlr_output_init(struct wlr_output *output, const struct wlr_output_impl *impl);
|
||||
void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend,
|
||||
const struct wlr_output_impl *impl);
|
||||
void wlr_output_free(struct wlr_output *output);
|
||||
void wlr_output_update_matrix(struct wlr_output *output);
|
||||
struct wl_global *wlr_output_create_global(
|
||||
struct wlr_output *wlr_output, struct wl_display *display);
|
||||
void wlr_output_update_size(struct wlr_output *output, int32_t width,
|
||||
int32_t height);
|
||||
struct wl_global *wlr_output_create_global(struct wlr_output *wlr_output,
|
||||
struct wl_display *display);
|
||||
void wlr_output_destroy_global(struct wlr_output *wlr_output);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -5,18 +5,28 @@
|
|||
|
||||
struct wlr_gamma_control_manager {
|
||||
struct wl_global *wl_global;
|
||||
struct wl_list controls; // list of wlr_gamma_control
|
||||
|
||||
void *data;
|
||||
};
|
||||
|
||||
struct wlr_gamma_control {
|
||||
struct wl_resource *resource;
|
||||
struct wl_resource *output;
|
||||
struct wlr_output *output;
|
||||
struct wl_list link;
|
||||
|
||||
struct wl_listener output_destroy_listener;
|
||||
|
||||
struct {
|
||||
struct wl_signal destroy;
|
||||
} events;
|
||||
|
||||
void* data;
|
||||
};
|
||||
|
||||
struct wlr_gamma_control_manager *wlr_gamma_control_manager_create(struct wl_display *display);
|
||||
void wlr_gamma_control_manager_destroy(struct wlr_gamma_control_manager *gamma_control_manager);
|
||||
struct wlr_gamma_control_manager *wlr_gamma_control_manager_create(
|
||||
struct wl_display *display);
|
||||
void wlr_gamma_control_manager_destroy(
|
||||
struct wlr_gamma_control_manager *gamma_control_manager);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -45,6 +45,8 @@ struct wlr_input_device {
|
|||
} events;
|
||||
|
||||
void *data;
|
||||
|
||||
struct wl_list link;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
@ -3,57 +3,57 @@
|
|||
|
||||
#include <stddef.h>
|
||||
|
||||
typedef struct {
|
||||
struct wlr_list {
|
||||
size_t capacity;
|
||||
size_t length;
|
||||
void **items;
|
||||
} list_t;
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a new list, may return `NULL` on failure
|
||||
*/
|
||||
list_t *list_create(void);
|
||||
void list_free(list_t *list);
|
||||
void list_foreach(list_t *list, void (*callback)(void *item));
|
||||
struct wlr_list *wlr_list_create(void);
|
||||
void wlr_list_free(struct wlr_list *list);
|
||||
void wlr_list_foreach(struct wlr_list *list, void (*callback)(void *item));
|
||||
/**
|
||||
* Add `item` to the end of a list.
|
||||
* Returns: new list length or `-1` on failure
|
||||
*/
|
||||
int list_add(list_t *list, void *item);
|
||||
int wlr_list_add(struct wlr_list *list, void *item);
|
||||
/**
|
||||
* Add `item` to the end of a list.
|
||||
* Returns: new list length or `-1` on failure
|
||||
*/
|
||||
int list_push(list_t *list, void *item);
|
||||
int wlr_list_push(struct wlr_list *list, void *item);
|
||||
/**
|
||||
* Place `item` into index `index` in the list
|
||||
* Returns: new list length or `-1` on failure
|
||||
*/
|
||||
int list_insert(list_t *list, size_t index, void *item);
|
||||
int wlr_list_insert(struct wlr_list *list, size_t index, void *item);
|
||||
/**
|
||||
* Remove an item from the list
|
||||
*/
|
||||
void list_del(list_t *list, size_t index);
|
||||
void wlr_list_del(struct wlr_list *list, size_t index);
|
||||
/**
|
||||
* Remove and return an item from the end of the list
|
||||
*/
|
||||
void *list_pop(list_t *list);
|
||||
void *wlr_list_pop(struct wlr_list *list);
|
||||
/**
|
||||
* Get a reference to the last item of a list without removal
|
||||
*/
|
||||
void *list_peek(list_t *list);
|
||||
void *wlr_list_peek(struct wlr_list *list);
|
||||
/**
|
||||
* Append each item in `source` to `list`
|
||||
* Does not modify `source`
|
||||
* Returns: new list length or `-1` on failure
|
||||
*/
|
||||
int list_cat(list_t *list, list_t *source);
|
||||
int wlr_list_cat(struct wlr_list *list, struct wlr_list *source);
|
||||
// See qsort. Remember to use *_qsort functions as compare functions,
|
||||
// because they dereference the left and right arguments first!
|
||||
void list_qsort(list_t *list, int compare(const void *left, const void *right));
|
||||
void wlr_list_qsort(struct wlr_list *list, int compare(const void *left, const void *right));
|
||||
// Return index for first item in list that returns 0 for given compare
|
||||
// function or -1 if none matches.
|
||||
int list_seq_find(list_t *list,
|
||||
int wlr_list_seq_find(struct wlr_list *list,
|
||||
int compare(const void *item, const void *cmp_to),
|
||||
const void *cmp_to);
|
||||
|
|
@ -1,20 +1,22 @@
|
|||
#ifndef WLR_TYPES_WLR_OUTPUT_H
|
||||
#define WLR_TYPES_WLR_OUTPUT_H
|
||||
|
||||
#include <wayland-util.h>
|
||||
#include <wayland-server.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
struct wlr_output_mode {
|
||||
uint32_t flags; // enum wl_output_mode
|
||||
int32_t width, height;
|
||||
int32_t refresh; // mHz
|
||||
struct wl_list link;
|
||||
};
|
||||
|
||||
struct wlr_output_impl;
|
||||
|
||||
struct wlr_output {
|
||||
const struct wlr_output_impl *impl;
|
||||
struct wlr_backend *backend;
|
||||
|
||||
struct wl_global *wl_global;
|
||||
struct wl_list wl_resources;
|
||||
|
@ -32,7 +34,7 @@ struct wlr_output {
|
|||
float transform_matrix[16];
|
||||
|
||||
/* Note: some backends may have zero modes */
|
||||
list_t *modes;
|
||||
struct wl_list modes;
|
||||
struct wlr_output_mode *current_mode;
|
||||
|
||||
struct {
|
||||
|
@ -82,7 +84,7 @@ void wlr_output_effective_resolution(struct wlr_output *output,
|
|||
void wlr_output_make_current(struct wlr_output *output);
|
||||
void wlr_output_swap_buffers(struct wlr_output *output);
|
||||
void wlr_output_set_gamma(struct wlr_output *output,
|
||||
uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b);
|
||||
uint16_t wlr_output_get_gamma_size(struct wlr_output *output);
|
||||
uint32_t size, uint16_t *r, uint16_t *g, uint16_t *b);
|
||||
uint32_t wlr_output_get_gamma_size(struct wlr_output *output);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -109,6 +109,14 @@ void wlr_surface_get_matrix(struct wlr_surface *surface,
|
|||
int wlr_surface_set_role(struct wlr_surface *surface, const char *role,
|
||||
struct wl_resource *error_resource, uint32_t error_code);
|
||||
|
||||
/**
|
||||
* Whether or not this surface currently has an attached buffer. A surface has
|
||||
* an attached buffer when it commits with a non-null buffer in its pending
|
||||
* state. A surface will not have a buffer if it has never committed one, has
|
||||
* committed a null buffer, or something went wrong with uploading the buffer.
|
||||
*/
|
||||
bool wlr_surface_has_buffer(struct wlr_surface *surface);
|
||||
|
||||
/**
|
||||
* Create the subsurface implementation for this surface.
|
||||
*/
|
||||
|
|
|
@ -5,6 +5,7 @@
|
|||
#include <stdbool.h>
|
||||
#include <wlr/types/wlr_compositor.h>
|
||||
#include <xcb/xcb.h>
|
||||
#include <wlr/types/wlr_list.h>
|
||||
|
||||
#ifdef HAS_XCB_ICCCM
|
||||
#include <xcb/xcb_icccm.h>
|
||||
|
@ -78,7 +79,7 @@ struct wlr_xwayland_surface {
|
|||
char *class;
|
||||
char *instance;
|
||||
struct wlr_xwayland_surface *parent;
|
||||
list_t *state; // list of xcb_atom_t
|
||||
struct wlr_list *state; // list of xcb_atom_t
|
||||
pid_t pid;
|
||||
|
||||
xcb_atom_t *window_type;
|
||||
|
|
|
@ -44,8 +44,8 @@ wayland_protos = dependency('wayland-protocols')
|
|||
egl = dependency('egl')
|
||||
glesv2 = dependency('glesv2')
|
||||
drm = dependency('libdrm')
|
||||
gbm = dependency('gbm')
|
||||
libinput = dependency('libinput')
|
||||
gbm = dependency('gbm', version: '>=17.1.0')
|
||||
libinput = dependency('libinput', version: '>=1.7.0')
|
||||
xkbcommon = dependency('xkbcommon')
|
||||
udev = dependency('libudev')
|
||||
pixman = dependency('pixman-1')
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
#include <GLES2/gl2.h>
|
||||
#include <stdlib.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include "render/glapi.h"
|
||||
|
||||
// Extension documentation
|
||||
|
|
|
@ -5,9 +5,9 @@
|
|||
#include <GLES2/gl2ext.h>
|
||||
#include <wayland-util.h>
|
||||
#include <wayland-server-protocol.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/backend.h>
|
||||
#include <wlr/render.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/render/interface.h>
|
||||
#include <wlr/render/matrix.h>
|
||||
#include <wlr/util/log.h>
|
||||
|
@ -246,9 +246,8 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_backend *backend) {
|
|||
return NULL;
|
||||
}
|
||||
wlr_renderer_init(&renderer->wlr_renderer, &wlr_renderer_impl);
|
||||
if (backend) {
|
||||
struct wlr_egl *egl = wlr_backend_get_egl(backend);
|
||||
renderer->egl = egl;
|
||||
}
|
||||
|
||||
renderer->egl = wlr_backend_get_egl(backend);
|
||||
|
||||
return &renderer->wlr_renderer;
|
||||
}
|
||||
|
|
|
@ -5,8 +5,8 @@
|
|||
#include <GLES2/gl2ext.h>
|
||||
#include <wayland-util.h>
|
||||
#include <wayland-server-protocol.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/render.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/render/interface.h>
|
||||
#include <wlr/render/matrix.h>
|
||||
#include <wlr/util/log.h>
|
||||
|
|
|
@ -306,7 +306,7 @@ struct roots_config *parse_args(int argc, char *argv[]) {
|
|||
if (result == -1) {
|
||||
wlr_log(L_DEBUG, "No config file found. Using sensible defaults.");
|
||||
config->keyboard.meta_key = WLR_MODIFIER_LOGO;
|
||||
add_binding_config(&config->bindings, "Logo+Shift+e", "exit");
|
||||
add_binding_config(&config->bindings, "Logo+Shift+E", "exit");
|
||||
add_binding_config(&config->bindings, "Ctrl+q", "close");
|
||||
add_binding_config(&config->bindings, "Alt+Tab", "next_window");
|
||||
} else if (result == -2) {
|
||||
|
|
|
@ -185,8 +185,8 @@ void set_view_focus(struct roots_input *input, struct roots_desktop *desktop,
|
|||
}
|
||||
view_activate(view, true);
|
||||
// TODO: list_swap
|
||||
list_del(desktop->views, index);
|
||||
list_add(desktop->views, view);
|
||||
wlr_list_del(desktop->views, index);
|
||||
wlr_list_add(desktop->views, view);
|
||||
}
|
||||
|
||||
static void handle_cursor_motion(struct wl_listener *listener, void *data) {
|
||||
|
|
|
@ -29,7 +29,7 @@ void view_destroy(struct roots_view *view) {
|
|||
for (size_t i = 0; i < desktop->views->length; ++i) {
|
||||
struct roots_view *_view = desktop->views->items[i];
|
||||
if (view == _view) {
|
||||
list_del(desktop->views, i);
|
||||
wlr_list_del(desktop->views, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -209,7 +209,7 @@ struct roots_desktop *desktop_create(struct roots_server *server,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
desktop->views = list_create();
|
||||
desktop->views = wlr_list_create();
|
||||
if (desktop->views == NULL) {
|
||||
free(desktop);
|
||||
return NULL;
|
||||
|
|
|
@ -175,9 +175,11 @@ void output_add_notify(struct wl_listener *listener, void *data) {
|
|||
wlr_log(L_DEBUG, "%s %s %"PRId32"mm x %"PRId32"mm",
|
||||
wlr_output->make, wlr_output->model,
|
||||
wlr_output->phys_width, wlr_output->phys_height);
|
||||
if (wlr_output->modes->length > 0) {
|
||||
wlr_output_set_mode(wlr_output, wlr_output->modes->items[0]);
|
||||
}
|
||||
if (wl_list_length(&wlr_output->modes) > 0) {
|
||||
struct wlr_output_mode *mode = NULL;
|
||||
mode = wl_container_of((&wlr_output->modes)->prev, mode, link);
|
||||
wlr_output_set_mode(wlr_output, mode);
|
||||
}
|
||||
|
||||
struct roots_output *output = calloc(1, sizeof(struct roots_output));
|
||||
clock_gettime(CLOCK_MONOTONIC, &output->last_frame);
|
||||
|
|
|
@ -40,6 +40,6 @@ meta-key = Logo
|
|||
# - "close" to close the current view
|
||||
# - "next_window" to cycle through windows
|
||||
[bindings]
|
||||
Logo+Shift+e = exit
|
||||
Logo+Shift+E = exit
|
||||
Logo+q = close
|
||||
Alt+Tab = next_window
|
||||
|
|
|
@ -110,12 +110,12 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
|
|||
view->close = close;
|
||||
view->desktop = desktop;
|
||||
roots_surface->view = view;
|
||||
list_add(desktop->views, view);
|
||||
wlr_list_add(desktop->views, view);
|
||||
view_initialize(view);
|
||||
|
||||
if (surface->state == WLR_WL_SHELL_SURFACE_STATE_TRANSIENT) {
|
||||
// we need to map it relative to the parent
|
||||
int i = list_seq_find(desktop->views, shell_surface_compare_equals,
|
||||
int i = wlr_list_seq_find(desktop->views, shell_surface_compare_equals,
|
||||
surface->parent);
|
||||
if (i != -1) {
|
||||
struct roots_view *parent = desktop->views->items[i];
|
||||
|
|
|
@ -124,7 +124,7 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
|
|||
view->close = close;
|
||||
view->desktop = desktop;
|
||||
roots_surface->view = view;
|
||||
list_add(desktop->views, view);
|
||||
wlr_list_add(desktop->views, view);
|
||||
|
||||
view_initialize(view);
|
||||
}
|
||||
|
|
|
@ -98,7 +98,7 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
|
|||
view->set_position = set_position;
|
||||
view->close = close;
|
||||
roots_surface->view = view;
|
||||
list_add(desktop->views, view);
|
||||
wlr_list_add(desktop->views, view);
|
||||
|
||||
if (!surface->override_redirect) {
|
||||
view_initialize(view);
|
||||
|
|
|
@ -2,13 +2,18 @@ lib_wlr_types = static_library(
|
|||
'wlr_types',
|
||||
files(
|
||||
'wlr_data_device.c',
|
||||
'wlr_box.c',
|
||||
'wlr_compositor.c',
|
||||
'wlr_cursor.c',
|
||||
'wlr_gamma_control.c',
|
||||
'wlr_input_device.c',
|
||||
'wlr_keyboard.c',
|
||||
'wlr_list.c',
|
||||
'wlr_output.c',
|
||||
'wlr_output_layout.c',
|
||||
'wlr_pointer.c',
|
||||
'wlr_cursor.c',
|
||||
'wlr_region.c',
|
||||
'wlr_screenshooter.c',
|
||||
'wlr_seat.c',
|
||||
'wlr_surface.c',
|
||||
'wlr_tablet_pad.c',
|
||||
|
@ -16,10 +21,6 @@ lib_wlr_types = static_library(
|
|||
'wlr_touch.c',
|
||||
'wlr_xdg_shell_v6.c',
|
||||
'wlr_wl_shell.c',
|
||||
'wlr_compositor.c',
|
||||
'wlr_box.c',
|
||||
'wlr_gamma_control.c',
|
||||
'wlr_screenshooter.c',
|
||||
),
|
||||
include_directories: wlr_inc,
|
||||
dependencies: [wayland_server, pixman, wlr_protos],
|
||||
|
|
|
@ -53,12 +53,7 @@ static void wl_compositor_bind(struct wl_client *wl_client, void *_compositor,
|
|||
uint32_t version, uint32_t id) {
|
||||
struct wlr_compositor *compositor = _compositor;
|
||||
assert(wl_client && compositor);
|
||||
if (version > 4) {
|
||||
wlr_log(L_ERROR, "Client requested unsupported wl_compositor version, "
|
||||
"disconnecting");
|
||||
wl_client_destroy(wl_client);
|
||||
return;
|
||||
}
|
||||
|
||||
struct wl_resource *wl_resource =
|
||||
wl_resource_create(wl_client, &wl_compositor_interface, version, id);
|
||||
wl_resource_set_implementation(wl_resource, &wl_compositor_impl,
|
||||
|
|
|
@ -6,100 +6,155 @@
|
|||
#include <wlr/util/log.h>
|
||||
#include "gamma-control-protocol.h"
|
||||
|
||||
static void resource_destroy(struct wl_client *client, struct wl_resource *resource) {
|
||||
static void resource_destroy(struct wl_client *client,
|
||||
struct wl_resource *resource) {
|
||||
wl_resource_destroy(resource);
|
||||
}
|
||||
|
||||
static void gamma_control_destroy(struct wl_resource *resource) {
|
||||
struct wlr_gamma_control *gamma_control = wl_resource_get_user_data(resource);
|
||||
static void gamma_control_destroy(struct wlr_gamma_control *gamma_control) {
|
||||
wl_signal_emit(&gamma_control->events.destroy, gamma_control);
|
||||
wl_list_remove(&gamma_control->output_destroy_listener.link);
|
||||
wl_resource_set_user_data(gamma_control->resource, NULL);
|
||||
free(gamma_control);
|
||||
}
|
||||
|
||||
static void gamma_control_destroy_resource(struct wl_resource *resource) {
|
||||
struct wlr_gamma_control *gamma_control =
|
||||
wl_resource_get_user_data(resource);
|
||||
gamma_control_destroy(gamma_control);
|
||||
}
|
||||
|
||||
static void gamma_control_handle_output_destroy(struct wl_listener *listener,
|
||||
void *data) {
|
||||
struct wlr_gamma_control *gamma_control =
|
||||
wl_container_of(listener, gamma_control, output_destroy_listener);
|
||||
gamma_control_destroy(gamma_control);
|
||||
}
|
||||
|
||||
static void gamma_control_set_gamma(struct wl_client *client,
|
||||
struct wl_resource *_gamma_control, struct wl_array *red,
|
||||
struct wl_resource *gamma_control_resource, struct wl_array *red,
|
||||
struct wl_array *green, struct wl_array *blue) {
|
||||
struct wlr_gamma_control *gamma_control =
|
||||
wl_resource_get_user_data(gamma_control_resource);
|
||||
|
||||
if (red->size != green->size || red->size != blue->size) {
|
||||
wl_resource_post_error(_gamma_control, GAMMA_CONTROL_ERROR_INVALID_GAMMA,
|
||||
wl_resource_post_error(gamma_control_resource,
|
||||
GAMMA_CONTROL_ERROR_INVALID_GAMMA,
|
||||
"The gamma ramps don't have the same size");
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t size = red->size / sizeof(uint16_t);
|
||||
uint16_t *r = (uint16_t *)red->data;
|
||||
uint16_t *g = (uint16_t *)green->data;
|
||||
uint16_t *b = (uint16_t *)blue->data;
|
||||
struct wlr_gamma_control *gamma_control = wl_resource_get_user_data(_gamma_control);
|
||||
struct wlr_output *output = wl_resource_get_user_data(gamma_control->output);
|
||||
wlr_output_set_gamma(output, red->size / sizeof(uint16_t), r, g, b);
|
||||
|
||||
wlr_output_set_gamma(gamma_control->output, size, r, g, b);
|
||||
}
|
||||
|
||||
static void gamma_control_reset_gamma(struct wl_client *client,
|
||||
struct wl_resource *_gamma_control) {
|
||||
struct wl_resource *gamma_control_resource) {
|
||||
// TODO
|
||||
}
|
||||
|
||||
static const struct gamma_control_interface gamma_control_implementation = {
|
||||
static const struct gamma_control_interface gamma_control_impl = {
|
||||
.destroy = resource_destroy,
|
||||
.set_gamma = gamma_control_set_gamma,
|
||||
.reset_gamma = gamma_control_reset_gamma,
|
||||
};
|
||||
|
||||
static void gamma_control_manager_get_gamma_control(struct wl_client *client,
|
||||
struct wl_resource *_gamma_control_manager, uint32_t id,
|
||||
struct wl_resource *_output) {
|
||||
//struct wlr_gamma_control_manager *gamma_control_manager =
|
||||
// wl_resource_get_user_data(_gamma_control_manager);
|
||||
struct wlr_output *output = wl_resource_get_user_data(_output);
|
||||
struct wlr_gamma_control *gamma_control;
|
||||
if (!(gamma_control = calloc(1, sizeof(struct wlr_gamma_control)))) {
|
||||
struct wl_resource *gamma_control_manager_resource, uint32_t id,
|
||||
struct wl_resource *output_resource) {
|
||||
struct wlr_gamma_control_manager *gamma_control_manager =
|
||||
wl_resource_get_user_data(gamma_control_manager_resource);
|
||||
struct wlr_output *output = wl_resource_get_user_data(output_resource);
|
||||
|
||||
struct wlr_gamma_control *gamma_control =
|
||||
calloc(1, sizeof(struct wlr_gamma_control));
|
||||
if (gamma_control == NULL) {
|
||||
wl_client_post_no_memory(client);
|
||||
return;
|
||||
}
|
||||
gamma_control->output = _output;
|
||||
gamma_control->output = output;
|
||||
|
||||
int version = wl_resource_get_version(gamma_control_manager_resource);
|
||||
gamma_control->resource = wl_resource_create(client,
|
||||
&gamma_control_interface, wl_resource_get_version(_gamma_control_manager), id);
|
||||
wlr_log(L_DEBUG, "new gamma_control %p (res %p)", gamma_control, gamma_control->resource);
|
||||
&gamma_control_interface, version, id);
|
||||
if (gamma_control->resource == NULL) {
|
||||
wl_client_post_no_memory(client);
|
||||
free(gamma_control);
|
||||
return;
|
||||
}
|
||||
wlr_log(L_DEBUG, "new gamma_control %p (res %p)", gamma_control,
|
||||
gamma_control->resource);
|
||||
wl_resource_set_implementation(gamma_control->resource,
|
||||
&gamma_control_implementation, gamma_control, gamma_control_destroy);
|
||||
gamma_control_send_gamma_size(gamma_control->resource, wlr_output_get_gamma_size(output));
|
||||
&gamma_control_impl, gamma_control, gamma_control_destroy_resource);
|
||||
|
||||
wl_signal_init(&gamma_control->events.destroy);
|
||||
|
||||
wl_signal_add(&output->events.destroy,
|
||||
&gamma_control->output_destroy_listener);
|
||||
gamma_control->output_destroy_listener.notify =
|
||||
gamma_control_handle_output_destroy;
|
||||
|
||||
wl_list_insert(&gamma_control_manager->controls, &gamma_control->link);
|
||||
|
||||
gamma_control_send_gamma_size(gamma_control->resource,
|
||||
wlr_output_get_gamma_size(output));
|
||||
}
|
||||
|
||||
static struct gamma_control_manager_interface gamma_control_manager_impl = {
|
||||
.get_gamma_control = gamma_control_manager_get_gamma_control,
|
||||
};
|
||||
|
||||
static void gamma_control_manager_bind(struct wl_client *wl_client,
|
||||
static void gamma_control_manager_bind(struct wl_client *client,
|
||||
void *_gamma_control_manager, uint32_t version, uint32_t id) {
|
||||
struct wlr_gamma_control_manager *gamma_control_manager = _gamma_control_manager;
|
||||
assert(wl_client && gamma_control_manager);
|
||||
if (version > 1) {
|
||||
wlr_log(L_ERROR, "Client requested unsupported gamma_control version, disconnecting");
|
||||
wl_client_destroy(wl_client);
|
||||
struct wlr_gamma_control_manager *gamma_control_manager =
|
||||
_gamma_control_manager;
|
||||
assert(client && gamma_control_manager);
|
||||
|
||||
struct wl_resource *resource = wl_resource_create(client,
|
||||
&gamma_control_manager_interface, version, id);
|
||||
if (resource == NULL) {
|
||||
wl_client_post_no_memory(client);
|
||||
return;
|
||||
}
|
||||
struct wl_resource *wl_resource = wl_resource_create(
|
||||
wl_client, &gamma_control_manager_interface, version, id);
|
||||
wl_resource_set_implementation(wl_resource, &gamma_control_manager_impl,
|
||||
wl_resource_set_implementation(resource, &gamma_control_manager_impl,
|
||||
gamma_control_manager, NULL);
|
||||
}
|
||||
|
||||
struct wlr_gamma_control_manager *wlr_gamma_control_manager_create(struct wl_display *display) {
|
||||
struct wlr_gamma_control_manager *wlr_gamma_control_manager_create(
|
||||
struct wl_display *display) {
|
||||
struct wlr_gamma_control_manager *gamma_control_manager =
|
||||
calloc(1, sizeof(struct wlr_gamma_control_manager));
|
||||
if (!gamma_control_manager) {
|
||||
return NULL;
|
||||
}
|
||||
struct wl_global *wl_global = wl_global_create(display,
|
||||
&gamma_control_manager_interface, 1, gamma_control_manager, gamma_control_manager_bind);
|
||||
&gamma_control_manager_interface, 1, gamma_control_manager,
|
||||
gamma_control_manager_bind);
|
||||
if (!wl_global) {
|
||||
free(gamma_control_manager);
|
||||
return NULL;
|
||||
}
|
||||
gamma_control_manager->wl_global = wl_global;
|
||||
|
||||
wl_list_init(&gamma_control_manager->controls);
|
||||
|
||||
return gamma_control_manager;
|
||||
}
|
||||
|
||||
void wlr_gamma_control_manager_destroy(struct wlr_gamma_control_manager *gamma_control_manager) {
|
||||
void wlr_gamma_control_manager_destroy(
|
||||
struct wlr_gamma_control_manager *gamma_control_manager) {
|
||||
if (!gamma_control_manager) {
|
||||
return;
|
||||
}
|
||||
struct wlr_gamma_control *gamma_control, *tmp;
|
||||
wl_list_for_each_safe(gamma_control, tmp, &gamma_control_manager->controls,
|
||||
link) {
|
||||
gamma_control_destroy(gamma_control);
|
||||
}
|
||||
// TODO: this segfault (wl_display->registry_resource_list is not init)
|
||||
// wl_global_destroy(gamma_control_manager->wl_global);
|
||||
free(gamma_control_manager);
|
||||
|
|
|
@ -3,10 +3,10 @@
|
|||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
#include <stddef.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <wlr/types/wlr_list.h>
|
||||
|
||||
list_t *list_create(void) {
|
||||
list_t *list = malloc(sizeof(list_t));
|
||||
struct wlr_list *wlr_list_create(void) {
|
||||
struct wlr_list *list = malloc(sizeof(struct wlr_list));
|
||||
if (!list) {
|
||||
return NULL;
|
||||
}
|
||||
|
@ -20,7 +20,7 @@ list_t *list_create(void) {
|
|||
return list;
|
||||
}
|
||||
|
||||
static bool list_resize(list_t *list) {
|
||||
static bool list_resize(struct wlr_list *list) {
|
||||
if (list->length == list->capacity) {
|
||||
void *new_items = realloc(list->items, sizeof(void*) * (list->capacity + 10));
|
||||
if (!new_items) {
|
||||
|
@ -32,7 +32,7 @@ static bool list_resize(list_t *list) {
|
|||
return true;
|
||||
}
|
||||
|
||||
void list_free(list_t *list) {
|
||||
void wlr_list_free(struct wlr_list *list) {
|
||||
if (list == NULL) {
|
||||
return;
|
||||
}
|
||||
|
@ -40,7 +40,7 @@ void list_free(list_t *list) {
|
|||
free(list);
|
||||
}
|
||||
|
||||
void list_foreach(list_t *list, void (*callback)(void *item)) {
|
||||
void wlr_list_foreach(struct wlr_list *list, void (*callback)(void *item)) {
|
||||
if (list == NULL || callback == NULL) {
|
||||
return;
|
||||
}
|
||||
|
@ -49,7 +49,7 @@ void list_foreach(list_t *list, void (*callback)(void *item)) {
|
|||
}
|
||||
}
|
||||
|
||||
int list_add(list_t *list, void *item) {
|
||||
int wlr_list_add(struct wlr_list *list, void *item) {
|
||||
if (!list_resize(list)) {
|
||||
return -1;
|
||||
}
|
||||
|
@ -57,11 +57,11 @@ int list_add(list_t *list, void *item) {
|
|||
return list->length;
|
||||
}
|
||||
|
||||
int list_push(list_t *list, void *item) {
|
||||
return list_add(list, item);
|
||||
int wlr_list_push(struct wlr_list *list, void *item) {
|
||||
return wlr_list_add(list, item);
|
||||
}
|
||||
|
||||
int list_insert(list_t *list, size_t index, void *item) {
|
||||
int wlr_list_insert(struct wlr_list *list, size_t index, void *item) {
|
||||
if (!list_resize(list)) {
|
||||
return -1;
|
||||
}
|
||||
|
@ -71,26 +71,26 @@ int list_insert(list_t *list, size_t index, void *item) {
|
|||
return list->length;
|
||||
}
|
||||
|
||||
void list_del(list_t *list, size_t index) {
|
||||
void wlr_list_del(struct wlr_list *list, size_t index) {
|
||||
list->length--;
|
||||
memmove(&list->items[index], &list->items[index + 1], sizeof(void*) * (list->length - index));
|
||||
}
|
||||
|
||||
void *list_pop(list_t *list) {
|
||||
void *wlr_list_pop(struct wlr_list *list) {
|
||||
void *_ = list->items[list->length - 1];
|
||||
list_del(list, list->length - 1);
|
||||
wlr_list_del(list, list->length - 1);
|
||||
return _;
|
||||
}
|
||||
|
||||
void *list_peek(list_t *list) {
|
||||
void *wlr_list_peek(struct wlr_list *list) {
|
||||
return list->items[list->length - 1];
|
||||
}
|
||||
|
||||
int list_cat(list_t *list, list_t *source) {
|
||||
int wlr_list_cat(struct wlr_list *list, struct wlr_list *source) {
|
||||
size_t old_len = list->length;
|
||||
size_t i;
|
||||
for (i = 0; i < source->length; ++i) {
|
||||
if (list_add(list, source->items[i]) == -1) {
|
||||
if (wlr_list_add(list, source->items[i]) == -1) {
|
||||
list->length = old_len;
|
||||
return -1;
|
||||
}
|
||||
|
@ -98,11 +98,11 @@ int list_cat(list_t *list, list_t *source) {
|
|||
return list->length;
|
||||
}
|
||||
|
||||
void list_qsort(list_t *list, int compare(const void *left, const void *right)) {
|
||||
void wlr_list_qsort(struct wlr_list *list, int compare(const void *left, const void *right)) {
|
||||
qsort(list->items, list->length, sizeof(void *), compare);
|
||||
}
|
||||
|
||||
int list_seq_find(list_t *list,
|
||||
int wlr_list_seq_find(struct wlr_list *list,
|
||||
int compare(const void *item, const void *data),
|
||||
const void *data) {
|
||||
for (size_t i = 0; i < list->length; i++) {
|
|
@ -8,7 +8,7 @@
|
|||
#include <wlr/types/wlr_output.h>
|
||||
#include <wlr/types/wlr_surface.h>
|
||||
#include <wlr/interfaces/wlr_output.h>
|
||||
#include <wlr/util/list.h>
|
||||
#include <wlr/types/wlr_list.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include <GLES2/gl2.h>
|
||||
#include <wlr/render/matrix.h>
|
||||
|
@ -26,18 +26,18 @@ static void wl_output_send_to_resource(struct wl_resource *resource) {
|
|||
output->make, output->model, output->transform);
|
||||
}
|
||||
if (version >= WL_OUTPUT_MODE_SINCE_VERSION) {
|
||||
for (size_t i = 0; i < output->modes->length; ++i) {
|
||||
struct wlr_output_mode *mode = output->modes->items[i];
|
||||
struct wlr_output_mode *mode;
|
||||
wl_list_for_each(mode, &output->modes, link) {
|
||||
// TODO: mode->flags should just be preferred
|
||||
uint32_t flags = mode->flags;
|
||||
if (output->current_mode == mode) {
|
||||
flags |= WL_OUTPUT_MODE_CURRENT;
|
||||
}
|
||||
wl_output_send_mode(resource, flags,
|
||||
mode->width, mode->height, mode->refresh);
|
||||
wl_output_send_mode(resource, flags, mode->width, mode->height,
|
||||
mode->refresh);
|
||||
}
|
||||
|
||||
if (output->modes->length == 0) {
|
||||
if (wl_list_length(&output->modes) == 0) {
|
||||
// Output has no mode, send the current width/height
|
||||
wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT,
|
||||
output->width, output->height, 0);
|
||||
|
@ -51,6 +51,25 @@ static void wl_output_send_to_resource(struct wl_resource *resource) {
|
|||
}
|
||||
}
|
||||
|
||||
static void wlr_output_send_current_mode_to_resource(
|
||||
struct wl_resource *resource) {
|
||||
struct wlr_output *output = wl_resource_get_user_data(resource);
|
||||
assert(output);
|
||||
const uint32_t version = wl_resource_get_version(resource);
|
||||
if (version < WL_OUTPUT_MODE_SINCE_VERSION) {
|
||||
return;
|
||||
}
|
||||
if (output->current_mode != NULL) {
|
||||
struct wlr_output_mode *mode = output->current_mode;
|
||||
wl_output_send_mode(resource, mode->flags | WL_OUTPUT_MODE_CURRENT,
|
||||
mode->width, mode->height, mode->refresh);
|
||||
} else {
|
||||
// Output has no mode, send the current width/height
|
||||
wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT, output->width,
|
||||
output->height, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void wl_output_destroy(struct wl_resource *resource) {
|
||||
struct wlr_output *output = wl_resource_get_user_data(resource);
|
||||
struct wl_resource *_resource = NULL;
|
||||
|
@ -75,21 +94,21 @@ static void wl_output_bind(struct wl_client *wl_client, void *_wlr_output,
|
|||
uint32_t version, uint32_t id) {
|
||||
struct wlr_output *wlr_output = _wlr_output;
|
||||
assert(wl_client && wlr_output);
|
||||
if (version > 3) {
|
||||
wlr_log(L_ERROR, "Client requested unsupported wl_output version, disconnecting");
|
||||
wl_client_destroy(wl_client);
|
||||
return;
|
||||
}
|
||||
struct wl_resource *wl_resource = wl_resource_create(
|
||||
wl_client, &wl_output_interface, version, id);
|
||||
wl_resource_set_implementation(wl_resource, &wl_output_impl,
|
||||
wlr_output, wl_output_destroy);
|
||||
wl_list_insert(&wlr_output->wl_resources, wl_resource_get_link(wl_resource));
|
||||
|
||||
struct wl_resource *wl_resource = wl_resource_create(wl_client,
|
||||
&wl_output_interface, version, id);
|
||||
wl_resource_set_implementation(wl_resource, &wl_output_impl, wlr_output,
|
||||
wl_output_destroy);
|
||||
wl_list_insert(&wlr_output->wl_resources,
|
||||
wl_resource_get_link(wl_resource));
|
||||
wl_output_send_to_resource(wl_resource);
|
||||
}
|
||||
|
||||
struct wl_global *wlr_output_create_global(
|
||||
struct wlr_output *wlr_output, struct wl_display *display) {
|
||||
struct wl_global *wlr_output_create_global(struct wlr_output *wlr_output,
|
||||
struct wl_display *display) {
|
||||
if (wlr_output->wl_global != NULL) {
|
||||
return wlr_output->wl_global;
|
||||
}
|
||||
struct wl_global *wl_global = wl_global_create(display,
|
||||
&wl_output_interface, 3, wlr_output, wl_output_bind);
|
||||
wlr_output->wl_global = wl_global;
|
||||
|
@ -97,32 +116,65 @@ struct wl_global *wlr_output_create_global(
|
|||
return wl_global;
|
||||
}
|
||||
|
||||
void wlr_output_update_matrix(struct wlr_output *output) {
|
||||
wlr_matrix_texture(output->transform_matrix, output->width, output->height, output->transform);
|
||||
void wlr_output_destroy_global(struct wlr_output *wlr_output) {
|
||||
if (wlr_output->wl_global == NULL) {
|
||||
return;
|
||||
}
|
||||
struct wl_resource *resource, *tmp;
|
||||
wl_resource_for_each_safe(resource, tmp, &wlr_output->wl_resources) {
|
||||
struct wl_list *link = wl_resource_get_link(resource);
|
||||
wl_list_remove(link);
|
||||
}
|
||||
wl_global_destroy(wlr_output->wl_global);
|
||||
wlr_output->wl_global = NULL;
|
||||
}
|
||||
|
||||
static void wlr_output_update_matrix(struct wlr_output *output) {
|
||||
wlr_matrix_texture(output->transform_matrix, output->width, output->height,
|
||||
output->transform);
|
||||
}
|
||||
|
||||
void wlr_output_enable(struct wlr_output *output, bool enable) {
|
||||
output->impl->enable(output, enable);
|
||||
}
|
||||
|
||||
bool wlr_output_set_mode(struct wlr_output *output, struct wlr_output_mode *mode) {
|
||||
bool wlr_output_set_mode(struct wlr_output *output,
|
||||
struct wlr_output_mode *mode) {
|
||||
if (!output->impl || !output->impl->set_mode) {
|
||||
return false;
|
||||
}
|
||||
bool result = output->impl->set_mode(output, mode);
|
||||
if (result) {
|
||||
wlr_output_update_matrix(output);
|
||||
struct wl_resource *resource;
|
||||
wl_resource_for_each(resource, &output->wl_resources) {
|
||||
wlr_output_send_current_mode_to_resource(resource);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void wlr_output_update_size(struct wlr_output *output, int32_t width,
|
||||
int32_t height) {
|
||||
output->width = width;
|
||||
output->height = height;
|
||||
wlr_output_update_matrix(output);
|
||||
if (output->wl_global != NULL) {
|
||||
struct wl_resource *resource;
|
||||
wl_resource_for_each(resource, &output->wl_resources) {
|
||||
wlr_output_send_current_mode_to_resource(resource);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void wlr_output_transform(struct wlr_output *output,
|
||||
enum wl_output_transform transform) {
|
||||
output->impl->transform(output, transform);
|
||||
wlr_output_update_matrix(output);
|
||||
}
|
||||
|
||||
void wlr_output_set_position(struct wlr_output *output, int32_t lx, int32_t ly) {
|
||||
void wlr_output_set_position(struct wlr_output *output, int32_t lx,
|
||||
int32_t ly) {
|
||||
if (lx == output->lx && ly == output->ly) {
|
||||
return;
|
||||
}
|
||||
|
@ -153,8 +205,7 @@ static bool set_cursor(struct wlr_output *output, const uint8_t *buf,
|
|||
output->cursor.height = height;
|
||||
|
||||
if (!output->cursor.renderer) {
|
||||
/* NULL egl is okay given that we are only using pixel buffers */
|
||||
output->cursor.renderer = wlr_gles2_renderer_create(NULL);
|
||||
output->cursor.renderer = wlr_gles2_renderer_create(output->backend);
|
||||
if (!output->cursor.renderer) {
|
||||
return false;
|
||||
}
|
||||
|
@ -307,10 +358,11 @@ bool wlr_output_move_cursor(struct wlr_output *output, int x, int y) {
|
|||
return output->impl->move_cursor(output, x, y);
|
||||
}
|
||||
|
||||
void wlr_output_init(struct wlr_output *output,
|
||||
void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend,
|
||||
const struct wlr_output_impl *impl) {
|
||||
output->backend = backend;
|
||||
output->impl = impl;
|
||||
output->modes = list_create();
|
||||
wl_list_init(&output->modes);
|
||||
output->transform = WL_OUTPUT_TRANSFORM_NORMAL;
|
||||
output->scale = 1;
|
||||
wl_signal_init(&output->events.frame);
|
||||
|
@ -334,11 +386,11 @@ void wlr_output_destroy(struct wlr_output *output) {
|
|||
wlr_texture_destroy(output->cursor.texture);
|
||||
wlr_renderer_destroy(output->cursor.renderer);
|
||||
|
||||
for (size_t i = 0; output->modes && i < output->modes->length; ++i) {
|
||||
struct wlr_output_mode *mode = output->modes->items[i];
|
||||
struct wlr_output_mode *mode, *tmp_mode;
|
||||
wl_list_for_each_safe(mode, tmp_mode, &output->modes, link) {
|
||||
free(mode);
|
||||
}
|
||||
list_free(output->modes);
|
||||
wl_list_remove(&output->modes);
|
||||
if (output->impl && output->impl->destroy) {
|
||||
output->impl->destroy(output);
|
||||
} else {
|
||||
|
@ -391,13 +443,13 @@ void wlr_output_swap_buffers(struct wlr_output *output) {
|
|||
}
|
||||
|
||||
void wlr_output_set_gamma(struct wlr_output *output,
|
||||
uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b) {
|
||||
uint32_t size, uint16_t *r, uint16_t *g, uint16_t *b) {
|
||||
if (output->impl->set_gamma) {
|
||||
output->impl->set_gamma(output, size, r, g, b);
|
||||
}
|
||||
}
|
||||
|
||||
uint16_t wlr_output_get_gamma_size(struct wlr_output *output) {
|
||||
uint32_t wlr_output_get_gamma_size(struct wlr_output *output) {
|
||||
if (!output->impl->get_gamma_size) {
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -121,12 +121,7 @@ static void screenshooter_bind(struct wl_client *wl_client,
|
|||
void *_screenshooter, uint32_t version, uint32_t id) {
|
||||
struct wlr_screenshooter *screenshooter = _screenshooter;
|
||||
assert(wl_client && screenshooter);
|
||||
if (version > 1) {
|
||||
wlr_log(L_ERROR, "Client requested unsupported screenshooter version,"
|
||||
"disconnecting");
|
||||
wl_client_destroy(wl_client);
|
||||
return;
|
||||
}
|
||||
|
||||
struct wl_resource *wl_resource = wl_resource_create(wl_client,
|
||||
&orbital_screenshooter_interface, version, id);
|
||||
wl_resource_set_implementation(wl_resource, &screenshooter_impl,
|
||||
|
|
|
@ -177,12 +177,7 @@ static void wl_seat_bind(struct wl_client *wl_client, void *_wlr_seat,
|
|||
uint32_t version, uint32_t id) {
|
||||
struct wlr_seat *wlr_seat = _wlr_seat;
|
||||
assert(wl_client && wlr_seat);
|
||||
if (version > 6) {
|
||||
wlr_log(L_ERROR,
|
||||
"Client requested unsupported wl_seat version, disconnecting");
|
||||
wl_client_destroy(wl_client);
|
||||
return;
|
||||
}
|
||||
|
||||
struct wlr_seat_handle *handle = calloc(1, sizeof(struct wlr_seat_handle));
|
||||
handle->wl_resource = wl_resource_create(
|
||||
wl_client, &wl_seat_interface, version, id);
|
||||
|
|
|
@ -2,9 +2,9 @@
|
|||
#include <stdlib.h>
|
||||
#include <wayland-server.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include <wlr/egl.h>
|
||||
#include <wlr/render/interface.h>
|
||||
#include <wlr/types/wlr_surface.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/render/matrix.h>
|
||||
|
||||
static void wlr_surface_state_reset_buffer(struct wlr_surface_state *state) {
|
||||
|
@ -408,7 +408,8 @@ static void wlr_surface_commit_pending(struct wlr_surface *surface) {
|
|||
wlr_surface_move_state(surface, surface->pending, surface->current);
|
||||
|
||||
if (null_buffer_commit) {
|
||||
surface->texture->valid = false;
|
||||
wlr_texture_destroy(surface->texture);
|
||||
surface->texture = NULL;
|
||||
}
|
||||
|
||||
bool reupload_buffer = oldw != surface->current->buffer_width ||
|
||||
|
@ -657,6 +658,10 @@ void wlr_surface_get_matrix(struct wlr_surface *surface,
|
|||
wlr_matrix_mul(projection, matrix, matrix);
|
||||
}
|
||||
|
||||
bool wlr_surface_has_buffer(struct wlr_surface *surface) {
|
||||
return surface->texture && surface->texture->valid;
|
||||
}
|
||||
|
||||
int wlr_surface_set_role(struct wlr_surface *surface, const char *role,
|
||||
struct wl_resource *error_resource, uint32_t error_code) {
|
||||
assert(role);
|
||||
|
|
|
@ -8,7 +8,6 @@
|
|||
#include <wlr/types/wlr_wl_shell.h>
|
||||
#include <stdlib.h>
|
||||
#include <wayland-server-protocol.h>
|
||||
#include <wlr/render/interface.h>
|
||||
|
||||
static const char *wlr_wl_shell_surface_role = "wl-shell-surface";
|
||||
|
||||
|
@ -482,7 +481,7 @@ static void handle_wlr_surface_committed(struct wl_listener *listener,
|
|||
struct wlr_wl_shell_surface *surface =
|
||||
wl_container_of(listener, surface, surface_commit_listener);
|
||||
if (!surface->configured &&
|
||||
surface->surface->texture->valid &&
|
||||
wlr_surface_has_buffer(surface->surface) &&
|
||||
surface->state != WLR_WL_SHELL_SURFACE_STATE_NONE) {
|
||||
surface->configured = true;
|
||||
wl_signal_emit(&surface->shell->events.new_surface, surface);
|
||||
|
@ -490,7 +489,7 @@ static void handle_wlr_surface_committed(struct wl_listener *listener,
|
|||
|
||||
if (surface->popup_mapped &&
|
||||
surface->state == WLR_WL_SHELL_SURFACE_STATE_POPUP &&
|
||||
!surface->surface->texture->valid) {
|
||||
!wlr_surface_has_buffer(surface->surface)) {
|
||||
surface->popup_mapped = false;
|
||||
struct wlr_wl_shell_popup_grab *grab =
|
||||
shell_popup_grab_from_seat(surface->shell,
|
||||
|
@ -580,12 +579,7 @@ static void shell_bind(struct wl_client *wl_client, void *_wl_shell,
|
|||
uint32_t version, uint32_t id) {
|
||||
struct wlr_wl_shell *wl_shell = _wl_shell;
|
||||
assert(wl_client && wl_shell);
|
||||
if (version > 1) {
|
||||
wlr_log(L_ERROR,
|
||||
"Client requested unsupported wl_shell version, disconnecting");
|
||||
wl_client_destroy(wl_client);
|
||||
return;
|
||||
}
|
||||
|
||||
struct wl_resource *wl_resource = wl_resource_create(wl_client,
|
||||
&wl_shell_interface, version, id);
|
||||
wl_resource_set_implementation(wl_resource, &shell_impl, wl_shell,
|
||||
|
|
|
@ -9,7 +9,6 @@
|
|||
#include <wlr/types/wlr_surface.h>
|
||||
#include <wlr/types/wlr_seat.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include <wlr/render/interface.h>
|
||||
#include "xdg-shell-unstable-v6-protocol.h"
|
||||
|
||||
static const char *wlr_desktop_xdg_toplevel_role = "xdg_toplevel";
|
||||
|
@ -1018,7 +1017,8 @@ static void wlr_xdg_surface_v6_toplevel_committed(
|
|||
struct wlr_xdg_surface_v6 *surface) {
|
||||
assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL);
|
||||
|
||||
if (!surface->surface->texture->valid && !surface->toplevel_state->added) {
|
||||
if (!wlr_surface_has_buffer(surface->surface)
|
||||
&& !surface->toplevel_state->added) {
|
||||
// on the first commit, send a configure request to tell the client it
|
||||
// is added
|
||||
wlr_xdg_surface_v6_schedule_configure(surface);
|
||||
|
@ -1026,7 +1026,7 @@ static void wlr_xdg_surface_v6_toplevel_committed(
|
|||
return;
|
||||
}
|
||||
|
||||
if (!surface->surface->texture->valid) {
|
||||
if (!wlr_surface_has_buffer(surface->surface)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -1048,7 +1048,7 @@ static void handle_wlr_surface_committed(struct wl_listener *listener,
|
|||
struct wlr_xdg_surface_v6 *surface =
|
||||
wl_container_of(listener, surface, surface_commit_listener);
|
||||
|
||||
if (surface->surface->texture->valid && !surface->configured) {
|
||||
if (wlr_surface_has_buffer(surface->surface) && !surface->configured) {
|
||||
wl_resource_post_error(surface->resource,
|
||||
ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER,
|
||||
"xdg_surface has never been configured");
|
||||
|
@ -1117,7 +1117,7 @@ static void xdg_shell_get_xdg_surface(struct wl_client *wl_client,
|
|||
&zxdg_surface_v6_interface, wl_resource_get_version(client_resource),
|
||||
id);
|
||||
|
||||
if (surface->surface->texture->valid) {
|
||||
if (wlr_surface_has_buffer(surface->surface)) {
|
||||
wl_resource_post_error(surface->resource,
|
||||
ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER,
|
||||
"xdg_surface must not have a buffer at creation");
|
||||
|
@ -1201,12 +1201,7 @@ static void xdg_shell_bind(struct wl_client *wl_client, void *_xdg_shell,
|
|||
uint32_t version, uint32_t id) {
|
||||
struct wlr_xdg_shell_v6 *xdg_shell = _xdg_shell;
|
||||
assert(wl_client && xdg_shell);
|
||||
if (version > 1) {
|
||||
wlr_log(L_ERROR,
|
||||
"Client requested unsupported xdg_shell_v6 version, disconnecting");
|
||||
wl_client_destroy(wl_client);
|
||||
return;
|
||||
}
|
||||
|
||||
struct wlr_xdg_client_v6 *client =
|
||||
calloc(1, sizeof(struct wlr_xdg_client_v6));
|
||||
if (client == NULL) {
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
lib_wlr_util = static_library(
|
||||
'wlr_util',
|
||||
files(
|
||||
'list.c',
|
||||
'log.c',
|
||||
),
|
||||
include_directories: wlr_inc,
|
||||
|
|
|
@ -72,7 +72,7 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
|
|||
surface->height = height;
|
||||
surface->override_redirect = override_redirect;
|
||||
wl_list_insert(&xwm->new_surfaces, &surface->link);
|
||||
surface->state = list_create();
|
||||
surface->state = wlr_list_create();
|
||||
wl_signal_init(&surface->events.destroy);
|
||||
wl_signal_init(&surface->events.request_configure);
|
||||
wl_signal_init(&surface->events.set_class);
|
||||
|
@ -93,7 +93,7 @@ static void wlr_xwayland_surface_destroy(struct wlr_xwayland_surface *surface) {
|
|||
free(surface->title);
|
||||
free(surface->class);
|
||||
free(surface->instance);
|
||||
list_free(surface->state);
|
||||
wlr_list_free(surface->state);
|
||||
free(surface->window_type);
|
||||
free(surface->protocols);
|
||||
free(surface->hints);
|
||||
|
@ -200,7 +200,7 @@ static void handle_surface_state(struct wlr_xwm *xwm,
|
|||
if (action == NET_WM_STATE_REMOVE ||
|
||||
action == NET_WM_STATE_TOGGLE) {
|
||||
free(surface->state->items[j]);
|
||||
list_del(surface->state, j);
|
||||
wlr_list_del(surface->state, j);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
@ -210,7 +210,7 @@ static void handle_surface_state(struct wlr_xwm *xwm,
|
|||
action == NET_WM_STATE_TOGGLE)) {
|
||||
xcb_atom_t *atom_ptr = malloc(sizeof(xcb_atom_t));
|
||||
*atom_ptr = atom;
|
||||
list_add(surface->state, atom_ptr);
|
||||
wlr_list_add(surface->state, atom_ptr);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue