From ab733d76e50f0855811a99b88357c356fd1d404f Mon Sep 17 00:00:00 2001 From: Armin Novak Date: Wed, 19 Oct 2016 11:05:12 +0200 Subject: [PATCH] Fixed NULL pointer dereferences. --- uwac/libuwac/uwac-display.c | 405 +++++++++++++++++++++------------- uwac/libuwac/uwac-window.c | 429 +++++++++++++++++++++--------------- 2 files changed, 507 insertions(+), 327 deletions(-) diff --git a/uwac/libuwac/uwac-display.c b/uwac/libuwac/uwac-display.c index b44172ac1..49c605972 100644 --- a/uwac/libuwac/uwac-display.c +++ b/uwac/libuwac/uwac-display.c @@ -41,7 +41,8 @@ #define TARGET_SEAT_INTERFACE 5 #define TARGET_XDG_VERSION 5 /* The version of xdg-shell that we implement */ -static const char *event_names[] = { +static const char* event_names[] = +{ "new seat", "removed seat", "new output", @@ -64,17 +65,18 @@ static const char *event_names[] = { NULL }; -bool uwac_default_error_handler(UwacDisplay *display, UwacReturnCode code, const char *msg, ...) { +bool uwac_default_error_handler(UwacDisplay* display, UwacReturnCode code, const char* msg, ...) +{ va_list args; va_start(args, msg); - vfprintf(stderr, "%s", args); return false; } UwacErrorHandler uwacErrorHandler = uwac_default_error_handler; -void UwacInstallErrorHandler(UwacErrorHandler handler) { +void UwacInstallErrorHandler(UwacErrorHandler handler) +{ if (handler) uwacErrorHandler = handler; else @@ -82,225 +84,274 @@ void UwacInstallErrorHandler(UwacErrorHandler handler) { } -static void cb_shm_format(void *data, struct wl_shm *wl_shm, uint32_t format) +static void cb_shm_format(void* data, struct wl_shm* wl_shm, uint32_t format) { - UwacDisplay *d = data; + UwacDisplay* d = data; if (format == WL_SHM_FORMAT_RGB565) d->has_rgb565 = true; d->shm_formats_nb++; - d->shm_formats = xrealloc((void *)d->shm_formats, sizeof(enum wl_shm_format) * d->shm_formats_nb); + d->shm_formats = xrealloc((void*)d->shm_formats, sizeof(enum wl_shm_format) * d->shm_formats_nb); d->shm_formats[d->shm_formats_nb - 1] = format; } -struct wl_shm_listener shm_listener = { +struct wl_shm_listener shm_listener = +{ cb_shm_format }; -static void xdg_shell_ping(void *data, struct xdg_shell *shell, uint32_t serial) +static void xdg_shell_ping(void* data, struct xdg_shell* shell, uint32_t serial) { xdg_shell_pong(shell, serial); } -static const struct xdg_shell_listener xdg_shell_listener = { +static const struct xdg_shell_listener xdg_shell_listener = +{ xdg_shell_ping, }; #ifdef BUILD_FULLSCREEN_SHELL -static void fullscreen_capability(void *data, struct _wl_fullscreen_shell *_wl_fullscreen_shell, - uint32_t capabilty) +static void fullscreen_capability(void* data, struct _wl_fullscreen_shell* _wl_fullscreen_shell, + uint32_t capabilty) { } -static const struct _wl_fullscreen_shell_listener fullscreen_shell_listener = { - fullscreen_capability, +static const struct _wl_fullscreen_shell_listener fullscreen_shell_listener = +{ + fullscreen_capability, }; #endif -static UwacSeat *display_destroy_seat(UwacDisplay *d, uint32_t name) +static UwacSeat* display_destroy_seat(UwacDisplay* d, uint32_t name) { - UwacSeat *seat; - - wl_list_for_each(seat, &d->seats, link) { - if (seat->seat_id == name) { + UwacSeat* seat; + wl_list_for_each(seat, &d->seats, link) + { + if (seat->seat_id == name) + { UwacSeatDestroy(seat); return seat; } } - return NULL; } -static void registry_handle_global(void *data, struct wl_registry *registry, uint32_t id, - const char *interface, uint32_t version) +static void registry_handle_global(void* data, struct wl_registry* registry, uint32_t id, + const char* interface, uint32_t version) { - UwacDisplay *d = data; - UwacGlobal *global; - - global = xmalloc(sizeof *global); + UwacDisplay* d = data; + UwacGlobal* global; + global = xmalloc(sizeof * global); global->name = id; global->interface = xstrdup(interface); global->version = version; wl_list_insert(d->globals.prev, &global->link); - if (strcmp(interface, "wl_compositor") == 0) { - d->compositor = wl_registry_bind(registry, id, &wl_compositor_interface, min(TARGET_COMPOSITOR_INTERFACE, version)); - } else if (strcmp(interface, "wl_shm") == 0) { + if (strcmp(interface, "wl_compositor") == 0) + { + d->compositor = wl_registry_bind(registry, id, &wl_compositor_interface, + min(TARGET_COMPOSITOR_INTERFACE, version)); + } + else if (strcmp(interface, "wl_shm") == 0) + { d->shm = wl_registry_bind(registry, id, &wl_shm_interface, min(TARGET_SHM_INTERFACE, version)); wl_shm_add_listener(d->shm, &shm_listener, d); - } else if (strcmp(interface, "wl_output") == 0) { - UwacOutput *output; - UwacOutputNewEvent *ev; - + } + else if (strcmp(interface, "wl_output") == 0) + { + UwacOutput* output; + UwacOutputNewEvent* ev; output = UwacCreateOutput(d, id, version); - if (!output) { + + if (!output) + { assert(uwacErrorHandler(d, UWAC_ERROR_NOMEMORY, "unable to create output\n")); return; } - ev = (UwacOutputNewEvent *)UwacDisplayNewEvent(d, UWAC_EVENT_NEW_OUTPUT); + ev = (UwacOutputNewEvent*)UwacDisplayNewEvent(d, UWAC_EVENT_NEW_OUTPUT); + if (ev) ev->output = output; - - } else if (strcmp(interface, "wl_seat") == 0) { - UwacSeatNewEvent *ev; - UwacSeat *seat; - + } + else if (strcmp(interface, "wl_seat") == 0) + { + UwacSeatNewEvent* ev; + UwacSeat* seat; seat = UwacSeatNew(d, id, min(version, TARGET_SEAT_INTERFACE)); - if (!seat) { + + if (!seat) + { assert(uwacErrorHandler(d, UWAC_ERROR_NOMEMORY, "unable to create new seat\n")); return; } - ev = (UwacSeatNewEvent *)UwacDisplayNewEvent(d, UWAC_EVENT_NEW_SEAT); - if (!ev) { + ev = (UwacSeatNewEvent*)UwacDisplayNewEvent(d, UWAC_EVENT_NEW_SEAT); + + if (!ev) + { assert(uwacErrorHandler(d, UWAC_ERROR_NOMEMORY, "unable to create new seat event\n")); return; } ev->seat = seat; - } else if (strcmp(interface, "wl_data_device_manager") == 0) { - d->data_device_manager = wl_registry_bind(registry, id, &wl_data_device_manager_interface, min(TARGET_DDM_INTERFACE, version)); - } else if (strcmp(interface, "wl_shell") == 0) { - d->shell = wl_registry_bind(registry, id, &wl_shell_interface, min(TARGET_SHELL_INTERFACE, version)); - } else if (strcmp(interface, "xdg_shell") == 0) { + } + else if (strcmp(interface, "wl_data_device_manager") == 0) + { + d->data_device_manager = wl_registry_bind(registry, id, &wl_data_device_manager_interface, + min(TARGET_DDM_INTERFACE, version)); + } + else if (strcmp(interface, "wl_shell") == 0) + { + d->shell = wl_registry_bind(registry, id, &wl_shell_interface, min(TARGET_SHELL_INTERFACE, + version)); + } + else if (strcmp(interface, "xdg_shell") == 0) + { d->xdg_shell = wl_registry_bind(registry, id, &xdg_shell_interface, 1); xdg_shell_use_unstable_version(d->xdg_shell, TARGET_XDG_VERSION); xdg_shell_add_listener(d->xdg_shell, &xdg_shell_listener, d); #if BUILD_IVI - } else if (strcmp(interface, "ivi_application") == 0) { + } + else if (strcmp(interface, "ivi_application") == 0) + { d->ivi_application = wl_registry_bind(registry, id, &ivi_application_interface, 1); #endif #if BUILD_FULLSCREEN_SHELL - } else if (strcmp(interface, "_wl_fullscreen_shell") == 0) { + } + else if (strcmp(interface, "_wl_fullscreen_shell") == 0) + { d->fullscreen_shell = wl_registry_bind(registry, id, &_wl_fullscreen_shell_interface, 1); _wl_fullscreen_shell_add_listener(d->fullscreen_shell, &fullscreen_shell_listener, d); #endif #if 0 - } else if (strcmp(interface, "text_cursor_position") == 0) { + } + else if (strcmp(interface, "text_cursor_position") == 0) + { d->text_cursor_position = wl_registry_bind(registry, id, &text_cursor_position_interface, 1); - } else if (strcmp(interface, "workspace_manager") == 0) { + } + else if (strcmp(interface, "workspace_manager") == 0) + { //init_workspace_manager(d, id); - } else if (strcmp(interface, "wl_subcompositor") == 0) { + } + else if (strcmp(interface, "wl_subcompositor") == 0) + { d->subcompositor = wl_registry_bind(registry, id, &wl_subcompositor_interface, 1); #endif } } -static void registry_handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) { - UwacDisplay *d = data; - UwacGlobal *global; - UwacGlobal *tmp; - - wl_list_for_each_safe(global, tmp, &d->globals, link) { +static void registry_handle_global_remove(void* data, struct wl_registry* registry, uint32_t name) +{ + UwacDisplay* d = data; + UwacGlobal* global; + UwacGlobal* tmp; + wl_list_for_each_safe(global, tmp, &d->globals, link) + { if (global->name != name) continue; #if 0 + if (strcmp(global->interface, "wl_output") == 0) display_destroy_output(d, name); + #endif - if (strcmp(global->interface, "wl_seat") == 0) { - UwacSeatRemovedEvent *ev; - UwacSeat *seat; - + if (strcmp(global->interface, "wl_seat") == 0) + { + UwacSeatRemovedEvent* ev; + UwacSeat* seat; seat = display_destroy_seat(d, name); - ev = (UwacSeatRemovedEvent *)UwacDisplayNewEvent(d, UWAC_EVENT_REMOVED_SEAT); + ev = (UwacSeatRemovedEvent*)UwacDisplayNewEvent(d, UWAC_EVENT_REMOVED_SEAT); + if (ev) ev->seat = seat; } - wl_list_remove(&global->link); free(global->interface); free(global); } } -void UwacDestroyGlobal(UwacGlobal *global) { +void UwacDestroyGlobal(UwacGlobal* global) +{ free(global->interface); wl_list_remove(&global->link); free(global); } -void *display_bind(UwacDisplay *display, uint32_t name, const struct wl_interface *interface, uint32_t version) { +void* display_bind(UwacDisplay* display, uint32_t name, const struct wl_interface* interface, + uint32_t version) +{ return wl_registry_bind(display->registry, name, interface, version); } -static const struct wl_registry_listener registry_listener = { +static const struct wl_registry_listener registry_listener = +{ registry_handle_global, registry_handle_global_remove }; -int UwacDisplayWatchFd(UwacDisplay *display, int fd, uint32_t events, UwacTask *task) { +int UwacDisplayWatchFd(UwacDisplay* display, int fd, uint32_t events, UwacTask* task) +{ struct epoll_event ep; - ep.events = events; ep.data.ptr = task; return epoll_ctl(display->epoll_fd, EPOLL_CTL_ADD, fd, &ep); } -void UwacDisplayUnwatchFd(UwacDisplay *display, int fd) { +void UwacDisplayUnwatchFd(UwacDisplay* display, int fd) +{ epoll_ctl(display->epoll_fd, EPOLL_CTL_DEL, fd, NULL); } -static void display_exit(UwacDisplay *display) { +static void display_exit(UwacDisplay* display) +{ display->running = false; } -static void display_dispatch_events(UwacTask *task, uint32_t events) +static void display_dispatch_events(UwacTask* task, uint32_t events) { - UwacDisplay *display = container_of(task, UwacDisplay, dispatch_fd_task); + UwacDisplay* display = container_of(task, UwacDisplay, dispatch_fd_task); struct epoll_event ep; int ret; - display->display_fd_events = events; - if ((events & EPOLLERR) || (events & EPOLLHUP)) { + if ((events & EPOLLERR) || (events & EPOLLHUP)) + { display_exit(display); return; } - if (events & EPOLLIN) { + if (events & EPOLLIN) + { ret = wl_display_dispatch(display->display); - if (ret == -1) { + + if (ret == -1) + { display_exit(display); return; } } - if (events & EPOLLOUT) { + if (events & EPOLLOUT) + { ret = wl_display_flush(display->display); - if (ret == 0) { + + if (ret == 0) + { ep.events = EPOLLIN | EPOLLERR | EPOLLHUP; ep.data.ptr = &display->dispatch_fd_task; epoll_ctl(display->epoll_fd, EPOLL_CTL_MOD, display->display_fd, &ep); - } else if (ret == -1 && errno != EAGAIN) { + } + else if (ret == -1 && errno != EAGAIN) + { display_exit(display); return; } @@ -308,11 +359,13 @@ static void display_dispatch_events(UwacTask *task, uint32_t events) } -UwacDisplay *UwacOpenDisplay(const char *name, UwacReturnCode *err) { - UwacDisplay *ret; +UwacDisplay* UwacOpenDisplay(const char* name, UwacReturnCode* err) +{ + UwacDisplay* ret; + ret = (UwacDisplay*)calloc(1, sizeof(*ret)); - ret = (UwacDisplay *)calloc(1, sizeof(*ret)); - if (!ret) { + if (!ret) + { *err = UWAC_ERROR_NOMEMORY; return NULL; } @@ -321,38 +374,46 @@ UwacDisplay *UwacOpenDisplay(const char *name, UwacReturnCode *err) { wl_list_init(&ret->seats); wl_list_init(&ret->outputs); wl_list_init(&ret->windows); - ret->display = wl_display_connect(name); - if (ret->display == NULL) { + + if (ret->display == NULL) + { fprintf(stderr, "failed to connect to Wayland display %s: %m\n", name); *err = UWAC_ERROR_UNABLE_TO_CONNECT; goto out_free; } ret->epoll_fd = uwac_os_epoll_create_cloexec(); - if (ret->epoll_fd < 0) { + + if (ret->epoll_fd < 0) + { *err = UWAC_NOT_ENOUGH_RESOURCES; goto out_disconnect; } ret->display_fd = wl_display_get_fd(ret->display); - ret->registry = wl_display_get_registry(ret->display); - if (!ret->registry) { + + if (!ret->registry) + { *err = UWAC_ERROR_NOMEMORY; goto out_close_epoll; } wl_registry_add_listener(ret->registry, ®istry_listener, ret); - if ((wl_display_roundtrip(ret->display) < 0) || (wl_display_roundtrip(ret->display) < 0)) { + if ((wl_display_roundtrip(ret->display) < 0) || (wl_display_roundtrip(ret->display) < 0)) + { uwacErrorHandler(ret, UWAC_ERROR_UNABLE_TO_CONNECT, "Failed to process Wayland connection: %m\n"); *err = UWAC_ERROR_UNABLE_TO_CONNECT; goto out_free_registry; } ret->dispatch_fd_task.run = display_dispatch_events; - if (UwacDisplayWatchFd(ret, ret->display_fd, EPOLLIN | EPOLLERR | EPOLLHUP, &ret->dispatch_fd_task) < 0) { + + if (UwacDisplayWatchFd(ret, ret->display_fd, EPOLLIN | EPOLLERR | EPOLLHUP, + &ret->dispatch_fd_task) < 0) + { uwacErrorHandler(ret, UWAC_ERROR_INTERNAL, "unable to watch display fd: %m\n"); *err = UWAC_ERROR_INTERNAL; goto out_free_registry; @@ -361,7 +422,6 @@ UwacDisplay *UwacOpenDisplay(const char *name, UwacReturnCode *err) { ret->running = true; ret->last_error = *err = UWAC_SUCCESS; return ret; - out_free_registry: wl_registry_destroy(ret->registry); out_close_epoll: @@ -373,28 +433,33 @@ out_free: return NULL; } -int UwacDisplayDispatch(UwacDisplay *display, int timeout) { +int UwacDisplayDispatch(UwacDisplay* display, int timeout) +{ int ret, count, i; - UwacTask *task; + UwacTask* task; struct epoll_event ep[16]; - wl_display_dispatch_pending(display->display); if (!display->running) return 0; ret = wl_display_flush(display->display); - if (ret < 0 && errno == EAGAIN) { + + if (ret < 0 && errno == EAGAIN) + { ep[0].events = (EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLHUP); ep[0].data.ptr = &display->dispatch_fd_task; - epoll_ctl(display->epoll_fd, EPOLL_CTL_MOD, display->display_fd, &ep[0]); - } else if (ret < 0) { + } + else if (ret < 0) + { return -1; } count = epoll_wait(display->epoll_fd, ep, ARRAY_LENGTH(ep), timeout); - for (i = 0; i < count; i++) { + + for (i = 0; i < count; i++) + { task = ep[i].data.ptr; task->run(task, ep[i].events); } @@ -404,74 +469,85 @@ int UwacDisplayDispatch(UwacDisplay *display, int timeout) { -UwacReturnCode UwacDisplayGetLastError(const UwacDisplay *display) { +UwacReturnCode UwacDisplayGetLastError(const UwacDisplay* display) +{ return display->last_error; } -UwacReturnCode UwacCloseDisplay(UwacDisplay **pdisplay) { - UwacDisplay *display; - UwacSeat *seat, *tmpSeat; - UwacWindow *window, *tmpWindow; - UwacOutput *output, *tmpOutput; - UwacGlobal *global, *tmpGlobal; - +UwacReturnCode UwacCloseDisplay(UwacDisplay** pdisplay) +{ + UwacDisplay* display; + UwacSeat* seat, *tmpSeat; + UwacWindow* window, *tmpWindow; + UwacOutput* output, *tmpOutput; + UwacGlobal* global, *tmpGlobal; assert(pdisplay); display = *pdisplay; + if (!display) return UWAC_ERROR_INVALID_DISPLAY; /* destroy windows */ - wl_list_for_each_safe(window, tmpWindow, &display->windows, link) { + wl_list_for_each_safe(window, tmpWindow, &display->windows, link) + { UwacDestroyWindow(&window); } - /* destroy seats */ - wl_list_for_each_safe(seat, tmpSeat, &display->seats, link) { + wl_list_for_each_safe(seat, tmpSeat, &display->seats, link) + { UwacSeatDestroy(seat); } - /* destroy output */ - wl_list_for_each_safe(output, tmpOutput, &display->outputs, link) { + wl_list_for_each_safe(output, tmpOutput, &display->outputs, link) + { UwacDestroyOutput(output); } - /* destroy globals */ - wl_list_for_each_safe(global, tmpGlobal, &display->globals, link) { + wl_list_for_each_safe(global, tmpGlobal, &display->globals, link) + { UwacDestroyGlobal(global); } if (display->compositor) wl_compositor_destroy(display->compositor); + #ifdef BUILD_FULLSCREEN_SHELL + if (display->fullscreen_shell) _wl_fullscreen_shell_destroy(display->fullscreen_shell); + #endif #ifdef BUILD_IVI + if (display->ivi_application) ivi_application_destroy(display->ivi_application); + #endif + if (display->xdg_shell) xdg_shell_destroy(display->xdg_shell); + if (display->shell) wl_shell_destroy(display->shell); + if (display->shm) wl_shm_destroy(display->shm); + if (display->subcompositor) wl_subcompositor_destroy(display->subcompositor); + if (display->data_device_manager) wl_data_device_manager_destroy(display->data_device_manager); free(display->shm_formats); wl_registry_destroy(display->registry); - close(display->epoll_fd); - wl_display_disconnect(display->display); /* cleanup the event queue */ - while (display->push_queue) { - UwacEventListItem *item = display->push_queue; - + while (display->push_queue) + { + UwacEventListItem* item = display->push_queue; display->push_queue = item->tail; free(item); } @@ -481,11 +557,13 @@ UwacReturnCode UwacCloseDisplay(UwacDisplay **pdisplay) { return UWAC_SUCCESS; } -int UwacDisplayGetFd(UwacDisplay *display) { +int UwacDisplayGetFd(UwacDisplay* display) +{ return display->epoll_fd; } -static const char *errorStrings[] = { +static const char* errorStrings[] = +{ "success", "out of memory error", "unable to connect to wayland display", @@ -498,37 +576,44 @@ static const char *errorStrings[] = { "internal error", }; -const char *UwacErrorString(UwacReturnCode error) { +const char* UwacErrorString(UwacReturnCode error) +{ if (error < UWAC_SUCCESS || error >= UWAC_ERROR_LAST) return "invalid error code"; return errorStrings[error]; } -UwacReturnCode UwacDisplayQueryInterfaceVersion(const UwacDisplay *display, const char *name, uint32_t *version) { - const UwacGlobal *global; +UwacReturnCode UwacDisplayQueryInterfaceVersion(const UwacDisplay* display, const char* name, + uint32_t* version) +{ + const UwacGlobal* global; if (!display) return UWAC_ERROR_INVALID_DISPLAY; - wl_list_for_each(global, &display->globals, link) { - if (strcmp(global->interface, name) == 0) { + wl_list_for_each(global, &display->globals, link) + { + if (strcmp(global->interface, name) == 0) + { if (version) *version = global->version; + return UWAC_SUCCESS; } } - return UWAC_NOT_FOUND; } -uint32_t UwacDisplayQueryGetNbShmFormats(UwacDisplay *display) { - if (!display) { - display->last_error = UWAC_ERROR_INVALID_DISPLAY; +uint32_t UwacDisplayQueryGetNbShmFormats(UwacDisplay* display) +{ + if (!display) + { return 0; } - if (!display->shm) { + if (!display->shm) + { display->last_error = UWAC_NOT_FOUND; return 0; } @@ -538,28 +623,35 @@ uint32_t UwacDisplayQueryGetNbShmFormats(UwacDisplay *display) { } -UwacReturnCode UwacDisplayQueryShmFormats(const UwacDisplay *display, enum wl_shm_format *formats, int formats_size, int *filled) { +UwacReturnCode UwacDisplayQueryShmFormats(const UwacDisplay* display, enum wl_shm_format* formats, + int formats_size, int* filled) +{ if (!display) return UWAC_ERROR_INVALID_DISPLAY; *filled = min(display->shm_formats_nb, formats_size); - memcpy(formats, (const void *)display->shm_formats, *filled * sizeof(enum wl_shm_format)); - + memcpy(formats, (const void*)display->shm_formats, *filled * sizeof(enum wl_shm_format)); return UWAC_SUCCESS; } -uint32_t UwacDisplayGetNbOutputs(UwacDisplay *display) { +uint32_t UwacDisplayGetNbOutputs(UwacDisplay* display) +{ return wl_list_length(&display->outputs); } -UwacOutput *UwacDisplayGetOutput(UwacDisplay *display, int index) { - struct wl_list *l; +UwacOutput* UwacDisplayGetOutput(UwacDisplay* display, int index) +{ + struct wl_list* l; int i; + if (!display) + return NULL; + for (i = 0, l = &display->outputs; l && i < index; i++, l = l->next) ; - if (!l) { + if (!l) + { display->last_error = UWAC_NOT_FOUND; return NULL; } @@ -568,51 +660,62 @@ UwacOutput *UwacDisplayGetOutput(UwacDisplay *display, int index) { return container_of(l, UwacOutput, link); } -UwacReturnCode UwacOutputGetResolution(UwacOutput *output, UwacSize *resolution) { +UwacReturnCode UwacOutputGetResolution(UwacOutput* output, UwacSize* resolution) +{ *resolution = output->resolution; return UWAC_SUCCESS; } -UwacEvent *UwacDisplayNewEvent(UwacDisplay *display, int type) { - UwacEventListItem *ret; +UwacEvent* UwacDisplayNewEvent(UwacDisplay* display, int type) +{ + UwacEventListItem* ret; - if (!display) { - display->last_error = UWAC_ERROR_INVALID_DISPLAY; + if (!display) + { return 0; } ret = zalloc(sizeof(UwacEventListItem)); - if (!ret) { - assert(uwacErrorHandler(display, UWAC_ERROR_NOMEMORY, "unable to allocate a '%s' event", event_names[type])); + + if (!ret) + { + assert(uwacErrorHandler(display, UWAC_ERROR_NOMEMORY, "unable to allocate a '%s' event", + event_names[type])); display->last_error = UWAC_ERROR_NOMEMORY; return 0; } ret->event.type = type; ret->tail = display->push_queue; + if (ret->tail) ret->tail->head = ret; else display->pop_queue = ret; + display->push_queue = ret; return &ret->event; } -bool UwacHasEvent(UwacDisplay *display) { +bool UwacHasEvent(UwacDisplay* display) +{ return display->pop_queue != NULL; } -UwacReturnCode UwacNextEvent(UwacDisplay *display, UwacEvent *event) { - UwacEventListItem *prevItem; +UwacReturnCode UwacNextEvent(UwacDisplay* display, UwacEvent* event) +{ + UwacEventListItem* prevItem; int ret; if (!display) return UWAC_ERROR_INVALID_DISPLAY; - while (!display->pop_queue) { + while (!display->pop_queue) + { ret = UwacDisplayDispatch(display, 1 * 1000); + if (ret < 0) return UWAC_ERROR_INTERNAL; else if (ret == 0) @@ -623,9 +726,11 @@ UwacReturnCode UwacNextEvent(UwacDisplay *display, UwacEvent *event) { *event = display->pop_queue->event; free(display->pop_queue); display->pop_queue = prevItem; + if (prevItem) prevItem->tail = NULL; else display->push_queue = NULL; + return UWAC_SUCCESS; } diff --git a/uwac/libuwac/uwac-window.c b/uwac/libuwac/uwac-window.c index fcc408fef..7574dc38c 100644 --- a/uwac/libuwac/uwac-window.c +++ b/uwac/libuwac/uwac-window.c @@ -35,31 +35,36 @@ #define UWAC_INITIAL_BUFFERS 3 -static int bppFromShmFormat(enum wl_shm_format format) { - switch (format) { - case WL_SHM_FORMAT_ARGB8888: - case WL_SHM_FORMAT_XRGB8888: - default: - return 4; +static int bppFromShmFormat(enum wl_shm_format format) +{ + switch (format) + { + case WL_SHM_FORMAT_ARGB8888: + case WL_SHM_FORMAT_XRGB8888: + default: + return 4; } } -static void buffer_release(void *data, struct wl_buffer *buffer) { - UwacBuffer *uwacBuffer = (UwacBuffer *)data; - +static void buffer_release(void* data, struct wl_buffer* buffer) +{ + UwacBuffer* uwacBuffer = (UwacBuffer*)data; uwacBuffer->used = false; } -static const struct wl_buffer_listener buffer_listener = { +static const struct wl_buffer_listener buffer_listener = +{ buffer_release }; -void UwacWindowDestroyBuffers(UwacWindow *w) { +void UwacWindowDestroyBuffers(UwacWindow* w) +{ int i; - for (i = 0; i < w->nbuffers; i++) { - UwacBuffer *buffer = &w->buffers[i]; + for (i = 0; i < w->nbuffers; i++) + { + UwacBuffer* buffer = &w->buffers[i]; #ifdef HAVE_PIXMAN_REGION pixman_region32_fini(&buffer->damage); #else @@ -74,67 +79,77 @@ void UwacWindowDestroyBuffers(UwacWindow *w) { } -int UwacWindowShmAllocBuffers(UwacWindow *w, int nbuffers, int allocSize, uint32_t width, - uint32_t height, enum wl_shm_format format); +int UwacWindowShmAllocBuffers(UwacWindow* w, int nbuffers, int allocSize, uint32_t width, + uint32_t height, enum wl_shm_format format); -static void xdg_handle_configure(void *data, struct xdg_surface *surface, - int32_t width, int32_t height, - struct wl_array *states, uint32_t serial) +static void xdg_handle_configure(void* data, struct xdg_surface* surface, + int32_t width, int32_t height, + struct wl_array* states, uint32_t serial) { - UwacWindow *window = (UwacWindow *)data; - UwacConfigureEvent *event; + UwacWindow* window = (UwacWindow*)data; + UwacConfigureEvent* event; int ret, surfaceState; - enum xdg_surface_state *state; - + enum xdg_surface_state* state; surfaceState = 0; - wl_array_for_each(state, states) { - switch (*state) { - case XDG_SURFACE_STATE_MAXIMIZED: - surfaceState |= UWAC_WINDOW_MAXIMIZED; - break; - case XDG_SURFACE_STATE_FULLSCREEN: - surfaceState |= UWAC_WINDOW_FULLSCREEN; - break; - case XDG_SURFACE_STATE_ACTIVATED: - surfaceState |= UWAC_WINDOW_ACTIVATED; - break; - case XDG_SURFACE_STATE_RESIZING: - surfaceState |= UWAC_WINDOW_RESIZING; - break; - default: - break; + wl_array_for_each(state, states) + { + switch (*state) + { + case XDG_SURFACE_STATE_MAXIMIZED: + surfaceState |= UWAC_WINDOW_MAXIMIZED; + break; + + case XDG_SURFACE_STATE_FULLSCREEN: + surfaceState |= UWAC_WINDOW_FULLSCREEN; + break; + + case XDG_SURFACE_STATE_ACTIVATED: + surfaceState |= UWAC_WINDOW_ACTIVATED; + break; + + case XDG_SURFACE_STATE_RESIZING: + surfaceState |= UWAC_WINDOW_RESIZING; + break; + + default: + break; } } - window->surfaceStates = surfaceState; + event = (UwacConfigureEvent*)UwacDisplayNewEvent(window->display, UWAC_EVENT_CONFIGURE); - event = (UwacConfigureEvent *)UwacDisplayNewEvent(window->display, UWAC_EVENT_CONFIGURE); - if(!event) { - assert(uwacErrorHandler(window->display, UWAC_ERROR_NOMEMORY, "failed to allocate a configure event\n")); + if (!event) + { + assert(uwacErrorHandler(window->display, UWAC_ERROR_NOMEMORY, + "failed to allocate a configure event\n")); goto ack; } event->window = window; event->states = surfaceState; - if (width && height) { + + if (width && height) + { event->width = width; event->height = height; - UwacWindowDestroyBuffers(window); - window->width = width; window->stride = width * bppFromShmFormat(window->format); window->height = height; - ret = UwacWindowShmAllocBuffers(window, UWAC_INITIAL_BUFFERS, window->stride * height, - width, height, window->format); - if (ret != UWAC_SUCCESS) { + width, height, window->format); + + if (ret != UWAC_SUCCESS) + { assert(uwacErrorHandler(window->display, ret, "failed to reallocate a wayland buffers\n")); window->drawingBuffer = window->pendingBuffer = NULL; goto ack; } + window->drawingBuffer = window->pendingBuffer = &window->buffers[0]; - } else { + } + else + { event->width = window->width; event->height = window->height; } @@ -143,198 +158,221 @@ ack: xdg_surface_ack_configure(surface, serial); } -static void xdg_handle_close(void *data, struct xdg_surface *xdg_surface) +static void xdg_handle_close(void* data, struct xdg_surface* xdg_surface) { - UwacCloseEvent *event; - UwacWindow *window = (UwacWindow *)data; + UwacCloseEvent* event; + UwacWindow* window = (UwacWindow*)data; + event = (UwacCloseEvent*)UwacDisplayNewEvent(window->display, UWAC_EVENT_CLOSE); - event = (UwacCloseEvent *)UwacDisplayNewEvent(window->display, UWAC_EVENT_CLOSE); - if(!event) { - assert(uwacErrorHandler(window->display, UWAC_ERROR_INTERNAL, "failed to allocate a close event\n")); + if (!event) + { + assert(uwacErrorHandler(window->display, UWAC_ERROR_INTERNAL, + "failed to allocate a close event\n")); return; } event->window = window; } -static const struct xdg_surface_listener xdg_surface_listener = { +static const struct xdg_surface_listener xdg_surface_listener = +{ xdg_handle_configure, xdg_handle_close, }; #if BUILD_IVI -static void ivi_handle_configure(void *data, struct ivi_surface *surface, - int32_t width, int32_t height) +static void ivi_handle_configure(void* data, struct ivi_surface* surface, + int32_t width, int32_t height) { - UwacWindow *window = (UwacWindow *)data; - UwacConfigureEvent *event; + UwacWindow* window = (UwacWindow*)data; + UwacConfigureEvent* event; int ret; + event = (UwacConfigureEvent*)UwacDisplayNewEvent(window->display, UWAC_EVENT_CONFIGURE); - - event = (UwacConfigureEvent *)UwacDisplayNewEvent(window->display, UWAC_EVENT_CONFIGURE); - if(!event) { - assert(uwacErrorHandler(window->display, UWAC_ERROR_NOMEMORY, "failed to allocate a configure event\n")); + if (!event) + { + assert(uwacErrorHandler(window->display, UWAC_ERROR_NOMEMORY, + "failed to allocate a configure event\n")); return; } event->window = window; event->states = 0; - if (width && height) { + + if (width && height) + { event->width = width; event->height = height; - UwacWindowDestroyBuffers(window); - window->width = width; window->stride = width * bppFromShmFormat(window->format); window->height = height; - ret = UwacWindowShmAllocBuffers(window, UWAC_INITIAL_BUFFERS, window->stride * height, - width, height, window->format); - if (ret != UWAC_SUCCESS) { + width, height, window->format); + + if (ret != UWAC_SUCCESS) + { assert(uwacErrorHandler(window->display, ret, "failed to reallocate a wayland buffers\n")); window->drawingBuffer = window->pendingBuffer = NULL; return; } + window->drawingBuffer = window->pendingBuffer = &window->buffers[0]; - } else { + } + else + { event->width = window->width; event->height = window->height; } } -static const struct ivi_surface_listener ivi_surface_listener = { +static const struct ivi_surface_listener ivi_surface_listener = +{ ivi_handle_configure, }; #endif -void shell_ping(void *data, struct wl_shell_surface *surface, uint32_t serial) +void shell_ping(void* data, struct wl_shell_surface* surface, uint32_t serial) { wl_shell_surface_pong(surface, serial); } -void shell_configure(void *data, struct wl_shell_surface *surface, uint32_t edges, - int32_t width, int32_t height) +void shell_configure(void* data, struct wl_shell_surface* surface, uint32_t edges, + int32_t width, int32_t height) { - UwacWindow *window = (UwacWindow *)data; - UwacConfigureEvent *event; + UwacWindow* window = (UwacWindow*)data; + UwacConfigureEvent* event; int ret; + event = (UwacConfigureEvent*)UwacDisplayNewEvent(window->display, UWAC_EVENT_CONFIGURE); - event = (UwacConfigureEvent *)UwacDisplayNewEvent(window->display, UWAC_EVENT_CONFIGURE); - if(!event) { - assert(uwacErrorHandler(window->display, UWAC_ERROR_NOMEMORY, "failed to allocate a configure event\n")); + if (!event) + { + assert(uwacErrorHandler(window->display, UWAC_ERROR_NOMEMORY, + "failed to allocate a configure event\n")); return; } event->window = window; event->states = 0; - if (width && height) { + + if (width && height) + { event->width = width; event->height = height; - UwacWindowDestroyBuffers(window); - window->width = width; window->stride = width * bppFromShmFormat(window->format); window->height = height; - ret = UwacWindowShmAllocBuffers(window, UWAC_INITIAL_BUFFERS, window->stride * height, - width, height, window->format); - if (ret != UWAC_SUCCESS) { + width, height, window->format); + + if (ret != UWAC_SUCCESS) + { assert(uwacErrorHandler(window->display, ret, "failed to reallocate a wayland buffers\n")); window->drawingBuffer = window->pendingBuffer = NULL; return; } + window->drawingBuffer = window->pendingBuffer = &window->buffers[0]; - } else { + } + else + { event->width = window->width; event->height = window->height; } - } -void shell_popup_done(void *data, struct wl_shell_surface *surface) +void shell_popup_done(void* data, struct wl_shell_surface* surface) { } -static const struct wl_shell_surface_listener shell_listener = { +static const struct wl_shell_surface_listener shell_listener = +{ shell_ping, shell_configure, shell_popup_done }; -int UwacWindowShmAllocBuffers(UwacWindow *w, int nbuffers, int allocSize, uint32_t width, - uint32_t height, enum wl_shm_format format) +int UwacWindowShmAllocBuffers(UwacWindow* w, int nbuffers, int allocSize, uint32_t width, + uint32_t height, enum wl_shm_format format) { int ret = UWAC_SUCCESS; - UwacBuffer *newBuffers; + UwacBuffer* newBuffers; int i, fd; - void *data; - struct wl_shm_pool *pool; - + void* data; + struct wl_shm_pool* pool; newBuffers = realloc(w->buffers, (w->nbuffers + nbuffers) * sizeof(UwacBuffer)); + if (!newBuffers) return UWAC_ERROR_NOMEMORY; w->buffers = newBuffers; - memset(w->buffers + w->nbuffers, 0, sizeof(UwacBuffer) * nbuffers); - fd = uwac_create_anonymous_file(allocSize * nbuffers); - if (fd < 0) { + + if (fd < 0) + { return UWAC_ERROR_INTERNAL; } data = mmap(NULL, allocSize * nbuffers, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); - if (data == MAP_FAILED) { + + if (data == MAP_FAILED) + { ret = UWAC_ERROR_NOMEMORY; goto error_mmap; } pool = wl_shm_create_pool(w->display->shm, fd, allocSize * nbuffers); - if (!pool) { + + if (!pool) + { ret = UWAC_ERROR_NOMEMORY; goto error_mmap; } - for (i = 0; i < nbuffers; i++) { - UwacBuffer *buffer = &w->buffers[w->nbuffers + i]; + for (i = 0; i < nbuffers; i++) + { + UwacBuffer* buffer = &w->buffers[w->nbuffers + i]; #ifdef HAVE_PIXMAN_REGION pixman_region32_init(&buffer->damage); #else region16_init(&buffer->damage); #endif buffer->data = data + (allocSize * i); - - buffer->wayland_buffer = wl_shm_pool_create_buffer(pool, allocSize * i, width, height, w->stride, format); + buffer->wayland_buffer = wl_shm_pool_create_buffer(pool, allocSize * i, width, height, w->stride, + format); wl_buffer_add_listener(buffer->wayland_buffer, &buffer_listener, buffer); - } wl_shm_pool_destroy(pool); w->nbuffers += nbuffers; - error_mmap: close(fd); return ret; } -UwacBuffer *UwacWindowFindFreeBuffer(UwacWindow *w) { +UwacBuffer* UwacWindowFindFreeBuffer(UwacWindow* w) +{ int i, ret; - for (i = 0; i < w->nbuffers; i++) { - if (!w->buffers[i].used) { + for (i = 0; i < w->nbuffers; i++) + { + if (!w->buffers[i].used) + { w->buffers[i].used = true; return &w->buffers[i]; } } ret = UwacWindowShmAllocBuffers(w, 2, w->stride * w->height, w->width, w->height, w->format); - if (ret != UWAC_SUCCESS) { + + if (ret != UWAC_SUCCESS) + { w->display->last_error = ret; return NULL; } @@ -344,17 +382,21 @@ UwacBuffer *UwacWindowFindFreeBuffer(UwacWindow *w) { } -UwacWindow *UwacCreateWindowShm(UwacDisplay *display, uint32_t width, uint32_t height, enum wl_shm_format format) { - UwacWindow *w; +UwacWindow* UwacCreateWindowShm(UwacDisplay* display, uint32_t width, uint32_t height, + enum wl_shm_format format) +{ + UwacWindow* w; int allocSize, ret; - if (!display) { - display->last_error = UWAC_ERROR_INVALID_DISPLAY; + if (!display) + { return NULL; } w = zalloc(sizeof(*w)); - if (!w) { + + if (!w) + { display->last_error = UWAC_ERROR_NOMEMORY; return NULL; } @@ -365,60 +407,65 @@ UwacWindow *UwacCreateWindowShm(UwacDisplay *display, uint32_t width, uint32_t h w->height = height; w->stride = width * bppFromShmFormat(format); allocSize = w->stride * height; - ret = UwacWindowShmAllocBuffers(w, UWAC_INITIAL_BUFFERS, allocSize, width, height, format); - if (ret != UWAC_SUCCESS) { + + if (ret != UWAC_SUCCESS) + { display->last_error = ret; goto out_error_free; } w->buffers[0].used = true; w->drawingBuffer = &w->buffers[0]; - w->surface = wl_compositor_create_surface(display->compositor); - if (!w->surface) { + + if (!w->surface) + { display->last_error = UWAC_ERROR_NOMEMORY; goto out_error_surface; } + wl_surface_set_user_data(w->surface, w); - if (display->xdg_shell) { + if (display->xdg_shell) + { w->xdg_surface = xdg_shell_get_xdg_surface(display->xdg_shell, w->surface); - if (!w->xdg_surface) { + + if (!w->xdg_surface) + { display->last_error = UWAC_ERROR_NOMEMORY; goto out_error_shell; } assert(w->xdg_surface); - xdg_surface_add_listener(w->xdg_surface, &xdg_surface_listener, w); #if BUILD_IVI - } else if (display->ivi_application) { + } + else if (display->ivi_application) + { w->ivi_surface = ivi_application_surface_create(display->ivi_application, 1, w->surface); - - assert (w->ivi_surface); - + assert(w->ivi_surface); ivi_surface_add_listener(w->ivi_surface, &ivi_surface_listener, w); #endif #if BUILD_FULLSCREEN_SHELL - } else if (display->fullscreen_shell) { + } + else if (display->fullscreen_shell) + { _wl_fullscreen_shell_present_surface(display->fullscreen_shell, w->surface, - _WL_FULLSCREEN_SHELL_PRESENT_METHOD_CENTER, NULL); + _WL_FULLSCREEN_SHELL_PRESENT_METHOD_CENTER, NULL); #endif - } else { + } + else + { w->shell_surface = wl_shell_get_shell_surface(display->shell, w->surface); - assert(w->shell_surface); - wl_shell_surface_add_listener(w->shell_surface, &shell_listener, w); wl_shell_surface_set_toplevel(w->shell_surface); } wl_list_insert(display->windows.prev, &w->link); - display->last_error = UWAC_SUCCESS; return w; - out_error_shell: wl_surface_destroy(w->surface); out_error_surface: @@ -429,11 +476,10 @@ out_error_free: } -UwacReturnCode UwacDestroyWindow(UwacWindow **pwindow) { - UwacWindow *w; - - assert (pwindow); - +UwacReturnCode UwacDestroyWindow(UwacWindow** pwindow) +{ + UwacWindow* w; + assert(pwindow); w = *pwindow; UwacWindowDestroyBuffers(w); @@ -442,9 +488,12 @@ UwacReturnCode UwacDestroyWindow(UwacWindow **pwindow) { if (w->xdg_surface) xdg_surface_destroy(w->xdg_surface); + #if BUILD_IVI + if (w->ivi_surface) ivi_surface_destroy(w->ivi_surface); + #endif if (w->opaque_region) @@ -456,14 +505,13 @@ UwacReturnCode UwacDestroyWindow(UwacWindow **pwindow) { wl_surface_destroy(w->surface); wl_list_remove(&w->link); free(w); - *pwindow = NULL; return UWAC_SUCCESS; } -UwacReturnCode UwacWindowSetOpaqueRegion(UwacWindow *window, uint32_t x, uint32_t y, uint32_t width, - uint32_t height) +UwacReturnCode UwacWindowSetOpaqueRegion(UwacWindow* window, uint32_t x, uint32_t y, uint32_t width, + uint32_t height) { assert(window); @@ -471,6 +519,7 @@ UwacReturnCode UwacWindowSetOpaqueRegion(UwacWindow *window, uint32_t x, uint32_ wl_region_destroy(window->opaque_region); window->opaque_region = wl_compositor_create_region(window->display->compositor); + if (!window->opaque_region) return UWAC_ERROR_NOMEMORY; @@ -479,13 +528,16 @@ UwacReturnCode UwacWindowSetOpaqueRegion(UwacWindow *window, uint32_t x, uint32_ return UWAC_SUCCESS; } -UwacReturnCode UwacWindowSetInputRegion(UwacWindow *window, uint32_t x, uint32_t y, uint32_t width, uint32_t height) { +UwacReturnCode UwacWindowSetInputRegion(UwacWindow* window, uint32_t x, uint32_t y, uint32_t width, + uint32_t height) +{ assert(window); if (window->input_region) wl_region_destroy(window->input_region); window->input_region = wl_compositor_create_region(window->display->compositor); + if (!window->input_region) return UWAC_ERROR_NOMEMORY; @@ -495,35 +547,41 @@ UwacReturnCode UwacWindowSetInputRegion(UwacWindow *window, uint32_t x, uint32_t } -void *UwacWindowGetDrawingBuffer(UwacWindow *window) { +void* UwacWindowGetDrawingBuffer(UwacWindow* window) +{ return window->drawingBuffer->data; } -static void frame_done_cb(void *data, struct wl_callback *callback, uint32_t time); +static void frame_done_cb(void* data, struct wl_callback* callback, uint32_t time); -static const struct wl_callback_listener frame_listener = { - frame_done_cb +static const struct wl_callback_listener frame_listener = +{ + frame_done_cb }; -static void UwacSubmitBufferPtr(UwacWindow *window, UwacBuffer *buffer) { +static void UwacSubmitBufferPtr(UwacWindow* window, UwacBuffer* buffer) +{ UINT32 nrects, i; #ifdef HAVE_PIXMAN_REGION - const pixman_box32_t *box; + const pixman_box32_t* box; #else - const RECTANGLE_16 *box; + const RECTANGLE_16* box; #endif - wl_surface_attach(window->surface, buffer->wayland_buffer, 0, 0); - #ifdef HAVE_PIXMAN_REGION box = pixman_region32_rectangles(&buffer->damage, &nrects); + for (i = 0; i < nrects; i++, box++) wl_surface_damage(window->surface, box->x1, box->y1, (box->x2 - box->x1), (box->y2 - box->y1)); + #else box = region16_rects(&buffer->damage, &nrects); + for (i = 0; i < nrects; i++, box++) - wl_surface_damage(window->surface, box->left, box->top, (box->right - box->left), (box->bottom - box->top)); + wl_surface_damage(window->surface, box->left, box->top, (box->right - box->left), + (box->bottom - box->top)); + #endif if (window->frame_callback) @@ -531,9 +589,7 @@ static void UwacSubmitBufferPtr(UwacWindow *window, UwacBuffer *buffer) { window->frame_callback = wl_surface_frame(window->surface); wl_callback_add_listener(window->frame_callback, &frame_listener, window); - wl_surface_commit(window->surface); - #ifdef HAVE_PIXMAN_REGION pixman_region32_clear(&buffer->damage); #else @@ -542,24 +598,32 @@ static void UwacSubmitBufferPtr(UwacWindow *window, UwacBuffer *buffer) { } -static void frame_done_cb(void *data, struct wl_callback *callback, uint32_t time) { - UwacWindow *window = (UwacWindow *)data; - UwacFrameDoneEvent *event; - +static void frame_done_cb(void* data, struct wl_callback* callback, uint32_t time) +{ + UwacWindow* window = (UwacWindow*)data; + UwacFrameDoneEvent* event; window->pendingBuffer = NULL; - event = (UwacFrameDoneEvent *)UwacDisplayNewEvent(window->display, UWAC_EVENT_FRAME_DONE); - if(event) + event = (UwacFrameDoneEvent*)UwacDisplayNewEvent(window->display, UWAC_EVENT_FRAME_DONE); + + if (event) event->window = window; } -UwacReturnCode UwacWindowAddDamage(UwacWindow *window, uint32_t x, uint32_t y, uint32_t width, uint32_t height) { +UwacReturnCode UwacWindowAddDamage(UwacWindow* window, uint32_t x, uint32_t y, uint32_t width, + uint32_t height) +{ #ifdef HAVE_PIXMAN_REGION - if (!pixman_region32_union_rect(&window->drawingBuffer->damage, &window->drawingBuffer->damage, x, y, width, height)) + + if (!pixman_region32_union_rect(&window->drawingBuffer->damage, &window->drawingBuffer->damage, x, + y, width, height)) #else RECTANGLE_16 box; - box.left = x; box.top = y; - box.right = x + width; box.bottom = y + height; + + box.left = x; + box.top = y; + box.right = x + width; + box.bottom = y + height; if (!region16_union_rect(&window->drawingBuffer->damage, &window->drawingBuffer->damage, &box)) #endif @@ -569,50 +633,61 @@ UwacReturnCode UwacWindowAddDamage(UwacWindow *window, uint32_t x, uint32_t y, u } -UwacReturnCode UwacWindowSubmitBuffer(UwacWindow *window, bool copyContentForNextFrame) { - UwacBuffer *drawingBuffer = window->drawingBuffer; +UwacReturnCode UwacWindowSubmitBuffer(UwacWindow* window, bool copyContentForNextFrame) +{ + UwacBuffer* drawingBuffer = window->drawingBuffer; - if (window->pendingBuffer) { + if (window->pendingBuffer) + { /* we already have a pending frame, don't do anything*/ return UWAC_SUCCESS; } UwacSubmitBufferPtr(window, drawingBuffer); - window->pendingBuffer = window->drawingBuffer; window->drawingBuffer = UwacWindowFindFreeBuffer(window); + if (!window->drawingBuffer) return UWAC_ERROR_NOMEMORY; - if (copyContentForNextFrame) { + if (copyContentForNextFrame) + { memcpy(window->drawingBuffer->data, window->pendingBuffer->data, window->stride * window->height); } return UWAC_SUCCESS; } -UwacReturnCode UwacWindowGetGeometry(UwacWindow *window, UwacSize *geometry) { +UwacReturnCode UwacWindowGetGeometry(UwacWindow* window, UwacSize* geometry) +{ assert(window); assert(geometry); - geometry->width = window->width; geometry->height = window->height; return UWAC_SUCCESS; } -UwacReturnCode UwacWindowSetFullscreenState(UwacWindow *window, UwacOutput *output, bool isFullscreen) { - if (window->xdg_surface) { - if (isFullscreen) { +UwacReturnCode UwacWindowSetFullscreenState(UwacWindow* window, UwacOutput* output, + bool isFullscreen) +{ + if (window->xdg_surface) + { + if (isFullscreen) + { xdg_surface_set_fullscreen(window->xdg_surface, output ? output->output : NULL); - } else { + } + else + { xdg_surface_unset_fullscreen(window->xdg_surface); } } + return UWAC_SUCCESS; } -void UwacWindowSetTitle(UwacWindow *window, const char *name) { +void UwacWindowSetTitle(UwacWindow* window, const char* name) +{ if (window->xdg_surface) xdg_surface_set_title(window->xdg_surface, name); else if (window->shell_surface)