blankie
/
wlroots
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #298 from raazvvann/heghe/wl_list 

Replace list_t with wl_list
This commit is contained in:
Drew DeVault 2017-10-21 22:07:44 -04:00 committed by GitHub
parent d4e311a1ad 16f35ecbea
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;

8
rootston/output.c
View File

@ -166,9 +166,11 @@ 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));
clock_gettime(CLOCK_MONOTONIC, &output->last_frame); clock_gettime(CLOCK_MONOTONIC, &output->last_frame);

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,