hyprwm/wlroots-hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/wlroots-hyprland.git synced 2024-11-29 16:05:59 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #298 from raazvvann/heghe/wl_list

Browse source 
Replace list_t with wl_list
This commit is contained in:
Drew DeVault 2017-10-21 22:07:44 -04:00 committed by GitHub
commit e8f9283894
27 changed files with 175 additions and 207 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
backend/drm/backend.c
View file

@ -9,7 +9,7 @@
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/interfaces/wlr_output.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/util/log.h>
#include <wlr/render/egl.h> #include <wlr/render/egl.h>
#include "backend/drm/drm.h" #include "backend/drm/drm.h"
@ -29,8 +29,8 @@ static void wlr_drm_backend_destroy(struct wlr_backend *backend) {
wlr_drm_restore_outputs(drm); wlr_drm_restore_outputs(drm);
for (size_t i = 0; drm->outputs && i < drm->outputs->length; ++i) { struct wlr_drm_connector *conn;
struct wlr_drm_connector *conn = drm->outputs->items[i]; wl_list_for_each(conn, &drm->outputs, link) {
wlr_output_destroy(&conn->output); 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_drm_renderer_finish(&drm->renderer);
wlr_session_close_file(drm->session, drm->fd); wlr_session_close_file(drm->session, drm->fd);
wl_event_source_remove(drm->drm_event); wl_event_source_remove(drm->drm_event);
list_free(drm->outputs);
free(drm); free(drm);
} }
@ -64,8 +63,8 @@ static void session_signal(struct wl_listener *listener, void *data) {
if (session->active) { if (session->active) {
wlr_log(L_INFO, "DRM fd resumed"); wlr_log(L_INFO, "DRM fd resumed");
for (size_t i = 0; i < drm->outputs->length; ++i) { struct wlr_drm_connector *conn;
struct wlr_drm_connector *conn = drm->outputs->items[i]; wl_list_for_each(conn, &drm->outputs, link){
wlr_drm_connector_start_renderer(conn); wlr_drm_connector_start_renderer(conn);
if (!conn->crtc) { if (!conn->crtc) {
@ -110,11 +109,7 @@ struct wlr_backend *wlr_drm_backend_create(struct wl_display *display,
wlr_backend_init(&drm->backend, &backend_impl); wlr_backend_init(&drm->backend, &backend_impl);
drm->session = session; drm->session = session;
drm->outputs = list_create(); wl_list_init(&drm->outputs);
if (!drm->outputs) {
wlr_log(L_ERROR, "Failed to allocate list");
goto error_backend;
}
drm->fd = gpu_fd; drm->fd = gpu_fd;
drm->parent = (struct wlr_drm_backend *)parent; drm->parent = (struct wlr_drm_backend *)parent;
@ -158,8 +153,6 @@ error_event:
wl_event_source_remove(drm->drm_event); wl_event_source_remove(drm->drm_event);
error_fd: error_fd:
wlr_session_close_file(drm->session, drm->fd); wlr_session_close_file(drm->session, drm->fd);
list_free(drm->outputs);
error_backend:
free(drm); free(drm);
return NULL; return NULL;
} }

89
backend/drm/drm.c
View file

@ -311,7 +311,7 @@ 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) {
uint32_t crtc[drm->num_crtcs]; uint32_t crtc[drm->num_crtcs];
uint32_t crtc_res[drm->num_crtcs]; uint32_t crtc_res[drm->num_crtcs];
uint32_t possible_crtc[drm->outputs->length]; uint32_t possible_crtc[wl_list_length(&drm->outputs)];
for (size_t i = 0; i < drm->num_crtcs; ++i) { for (size_t i = 0; i < drm->num_crtcs; ++i) {
crtc[i] = UNMATCHED; crtc[i] = UNMATCHED;
@ -319,9 +319,9 @@ static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector
memset(possible_crtc, 0, sizeof(possible_crtc)); memset(possible_crtc, 0, sizeof(possible_crtc));
ssize_t index = -1; ssize_t index = -1, i = 0;
for (size_t i = 0; i < drm->outputs->length; ++i) { struct wlr_drm_connector *c;
struct wlr_drm_connector *c = drm->outputs->items[i]; wl_list_for_each(c, &drm->outputs, link) {
if (c == conn) { if (c == conn) {
index = i; index = i;
} }
@ -332,11 +332,12 @@ static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector
possible_crtc[i] = c->possible_crtc; possible_crtc[i] = c->possible_crtc;
crtc[c->crtc - drm->crtcs] = i; crtc[c->crtc - drm->crtcs] = i;
i++;
} }
assert(index != -1); assert(index != -1);
possible_crtc[index] = conn->possible_crtc; possible_crtc[index] = conn->possible_crtc;
match_obj(drm->outputs->length, possible_crtc, drm->num_crtcs, match_obj(wl_list_length(&drm->outputs), possible_crtc, drm->num_crtcs,
crtc, crtc_res); crtc, crtc_res);
bool matched = false; bool matched = false;
@ -361,7 +362,14 @@ static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector
} }
if (crtc_res[i] != crtc[i]) { if (crtc_res[i] != crtc[i]) {
struct wlr_drm_connector *c = drm->outputs->items[crtc_res[i]]; 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]; c->crtc = &drm->crtcs[i];
} }
} }
@ -436,8 +444,7 @@ static bool wlr_drm_connector_set_mode(struct wlr_output *output,
// Since realloc_crtcs can deallocate planes on OTHER outputs, // Since realloc_crtcs can deallocate planes on OTHER outputs,
// we actually need to reinitalise all of them // we actually need to reinitalise all of them
for (size_t i = 0; i < drm->outputs->length; ++i) { wl_list_for_each(conn, &drm->outputs, link) {
struct wlr_drm_connector *conn = drm->outputs->items[i];
struct wlr_output_mode *mode = conn->output.current_mode; struct wlr_output_mode *mode = conn->output.current_mode;
struct wlr_drm_crtc *crtc = conn->crtc; struct wlr_drm_crtc *crtc = conn->crtc;
@ -660,13 +667,6 @@ static int retry_pageflip(void *data) {
return 0; 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[] = { static const int32_t subpixel_map[] = {
[DRM_MODE_SUBPIXEL_UNKNOWN] = WL_OUTPUT_SUBPIXEL_UNKNOWN, [DRM_MODE_SUBPIXEL_UNKNOWN] = WL_OUTPUT_SUBPIXEL_UNKNOWN,
[DRM_MODE_SUBPIXEL_HORIZONTAL_RGB] = WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB, [DRM_MODE_SUBPIXEL_HORIZONTAL_RGB] = WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB,
@ -685,7 +685,7 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
return; return;
} }
size_t seen_len = drm->outputs->length; size_t seen_len = wl_list_length(&drm->outputs);
// +1 so it can never be 0 // +1 so it can never be 0
bool seen[seen_len + 1]; bool seen[seen_len + 1];
memset(seen, 0, sizeof(seen)); memset(seen, 0, sizeof(seen));
@ -697,11 +697,16 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
wlr_log_errno(L_ERROR, "Failed to get DRM connector"); wlr_log_errno(L_ERROR, "Failed to get DRM connector");
continue; continue;
} }
int index = 0;
struct wlr_drm_connector *wlr_conn; struct wlr_drm_connector *c, *wlr_conn = NULL;
int index = list_seq_find(drm->outputs, find_id, &drm_conn->connector_id); wl_list_for_each(c, &drm->outputs, link) {
index++;
if (index == -1) { if (c->id == drm_conn->connector_id) {
wlr_conn = c;
break;
}
}
if (!wlr_conn) {
wlr_conn = calloc(1, sizeof(*wlr_conn)); wlr_conn = calloc(1, sizeof(*wlr_conn));
if (!wlr_conn) { if (!wlr_conn) {
wlr_log_errno(L_ERROR, "Allocation failed"); wlr_log_errno(L_ERROR, "Allocation failed");
@ -741,17 +746,10 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
parse_edid(&wlr_conn->output, edid_len, edid); parse_edid(&wlr_conn->output, edid_len, edid);
free(edid); free(edid);
if (list_add(drm->outputs, wlr_conn) == -1) { wl_list_insert(&drm->outputs, &wlr_conn->link);
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); wlr_output_create_global(&wlr_conn->output, drm->display);
wlr_log(L_INFO, "Found display '%s'", wlr_conn->output.name); wlr_log(L_INFO, "Found display '%s'", wlr_conn->output.name);
} else { } else {
wlr_conn = drm->outputs->items[index];
seen[index] = true; seen[index] = true;
} }
@ -776,11 +774,7 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
mode->wlr_mode.width, mode->wlr_mode.height, mode->wlr_mode.width, mode->wlr_mode.height,
mode->wlr_mode.refresh); mode->wlr_mode.refresh);
if (list_add(wlr_conn->output.modes, mode) == -1) { wl_list_insert(&wlr_conn->output.modes, &mode->wlr_mode.link);
wlr_log_errno(L_ERROR, "Allocation failed");
free(mode);
continue;
}
} }
wlr_conn->state = WLR_DRM_CONN_NEEDS_MODESET; wlr_conn->state = WLR_DRM_CONN_NEEDS_MODESET;
@ -799,12 +793,14 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
drmModeFreeResources(res); drmModeFreeResources(res);
for (size_t i = seen_len; i-- > 0;) { struct wlr_drm_connector *conn, *tmp_conn;
if (seen[i]) { size_t index = seen_len - 1;
wl_list_for_each_safe(conn, tmp_conn, &drm->outputs, link) {
if (seen[index]) {
index--;
continue; continue;
} }
index--;
struct wlr_drm_connector *conn = drm->outputs->items[i];
wlr_log(L_INFO, "'%s' disappeared", conn->output.name); wlr_log(L_INFO, "'%s' disappeared", conn->output.name);
wlr_drm_connector_cleanup(conn); wlr_drm_connector_cleanup(conn);
@ -812,8 +808,6 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
drmModeFreeCrtc(conn->old_crtc); drmModeFreeCrtc(conn->old_crtc);
wl_event_source_remove(conn->retry_pageflip); wl_event_source_remove(conn->retry_pageflip);
free(conn); free(conn);
list_del(drm->outputs, i);
} }
} }
@ -848,10 +842,10 @@ int wlr_drm_event(int fd, uint32_t mask, void *data) {
} }
void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) { 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;
struct wlr_drm_connector *conn = drm->outputs->items[i]; wl_list_for_each(conn, &drm->outputs, link) {
if (conn->state == WLR_DRM_CONN_CONNECTED) { if (conn->state == WLR_DRM_CONN_CONNECTED) {
conn->state = WLR_DRM_CONN_CLEANUP; conn->state = WLR_DRM_CONN_CLEANUP;
} }
@ -861,11 +855,13 @@ void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
while (to_close && time(NULL) < timeout) { while (to_close && time(NULL) < timeout) {
wlr_drm_event(drm->fd, 0, NULL); wlr_drm_event(drm->fd, 0, NULL);
for (size_t i = 0; i < drm->outputs->length; ++i) { size_t i = 0;
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_CLEANUP || !conn->pageflip_pending) { if (conn->state != WLR_DRM_CONN_CLEANUP || !conn->pageflip_pending) {
to_close &= ~(1 << i); to_close &= ~(1 << i);
} }
i++;
} }
} }
@ -873,8 +869,7 @@ void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
wlr_log(L_ERROR, "Timed out stopping output renderers"); wlr_log(L_ERROR, "Timed out stopping output renderers");
} }
for (size_t i = 0; i < drm->outputs->length; ++i) { wl_list_for_each(conn, &drm->outputs, link) {
struct wlr_drm_connector *conn = drm->outputs->items[i];
drmModeCrtc *crtc = conn->old_crtc; drmModeCrtc *crtc = conn->old_crtc;
if (!crtc) { if (!crtc) {
continue; continue;

2
backend/libinput/backend.c
View file

@ -99,7 +99,7 @@ static void wlr_libinput_backend_destroy(struct wlr_backend *_backend) {
} }
struct wlr_libinput_backend *backend = (struct wlr_libinput_backend *)_backend; struct wlr_libinput_backend *backend = (struct wlr_libinput_backend *)_backend;
for (size_t i = 0; i < backend->wlr_device_lists->length; i++) { 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++) { for (size_t j = 0; j < wlr_devices->length; j++) {
struct wlr_input_device *wlr_dev = wlr_devices->items[j]; struct wlr_input_device *wlr_dev = wlr_devices->items[j];
wl_signal_emit(&backend->backend.events.input_remove, wlr_dev); wl_signal_emit(&backend->backend.events.input_remove, wlr_dev);

41
backend/libinput/events.c
View file

@ -3,19 +3,19 @@
#include <libinput.h> #include <libinput.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_input_device.h>
#include <wlr/util/list.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include <wayland-util.h>
#include "backend/libinput.h" #include "backend/libinput.h"
struct wlr_input_device *get_appropriate_device( struct wlr_input_device *get_appropriate_device(
enum wlr_input_device_type desired_type, enum wlr_input_device_type desired_type,
struct libinput_device *libinput_dev) { 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) { if (!wlr_devices) {
return NULL; return NULL;
} }
for (size_t i = 0; i < wlr_devices->length; ++i) { struct wlr_input_device *dev;
struct wlr_input_device *dev = wlr_devices->items[i]; wl_list_for_each(dev, wlr_devices, link) {
if (dev->type == desired_type) { if (dev->type == desired_type) {
return dev; return dev;
} }
@ -35,7 +35,7 @@ static struct wlr_input_device_impl input_device_impl = {
static struct wlr_input_device *allocate_device( static struct wlr_input_device *allocate_device(
struct wlr_libinput_backend *backend, struct libinput_device *libinput_dev, 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 vendor = libinput_device_get_id_vendor(libinput_dev);
int product = libinput_device_get_id_product(libinput_dev); int product = libinput_device_get_id_product(libinput_dev);
const char *name = libinput_device_get_name(libinput_dev); const char *name = libinput_device_get_name(libinput_dev);
@ -44,10 +44,7 @@ static struct wlr_input_device *allocate_device(
return NULL; return NULL;
} }
struct wlr_input_device *wlr_dev = &wlr_libinput_dev->wlr_input_device; struct wlr_input_device *wlr_dev = &wlr_libinput_dev->wlr_input_device;
if (list_add(wlr_devices, wlr_dev) == -1) { wl_list_insert(wlr_devices, &wlr_dev->link);
free(wlr_libinput_dev);
return NULL;
}
wlr_libinput_dev->handle = libinput_dev; wlr_libinput_dev->handle = libinput_dev;
libinput_device_ref(libinput_dev); libinput_device_ref(libinput_dev);
wlr_input_device_init(wlr_dev, type, &input_device_impl, 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 vendor = libinput_device_get_id_vendor(libinput_dev);
int product = libinput_device_get_id_product(libinput_dev); int product = libinput_device_get_id_product(libinput_dev);
const char *name = libinput_device_get_name(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) { if (!wlr_devices) {
goto fail; goto fail;
} }
@ -145,23 +143,26 @@ static void handle_device_added(struct wlr_libinput_backend *backend,
// TODO // TODO
} }
if (wlr_devices->length > 0) { if (wl_list_length(wlr_devices) > 0) {
libinput_device_set_user_data(libinput_dev, wlr_devices); libinput_device_set_user_data(libinput_dev, wlr_devices);
list_add(backend->wlr_device_lists, wlr_devices); list_add(backend->wlr_device_lists, wlr_devices);
} else { } else {
list_free(wlr_devices); free(wlr_devices);
} }
return; return;
fail: fail:
wlr_log(L_ERROR, "Could not allocate new device"); wlr_log(L_ERROR, "Could not allocate new device");
list_foreach(wlr_devices, free); struct wlr_input_device *dev, *tmp_dev;
list_free(wlr_devices); 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, static void handle_device_removed(struct wlr_libinput_backend *backend,
struct libinput_device *libinput_dev) { 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 vendor = libinput_device_get_id_vendor(libinput_dev);
int product = libinput_device_get_id_product(libinput_dev); int product = libinput_device_get_id_product(libinput_dev);
const char *name = libinput_device_get_name(libinput_dev); const char *name = libinput_device_get_name(libinput_dev);
@ -169,10 +170,10 @@ static void handle_device_removed(struct wlr_libinput_backend *backend,
if (!wlr_devices) { if (!wlr_devices) {
return; return;
} }
for (size_t i = 0; i < wlr_devices->length; i++) { struct wlr_input_device *dev, *tmp_dev;
struct wlr_input_device *wlr_dev = wlr_devices->items[i]; wl_list_for_each_safe(dev, tmp_dev, wlr_devices, link) {
wl_signal_emit(&backend->backend.events.input_remove, wlr_dev); wl_signal_emit(&backend->backend.events.input_remove, dev);
wlr_input_device_destroy(wlr_dev); wlr_input_device_destroy(dev);
} }
for (size_t i = 0; i < backend->wlr_device_lists->length; i++) { for (size_t i = 0; i < backend->wlr_device_lists->length; i++) {
if (backend->wlr_device_lists->items[i] == wlr_devices) { if (backend->wlr_device_lists->items[i] == wlr_devices) {
@ -180,7 +181,7 @@ static void handle_device_removed(struct wlr_libinput_backend *backend,
break; break;
} }
} }
list_free(wlr_devices); free(wlr_devices);
} }
void wlr_libinput_event(struct wlr_libinput_backend *backend, void wlr_libinput_event(struct wlr_libinput_backend *backend,

30
backend/multi/backend.c
View file

@ -13,14 +13,15 @@ struct subbackend_state {
struct wl_listener input_remove; struct wl_listener input_remove;
struct wl_listener output_add; struct wl_listener output_add;
struct wl_listener output_remove; struct wl_listener output_remove;
struct wl_list link;
}; };
static bool multi_backend_start(struct wlr_backend *_backend) { static bool multi_backend_start(struct wlr_backend *_backend) {
struct wlr_multi_backend *backend = (struct wlr_multi_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;
struct subbackend_state *sub = backend->backends->items[i]; wl_list_for_each(sub, &backend->backends, link) {
if (!wlr_backend_start(sub->backend)) { 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; return false;
} }
} }
@ -29,20 +30,19 @@ static bool multi_backend_start(struct wlr_backend *_backend) {
static void multi_backend_destroy(struct wlr_backend *_backend) { static void multi_backend_destroy(struct wlr_backend *_backend) {
struct wlr_multi_backend *backend = (struct wlr_multi_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;
struct subbackend_state *sub = backend->backends->items[i]; wl_list_for_each(sub, &backend->backends, link) {
wlr_backend_destroy(sub->backend); wlr_backend_destroy(sub->backend);
free(sub); free(sub);
} }
list_free(backend->backends);
wlr_session_destroy(backend->session); wlr_session_destroy(backend->session);
free(backend); free(backend);
} }
static struct wlr_egl *multi_backend_get_egl(struct wlr_backend *_backend) { static struct wlr_egl *multi_backend_get_egl(struct wlr_backend *_backend) {
struct wlr_multi_backend *backend = (struct wlr_multi_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;
struct subbackend_state *sub = backend->backends->items[i]; wl_list_for_each(sub, &backend->backends, link) {
struct wlr_egl *egl = wlr_backend_get_egl(sub->backend); struct wlr_egl *egl = wlr_backend_get_egl(sub->backend);
if (egl) { if (egl) {
return egl; return egl;
@ -65,13 +65,7 @@ struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session) {
return NULL; return NULL;
} }
backend->backends = list_create(); wl_list_init(&backend->backends);
if (!backend->backends) {
free(backend);
wlr_log(L_ERROR, "Backend allocation failed");
return NULL;
}
wlr_backend_init(&backend->backend, &backend_impl); wlr_backend_init(&backend->backend, &backend_impl);
backend->session = session; 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"); wlr_log(L_ERROR, "Could not add backend: allocation failed");
return; return;
} }
if (list_add(multi->backends, sub) == -1) { wl_list_insert(&multi->backends, &sub->link);
wlr_log(L_ERROR, "Could not add backend: allocation failed");
free(sub);
return;
}
sub->backend = backend; sub->backend = backend;
sub->container = &multi->backend; sub->container = &multi->backend;

35
backend/wayland/backend.c
View file

@ -64,16 +64,16 @@ static void wlr_wl_backend_destroy(struct wlr_backend *_backend) {
return; return;
} }
for (size_t i = 0; i < backend->outputs->length; ++i) { struct wlr_wl_backend_output *output, *tmp_output;
wlr_output_destroy(backend->outputs->items[i]); 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) { struct wlr_input_device *input_device, *tmp_input_device;
wlr_input_device_destroy(backend->devices->items[i]); 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); free(backend->seat_name);
wl_event_source_remove(backend->remote_display_src); 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_output *wlr_wl_output_for_surface(
struct wlr_wl_backend *backend, struct wl_surface *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;
struct wlr_wl_backend_output *output = backend->outputs->items[i]; wl_list_for_each(output, &backend->outputs, link) {
if (output->surface == surface) { if (output->surface == surface) {
return output; return output;
} }
@ -123,15 +123,8 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
} }
wlr_backend_init(&backend->backend, &backend_impl); wlr_backend_init(&backend->backend, &backend_impl);
if (!(backend->devices = list_create())) { wl_list_init(&backend->devices);
wlr_log(L_ERROR, "Could not allocate devices list"); wl_list_init(&backend->outputs);
goto error;
}
if (!(backend->outputs = list_create())) {
wlr_log(L_ERROR, "Could not allocate outputs list");
goto error;
}
backend->local_display = display; 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); wlr_egl_bind_display(&backend->egl, backend->local_display);
return &backend->backend; return &backend->backend;
error:
if (backend) {
list_free(backend->devices);
list_free(backend->outputs);
}
free(backend);
return NULL;
} }

9
backend/wayland/output.c
View file

@ -248,8 +248,8 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
wlr_output->height = 480; wlr_output->height = 480;
strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make)); strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make));
strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model)); strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model));
snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%zd", snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%d",
backend->outputs->length + 1); wl_list_length(&backend->outputs) + 1);
wlr_output_update_matrix(wlr_output); wlr_output_update_matrix(wlr_output);
output->backend = backend; output->backend = backend;
@ -306,10 +306,7 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
goto error; goto error;
} }
if (list_add(backend->outputs, wlr_output) == -1) { wl_list_insert(&backend->outputs, &output->link);
wlr_log(L_ERROR, "Allocation failed");
goto error;
}
wlr_output_create_global(wlr_output, backend->local_display); wlr_output_create_global(wlr_output, backend->local_display);
wl_signal_emit(&backend->backend.events.output_add, wlr_output); wl_signal_emit(&backend->backend.events.output_add, wlr_output);
return wlr_output; return wlr_output;

6
backend/wayland/wl_seat.c
View file

@ -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; struct wlr_input_device *wlr_device = &wlr_wl_dev->wlr_input_device;
wlr_input_device_init(wlr_device, type, &input_device_impl, wlr_input_device_init(wlr_device, type, &input_device_impl,
name, vendor, product); name, vendor, product);
if (list_add(backend->devices, wlr_device) == -1) { wl_list_insert(&backend->devices, &wlr_device->link);
wlr_log_errno(L_ERROR, "Allocation failed");
free(wlr_wl_dev);
return NULL;
}
return wlr_device; return wlr_device;
} }

3
examples/pointer.c
View file

@ -21,6 +21,7 @@
#include <wlr/xcursor.h> #include <wlr/xcursor.h>
#include <wlr/types/wlr_cursor.h> #include <wlr/types/wlr_cursor.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include <wlr/types/wlr_list.h>
#include "shared.h" #include "shared.h"
#include "config.h" #include "config.h"
#include "cat.h" #include "cat.h"
@ -45,7 +46,7 @@ struct sample_state {
struct wl_listener touch_up; struct wl_listener touch_up;
struct wl_listener touch_down; struct wl_listener touch_down;
struct wl_listener touch_cancel; 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_axis;
struct wl_listener tablet_tool_proxmity; struct wl_listener tablet_tool_proxmity;

6
examples/shared.c
View file

@ -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, "Output '%s' added", output->name);
wlr_log(L_DEBUG, "%s %s %"PRId32"mm x %"PRId32"mm", output->make, output->model, wlr_log(L_DEBUG, "%s %s %"PRId32"mm x %"PRId32"mm", output->make, output->model,
output->phys_width, output->phys_height); output->phys_width, output->phys_height);
if (output->modes->length > 0) { if (wl_list_length(&output->modes) > 0) {
wlr_output_set_mode(output, output->modes->items[0]); struct wlr_output_mode *mode = NULL;
wl_container_of((&output->modes)->prev, mode, link);
wlr_output_set_mode(output, mode);
} }
struct output_state *ostate = calloc(1, sizeof(struct output_state)); struct output_state *ostate = calloc(1, sizeof(struct output_state));
clock_gettime(CLOCK_MONOTONIC, &ostate->last_frame); clock_gettime(CLOCK_MONOTONIC, &ostate->last_frame);

4
examples/touch.c
View file

@ -16,7 +16,7 @@
#include <wlr/render.h> #include <wlr/render.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/util/list.h> #include <wlr/types/wlr_list.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "shared.h" #include "shared.h"
#include "cat.h" #include "cat.h"
@ -24,7 +24,7 @@
struct sample_state { struct sample_state {
struct wlr_renderer *renderer; struct wlr_renderer *renderer;
struct wlr_texture *cat_texture; struct wlr_texture *cat_texture;
list_t *touch_points; struct wlr_list *touch_points;
}; };
struct touch_point { struct touch_point {

6
include/backend/drm/drm.h
View file

@ -8,12 +8,13 @@
#include <xf86drmMode.h> #include <xf86drmMode.h>
#include <EGL/egl.h> #include <EGL/egl.h>
#include <gbm.h> #include <gbm.h>
#include <wayland-util.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/backend/drm.h> #include <wlr/backend/drm.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/render/egl.h> #include <wlr/render/egl.h>
#include <wlr/util/list.h> #include <wlr/types/wlr_list.h>
#include "iface.h" #include "iface.h"
#include "properties.h" #include "properties.h"
@ -92,7 +93,7 @@ struct wlr_drm_backend {
struct wl_listener session_signal; struct wl_listener session_signal;
struct wl_listener drm_invalidated; struct wl_listener drm_invalidated;
list_t *outputs; struct wl_list outputs;
struct wlr_drm_renderer renderer; struct wlr_drm_renderer renderer;
struct wlr_session *session; struct wlr_session *session;
@ -128,6 +129,7 @@ struct wlr_drm_connector {
bool pageflip_pending; bool pageflip_pending;
struct wl_event_source *retry_pageflip; struct wl_event_source *retry_pageflip;
struct wl_list link;
}; };
bool wlr_drm_check_features(struct wlr_drm_backend *drm); bool wlr_drm_check_features(struct wlr_drm_backend *drm);

4
include/backend/libinput.h
View file

@ -5,7 +5,7 @@
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/interfaces/wlr_input_device.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_libinput_backend {
struct wlr_backend backend; struct wlr_backend backend;
@ -18,7 +18,7 @@ struct wlr_libinput_backend {
struct wl_listener session_signal; struct wl_listener session_signal;
list_t *wlr_device_lists; struct wlr_list *wlr_device_lists;
}; };
struct wlr_libinput_input_device { struct wlr_libinput_input_device {

4
include/backend/multi.h
View file

@ -3,14 +3,14 @@
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/backend/multi.h> #include <wlr/backend/multi.h>
#include <wlr/util/list.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wayland-util.h>
struct wlr_multi_backend { struct wlr_multi_backend {
struct wlr_backend backend; struct wlr_backend backend;
struct wlr_session *session; struct wlr_session *session;
list_t *backends; struct wl_list backends;
}; };
#endif #endif

7
include/backend/wayland.h
View file

@ -9,7 +9,7 @@
#include <wlr/backend/wayland.h> #include <wlr/backend/wayland.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
#include <wlr/util/list.h> #include <wayland-util.h>
struct wlr_wl_backend { struct wlr_wl_backend {
struct wlr_backend backend; struct wlr_backend backend;
@ -17,8 +17,8 @@ struct wlr_wl_backend {
/* local state */ /* local state */
bool started; bool started;
struct wl_display *local_display; struct wl_display *local_display;
list_t *devices; struct wl_list devices;
list_t *outputs; struct wl_list outputs;
struct wlr_egl egl; struct wlr_egl egl;
size_t requested_outputs; size_t requested_outputs;
/* remote state */ /* remote state */
@ -51,6 +51,7 @@ struct wlr_wl_backend_output {
uint32_t enter_serial; uint32_t enter_serial;
void *egl_surface; void *egl_surface;
struct wl_list link;
}; };
struct wlr_wl_input_device { struct wlr_wl_input_device {

4
include/rootston/desktop.h
View file

@ -9,7 +9,7 @@
#include <wlr/types/wlr_xdg_shell_v6.h> #include <wlr/types/wlr_xdg_shell_v6.h>
#include <wlr/types/wlr_gamma_control.h> #include <wlr/types/wlr_gamma_control.h>
#include <wlr/types/wlr_screenshooter.h> #include <wlr/types/wlr_screenshooter.h>
#include <wlr/util/list.h> #include <wlr/types/wlr_list.h>
#include "rootston/view.h" #include "rootston/view.h"
#include "rootston/config.h" #include "rootston/config.h"
@ -22,7 +22,7 @@ struct roots_output {
}; };
struct roots_desktop { struct roots_desktop {
list_t *views; struct wlr_list *views;
struct wl_list outputs; struct wl_list outputs;
struct timespec last_frame; struct timespec last_frame;

4
include/wlr/types/wlr_data_source.h
View file

@ -2,13 +2,13 @@
#define WLR_TYPES_WLR_DATA_SOURCE_H #define WLR_TYPES_WLR_DATA_SOURCE_H
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/util/list.h> #include <wlr/types/wlr_list.h>
struct wlr_data_source_impl; struct wlr_data_source_impl;
struct wlr_data_source { struct wlr_data_source {
struct wlr_data_source_impl *impl; struct wlr_data_source_impl *impl;
list_t *types; struct wlr_list *types;
void *data; void *data;
struct { struct {

2
include/wlr/types/wlr_input_device.h
View file

@ -45,6 +45,8 @@ struct wlr_input_device {
} events; } events;
void *data; void *data;
struct wl_list link;
}; };
#endif #endif

28
include/wlr/util/list.h → include/wlr/types/wlr_list.h
View file

@ -3,57 +3,57 @@
#include <stddef.h> #include <stddef.h>
typedef struct { struct wlr_list {
size_t capacity; size_t capacity;
size_t length; size_t length;
void **items; void **items;
} list_t; };
/** /**
* Creates a new list, may return `NULL` on failure * Creates a new list, may return `NULL` on failure
*/ */
list_t *list_create(void); struct wlr_list *list_create(void);
void list_free(list_t *list); void list_free(struct wlr_list *list);
void list_foreach(list_t *list, void (*callback)(void *item)); void list_foreach(struct wlr_list *list, void (*callback)(void *item));
/** /**
* Add `item` to the end of a list. * Add `item` to the end of a list.
* Returns: new list length or `-1` on failure * Returns: new list length or `-1` on failure
*/ */
int list_add(list_t *list, void *item); int list_add(struct wlr_list *list, void *item);
/** /**
* Add `item` to the end of a list. * Add `item` to the end of a list.
* Returns: new list length or `-1` on failure * Returns: new list length or `-1` on failure
*/ */
int list_push(list_t *list, void *item); int list_push(struct wlr_list *list, void *item);
/** /**
* Place `item` into index `index` in the list * Place `item` into index `index` in the list
* Returns: new list length or `-1` on failure * Returns: new list length or `-1` on failure
*/ */
int list_insert(list_t *list, size_t index, void *item); int list_insert(struct wlr_list *list, size_t index, void *item);
/** /**
* Remove an item from the list * Remove an item from the list
*/ */
void list_del(list_t *list, size_t index); void list_del(struct wlr_list *list, size_t index);
/** /**
* Remove and return an item from the end of the list * Remove and return an item from the end of the list
*/ */
void *list_pop(list_t *list); void *list_pop(struct wlr_list *list);
/** /**
* Get a reference to the last item of a list without removal * Get a reference to the last item of a list without removal
*/ */
void *list_peek(list_t *list); void *list_peek(struct wlr_list *list);
/** /**
* Append each item in `source` to `list` * Append each item in `source` to `list`
* Does not modify `source` * Does not modify `source`
* Returns: new list length or `-1` on failure * Returns: new list length or `-1` on failure
*/ */
int list_cat(list_t *list, list_t *source); int list_cat(struct wlr_list *list, struct wlr_list *source);
// See qsort. Remember to use *_qsort functions as compare functions, // See qsort. Remember to use *_qsort functions as compare functions,
// because they dereference the left and right arguments first! // because they dereference the left and right arguments first!
void list_qsort(list_t *list, int compare(const void *left, const void *right)); void 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 // Return index for first item in list that returns 0 for given compare
// function or -1 if none matches. // function or -1 if none matches.
int list_seq_find(list_t *list, int list_seq_find(struct wlr_list *list,
int compare(const void *item, const void *cmp_to), int compare(const void *item, const void *cmp_to),
const void *cmp_to); const void *cmp_to);

8
include/wlr/types/wlr_output.h
View file

@ -1,15 +1,15 @@
#ifndef WLR_TYPES_WLR_OUTPUT_H #ifndef WLR_TYPES_WLR_OUTPUT_H
#define WLR_TYPES_WLR_OUTPUT_H #define WLR_TYPES_WLR_OUTPUT_H
#include <stdbool.h> #include <wayland-util.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/backend.h> #include <stdbool.h>
#include <wlr/util/list.h>
struct wlr_output_mode { struct wlr_output_mode {
uint32_t flags; // enum wl_output_mode uint32_t flags; // enum wl_output_mode
int32_t width, height; int32_t width, height;
int32_t refresh; // mHz int32_t refresh; // mHz
struct wl_list link;
}; };
struct wlr_output_impl; struct wlr_output_impl;
@ -34,7 +34,7 @@ struct wlr_output {
float transform_matrix[16]; float transform_matrix[16];
/* Note: some backends may have zero modes */ /* Note: some backends may have zero modes */
list_t *modes; struct wl_list modes;
struct wlr_output_mode *current_mode; struct wlr_output_mode *current_mode;
struct { struct {

3
include/wlr/xwayland.h
View file

@ -5,6 +5,7 @@
#include <stdbool.h> #include <stdbool.h>
#include <wlr/types/wlr_compositor.h> #include <wlr/types/wlr_compositor.h>
#include <xcb/xcb.h> #include <xcb/xcb.h>
#include <wlr/types/wlr_list.h>
#ifdef HAS_XCB_ICCCM #ifdef HAS_XCB_ICCCM
#include <xcb/xcb_icccm.h> #include <xcb/xcb_icccm.h>
@ -78,7 +79,7 @@ struct wlr_xwayland_surface {
char *class; char *class;
char *instance; char *instance;
struct wlr_xwayland_surface *parent; 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; pid_t pid;
xcb_atom_t *window_type; xcb_atom_t *window_type;

6
rootston/output.c
View file

@ -166,8 +166,10 @@ void output_add_notify(struct wl_listener *listener, void *data) {
wlr_log(L_DEBUG, "%s %s %"PRId32"mm x %"PRId32"mm", wlr_log(L_DEBUG, "%s %s %"PRId32"mm x %"PRId32"mm",
wlr_output->make, wlr_output->model, wlr_output->make, wlr_output->model,
wlr_output->phys_width, wlr_output->phys_height); wlr_output->phys_width, wlr_output->phys_height);
if (wlr_output->modes->length > 0) { if (wl_list_length(&wlr_output->modes) > 0) {
wlr_output_set_mode(wlr_output, wlr_output->modes->items[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)); struct roots_output *output = calloc(1, sizeof(struct roots_output));

11
types/meson.build
View file

@ -1,15 +1,20 @@
lib_wlr_types = static_library( lib_wlr_types = static_library(
'wlr_types', 'wlr_types',
files( files(
'wlr_box.c',
'wlr_compositor.c',
'wlr_cursor.c',
'wlr_data_device_manager.c', 'wlr_data_device_manager.c',
'wlr_data_source.c', 'wlr_data_source.c',
'wlr_gamma_control.c',
'wlr_input_device.c', 'wlr_input_device.c',
'wlr_keyboard.c', 'wlr_keyboard.c',
'wlr_list.c',
'wlr_output.c', 'wlr_output.c',
'wlr_output_layout.c', 'wlr_output_layout.c',
'wlr_pointer.c', 'wlr_pointer.c',
'wlr_cursor.c',
'wlr_region.c', 'wlr_region.c',
'wlr_screenshooter.c',
'wlr_seat.c', 'wlr_seat.c',
'wlr_surface.c', 'wlr_surface.c',
'wlr_tablet_pad.c', 'wlr_tablet_pad.c',
@ -17,10 +22,6 @@ lib_wlr_types = static_library(
'wlr_touch.c', 'wlr_touch.c',
'wlr_xdg_shell_v6.c', 'wlr_xdg_shell_v6.c',
'wlr_wl_shell.c', 'wlr_wl_shell.c',
'wlr_compositor.c',
'wlr_box.c',
'wlr_gamma_control.c',
'wlr_screenshooter.c',
), ),
include_directories: wlr_inc, include_directories: wlr_inc,
dependencies: [wayland_server, pixman, wlr_protos], dependencies: [wayland_server, pixman, wlr_protos],

2
types/wlr_data_source.c
View file

@ -4,7 +4,7 @@
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/util/list.h> #include <wlr/types/wlr_list.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include <wlr/types/wlr_data_source.h> #include <wlr/types/wlr_data_source.h>
#include <wlr/types/wlr_data_device_manager.h> #include <wlr/types/wlr_data_device_manager.h>

30
util/list.c → types/wlr_list.c
View file

@ -3,10 +3,10 @@
#include <stdbool.h> #include <stdbool.h>
#include <string.h> #include <string.h>
#include <stddef.h> #include <stddef.h>
#include <wlr/util/list.h> #include <wlr/types/wlr_list.h>
list_t *list_create(void) { struct wlr_list *list_create(void) {
list_t *list = malloc(sizeof(list_t)); struct wlr_list *list = malloc(sizeof(struct wlr_list));
if (!list) { if (!list) {
return NULL; return NULL;
} }
@ -20,7 +20,7 @@ list_t *list_create(void) {
return list; return list;
} }
static bool list_resize(list_t *list) { static bool list_resize(struct wlr_list *list) {
if (list->length == list->capacity) { if (list->length == list->capacity) {
void *new_items = realloc(list->items, sizeof(void*) * (list->capacity + 10)); void *new_items = realloc(list->items, sizeof(void*) * (list->capacity + 10));
if (!new_items) { if (!new_items) {
@ -32,7 +32,7 @@ static bool list_resize(list_t *list) {
return true; return true;
} }
void list_free(list_t *list) { void list_free(struct wlr_list *list) {
if (list == NULL) { if (list == NULL) {
return; return;
} }
@ -40,7 +40,7 @@ void list_free(list_t *list) {
free(list); free(list);
} }
void list_foreach(list_t *list, void (*callback)(void *item)) { void list_foreach(struct wlr_list *list, void (*callback)(void *item)) {
if (list == NULL || callback == NULL) { if (list == NULL || callback == NULL) {
return; return;
} }
@ -49,7 +49,7 @@ void list_foreach(list_t *list, void (*callback)(void *item)) {
} }
} }
int list_add(list_t *list, void *item) { int list_add(struct wlr_list *list, void *item) {
if (!list_resize(list)) { if (!list_resize(list)) {
return -1; return -1;
} }
@ -57,11 +57,11 @@ int list_add(list_t *list, void *item) {
return list->length; return list->length;
} }
int list_push(list_t *list, void *item) { int list_push(struct wlr_list *list, void *item) {
return list_add(list, item); return list_add(list, item);
} }
int list_insert(list_t *list, size_t index, void *item) { int list_insert(struct wlr_list *list, size_t index, void *item) {
if (!list_resize(list)) { if (!list_resize(list)) {
return -1; return -1;
} }
@ -71,22 +71,22 @@ int list_insert(list_t *list, size_t index, void *item) {
return list->length; return list->length;
} }
void list_del(list_t *list, size_t index) { void list_del(struct wlr_list *list, size_t index) {
list->length--; list->length--;
memmove(&list->items[index], &list->items[index + 1], sizeof(void*) * (list->length - index)); memmove(&list->items[index], &list->items[index + 1], sizeof(void*) * (list->length - index));
} }
void *list_pop(list_t *list) { void *list_pop(struct wlr_list *list) {
void *_ = list->items[list->length - 1]; void *_ = list->items[list->length - 1];
list_del(list, list->length - 1); list_del(list, list->length - 1);
return _; return _;
} }
void *list_peek(list_t *list) { void *list_peek(struct wlr_list *list) {
return list->items[list->length - 1]; return list->items[list->length - 1];
} }
int list_cat(list_t *list, list_t *source) { int list_cat(struct wlr_list *list, struct wlr_list *source) {
size_t old_len = list->length; size_t old_len = list->length;
size_t i; size_t i;
for (i = 0; i < source->length; ++i) { for (i = 0; i < source->length; ++i) {
@ -98,11 +98,11 @@ int list_cat(list_t *list, list_t *source) {
return list->length; return list->length;
} }
void list_qsort(list_t *list, int compare(const void *left, const void *right)) { void list_qsort(struct wlr_list *list, int compare(const void *left, const void *right)) {
qsort(list->items, list->length, sizeof(void *), compare); qsort(list->items, list->length, sizeof(void *), compare);
} }
int list_seq_find(list_t *list, int list_seq_find(struct wlr_list *list,
int compare(const void *item, const void *data), int compare(const void *item, const void *data),
const void *data) { const void *data) {
for (size_t i = 0; i < list->length; i++) { for (size_t i = 0; i < list->length; i++) {

16
types/wlr_output.c
View file

@ -8,7 +8,7 @@
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_surface.h> #include <wlr/types/wlr_surface.h>
#include <wlr/interfaces/wlr_output.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/util/log.h>
#include <GLES2/gl2.h> #include <GLES2/gl2.h>
#include <wlr/render/matrix.h> #include <wlr/render/matrix.h>
@ -26,8 +26,8 @@ static void wl_output_send_to_resource(struct wl_resource *resource) {
output->make, output->model, output->transform); output->make, output->model, output->transform);
} }
if (version >= WL_OUTPUT_MODE_SINCE_VERSION) { if (version >= WL_OUTPUT_MODE_SINCE_VERSION) {
for (size_t i = 0; i < output->modes->length; ++i) { struct wlr_output_mode *mode;
struct wlr_output_mode *mode = output->modes->items[i]; wl_list_for_each(mode, &output->modes, link) {
// TODO: mode->flags should just be preferred // TODO: mode->flags should just be preferred
uint32_t flags = mode->flags; uint32_t flags = mode->flags;
if (output->current_mode == mode) { if (output->current_mode == mode) {
@ -37,7 +37,7 @@ static void wl_output_send_to_resource(struct wl_resource *resource) {
mode->width, mode->height, mode->refresh); 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 // Output has no mode, send the current width/height
wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT, wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT,
output->width, output->height, 0); output->width, output->height, 0);
@ -310,7 +310,7 @@ void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend,
const struct wlr_output_impl *impl) { const struct wlr_output_impl *impl) {
output->backend = backend; output->backend = backend;
output->impl = impl; output->impl = impl;
output->modes = list_create(); wl_list_init(&output->modes);
output->transform = WL_OUTPUT_TRANSFORM_NORMAL; output->transform = WL_OUTPUT_TRANSFORM_NORMAL;
output->scale = 1; output->scale = 1;
wl_signal_init(&output->events.frame); wl_signal_init(&output->events.frame);
@ -334,11 +334,11 @@ void wlr_output_destroy(struct wlr_output *output) {
wlr_texture_destroy(output->cursor.texture); wlr_texture_destroy(output->cursor.texture);
wlr_renderer_destroy(output->cursor.renderer); wlr_renderer_destroy(output->cursor.renderer);
for (size_t i = 0; output->modes && i < output->modes->length; ++i) { struct wlr_output_mode *mode, *tmp_mode;
struct wlr_output_mode *mode = output->modes->items[i]; wl_list_for_each_safe(mode, tmp_mode, &output->modes, link) {
free(mode); free(mode);
} }
list_free(output->modes); wl_list_remove(&output->modes);
if (output->impl && output->impl->destroy) { if (output->impl && output->impl->destroy) {
output->impl->destroy(output); output->impl->destroy(output);
} else { } else {

1
util/meson.build
View file

@ -1,7 +1,6 @@
lib_wlr_util = static_library( lib_wlr_util = static_library(
'wlr_util', 'wlr_util',
files( files(
'list.c',
'log.c', 'log.c',
), ),
include_directories: wlr_inc, include_directories: wlr_inc,