diff options
Diffstat (limited to 'uwac/libuwac')
| -rw-r--r-- | uwac/libuwac/CMakeLists.txt | 103 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-clipboard.c | 280 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-display.c | 794 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-input.c | 1277 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-os.c | 290 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-os.h | 45 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-output.c | 183 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-priv.h | 291 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-tools.c | 106 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-utils.c | 67 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-utils.h | 56 | ||||
| -rw-r--r-- | uwac/libuwac/uwac-window.c | 883 |
12 files changed, 4375 insertions, 0 deletions
diff --git a/uwac/libuwac/CMakeLists.txt b/uwac/libuwac/CMakeLists.txt new file mode 100644 index 0000000..9d57ad8 --- /dev/null +++ b/uwac/libuwac/CMakeLists.txt @@ -0,0 +1,103 @@ +# UWAC: Using Wayland As Client +# +# Copyright 2015 David FORT <contact@hardening-consulting.com> +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +set(MODULE_NAME "uwac") +set(MODULE_PREFIX "UWAC") + +set(GENERATED_SOURCES "") +macro(generate_protocol_file PROTO) + add_custom_command( + OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/protocols/${PROTO}-protocol.c" + COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/protocols + COMMAND ${WAYLAND_SCANNER} code < ${CMAKE_CURRENT_SOURCE_DIR}/../protocols/${PROTO}.xml > ${CMAKE_CURRENT_BINARY_DIR}/protocols/${PROTO}-protocol.c + DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/../protocols/${PROTO}.xml + ) + + add_custom_command( + OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/protocols/${PROTO}-client-protocol.h" + COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/protocols + COMMAND ${WAYLAND_SCANNER} client-header < ${CMAKE_CURRENT_SOURCE_DIR}/../protocols/${PROTO}.xml > ${CMAKE_CURRENT_BINARY_DIR}/protocols/${PROTO}-client-protocol.h + DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/../protocols/${PROTO}.xml + ) + + list(APPEND GENERATED_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/protocols/${PROTO}-client-protocol.h) + list(APPEND GENERATED_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/protocols/${PROTO}-protocol.c) +endmacro() + +generate_protocol_file(xdg-shell) +generate_protocol_file(viewporter) +generate_protocol_file(xdg-decoration-unstable-v1) +generate_protocol_file(server-decoration) +generate_protocol_file(ivi-application) +generate_protocol_file(fullscreen-shell-unstable-v1) +generate_protocol_file(keyboard-shortcuts-inhibit-unstable-v1) + +if(FREEBSD) + include_directories(${EPOLLSHIM_INCLUDE_DIR}) +endif() +include_directories(${WAYLAND_INCLUDE_DIR}) +include_directories(${XKBCOMMON_INCLUDE_DIR}) +include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include") +include_directories("${CMAKE_CURRENT_BINARY_DIR}/../include") +include_directories("${CMAKE_CURRENT_BINARY_DIR}/protocols") + +add_definitions(-DBUILD_IVI -DBUILD_FULLSCREEN_SHELL -DENABLE_XKBCOMMON) + +set(${MODULE_PREFIX}_SRCS + ${GENERATED_SOURCES} + uwac-display.c + uwac-input.c + uwac-clipboard.c + uwac-os.c + uwac-os.h + uwac-output.c + uwac-priv.h + uwac-tools.c + uwac-utils.c + uwac-window.c) + + +add_library(${MODULE_NAME} ${${MODULE_PREFIX}_SRCS}) + +set_target_properties(${MODULE_NAME} PROPERTIES LINKER_LANGUAGE C) +set_target_properties(${MODULE_NAME} PROPERTIES OUTPUT_NAME ${MODULE_NAME}${UWAC_API_VERSION}) +if (WITH_LIBRARY_VERSIONING) + set_target_properties(${MODULE_NAME} PROPERTIES VERSION ${UWAC_VERSION} SOVERSION ${UWAC_API_VERSION}) +endif() + +target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS} PRIVATE ${WAYLAND_LIBS} ${XKBCOMMON_LIBS} ${EPOLLSHIM_LIBS}) +if (UWAC_HAVE_PIXMAN_REGION) + target_link_libraries(${MODULE_NAME} PRIVATE ${pixman_LINK_LIBRARIES}) +else() + target_link_libraries(${MODULE_NAME} PRIVATE freerdp) +endif() + +target_link_libraries(${MODULE_NAME} PRIVATE m) + +if (NOT UWAC_FORCE_STATIC_BUILD) + target_include_directories(${MODULE_NAME} INTERFACE $<INSTALL_INTERFACE:include/uwac${UWAC_API_VERSION}>) + + install(TARGETS ${MODULE_NAME} COMPONENT libraries EXPORT uwac + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) +endif() + +set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "uwac") + +if(BUILD_TESTING) +# add_subdirectory(test) +endif() diff --git a/uwac/libuwac/uwac-clipboard.c b/uwac/libuwac/uwac-clipboard.c new file mode 100644 index 0000000..216d70a --- /dev/null +++ b/uwac/libuwac/uwac-clipboard.c @@ -0,0 +1,280 @@ +/* + * Copyright © 2018 Armin Novak <armin.novak@thincast.com> + * Copyright © 2018 Thincast Technologies GmbH + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ +#include "uwac-priv.h" +#include "uwac-utils.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <assert.h> +#include <time.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/mman.h> +#include <sys/timerfd.h> +#include <sys/epoll.h> + +/* paste */ +static void data_offer_offer(void* data, struct wl_data_offer* data_offer, + const char* offered_mime_type) +{ + UwacSeat* seat = (UwacSeat*)data; + + assert(seat); + if (!seat->ignore_announcement) + { + UwacClipboardEvent* event = + (UwacClipboardEvent*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_CLIPBOARD_OFFER); + + if (!event) + { + assert(uwacErrorHandler(seat->display, UWAC_ERROR_INTERNAL, + "failed to allocate a clipboard event\n")); + } + else + { + event->seat = seat; + snprintf(event->mime, sizeof(event->mime), "%s", offered_mime_type); + } + } +} + +static const struct wl_data_offer_listener data_offer_listener = { .offer = data_offer_offer }; + +static void data_device_data_offer(void* data, struct wl_data_device* data_device, + struct wl_data_offer* data_offer) +{ + UwacSeat* seat = (UwacSeat*)data; + + assert(seat); + if (!seat->ignore_announcement) + { + UwacClipboardEvent* event = + (UwacClipboardEvent*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_CLIPBOARD_SELECT); + + if (!event) + { + assert(uwacErrorHandler(seat->display, UWAC_ERROR_INTERNAL, + "failed to allocate a close event\n")); + } + else + event->seat = seat; + + wl_data_offer_add_listener(data_offer, &data_offer_listener, data); + seat->offer = data_offer; + } + else + seat->offer = NULL; +} + +static void data_device_selection(void* data, struct wl_data_device* data_device, + struct wl_data_offer* data_offer) +{ +} + +static const struct wl_data_device_listener data_device_listener = { + .data_offer = data_device_data_offer, .selection = data_device_selection +}; + +/* copy */ +static void data_source_target_handler(void* data, struct wl_data_source* data_source, + const char* mime_type) +{ +} + +static void data_source_send_handler(void* data, struct wl_data_source* data_source, + const char* mime_type, int fd) +{ + UwacSeat* seat = (UwacSeat*)data; + seat->transfer_data(seat, seat->data_context, mime_type, fd); +} + +static void data_source_cancelled_handler(void* data, struct wl_data_source* data_source) +{ + UwacSeat* seat = (UwacSeat*)data; + seat->cancel_data(seat, seat->data_context); +} + +static const struct wl_data_source_listener data_source_listener = { + .target = data_source_target_handler, + .send = data_source_send_handler, + .cancelled = data_source_cancelled_handler +}; + +static void UwacRegisterDeviceListener(UwacSeat* s) +{ + wl_data_device_add_listener(s->data_device, &data_device_listener, s); +} + +static UwacReturnCode UwacCreateDataSource(UwacSeat* s) +{ + if (!s) + return UWAC_ERROR_INTERNAL; + + s->data_source = wl_data_device_manager_create_data_source(s->display->data_device_manager); + wl_data_source_add_listener(s->data_source, &data_source_listener, s); + return UWAC_SUCCESS; +} + +UwacReturnCode UwacSeatRegisterClipboard(UwacSeat* s) +{ + UwacClipboardEvent* event = NULL; + + if (!s) + return UWAC_ERROR_INTERNAL; + + if (!s->display->data_device_manager || !s->data_device) + return UWAC_NOT_ENOUGH_RESOURCES; + + UwacRegisterDeviceListener(s); + + UwacReturnCode rc = UwacCreateDataSource(s); + + if (rc != UWAC_SUCCESS) + return rc; + event = (UwacClipboardEvent*)UwacDisplayNewEvent(s->display, UWAC_EVENT_CLIPBOARD_AVAILABLE); + + if (!event) + { + assert(uwacErrorHandler(s->display, UWAC_ERROR_INTERNAL, + "failed to allocate a clipboard event\n")); + return UWAC_ERROR_INTERNAL; + } + + event->seat = s; + return UWAC_SUCCESS; +} + +UwacReturnCode UwacClipboardOfferDestroy(UwacSeat* seat) +{ + if (!seat) + return UWAC_ERROR_INTERNAL; + + if (seat->data_source) + wl_data_source_destroy(seat->data_source); + + return UwacCreateDataSource(seat); +} + +UwacReturnCode UwacClipboardOfferCreate(UwacSeat* seat, const char* mime) +{ + if (!seat || !mime) + return UWAC_ERROR_INTERNAL; + + wl_data_source_offer(seat->data_source, mime); + return UWAC_SUCCESS; +} + +static void callback_done(void* data, struct wl_callback* callback, uint32_t serial) +{ + *(uint32_t*)data = serial; +} + +static const struct wl_callback_listener callback_listener = { .done = callback_done }; + +static uint32_t get_serial(UwacSeat* s) +{ + struct wl_callback* callback = NULL; + uint32_t serial = 0; + callback = wl_display_sync(s->display->display); + wl_callback_add_listener(callback, &callback_listener, &serial); + + while (serial == 0) + { + wl_display_dispatch(s->display->display); + } + + return serial; +} + +UwacReturnCode UwacClipboardOfferAnnounce(UwacSeat* seat, void* context, + UwacDataTransferHandler transfer, + UwacCancelDataTransferHandler cancel) +{ + if (!seat) + return UWAC_ERROR_INTERNAL; + + seat->data_context = context; + seat->transfer_data = transfer; + seat->cancel_data = cancel; + seat->ignore_announcement = true; + wl_data_device_set_selection(seat->data_device, seat->data_source, get_serial(seat)); + wl_display_roundtrip(seat->display->display); + seat->ignore_announcement = false; + return UWAC_SUCCESS; +} + +void* UwacClipboardDataGet(UwacSeat* seat, const char* mime, size_t* size) +{ + ssize_t r = 0; + size_t alloc = 0; + size_t pos = 0; + char* data = NULL; + int pipefd[2]; + + if (!seat || !mime || !size || !seat->offer) + return NULL; + + *size = 0; + if (pipe(pipefd) != 0) + return NULL; + + wl_data_offer_receive(seat->offer, mime, pipefd[1]); + close(pipefd[1]); + wl_display_roundtrip(seat->display->display); + wl_display_flush(seat->display->display); + + do + { + void* tmp = NULL; + alloc += 1024; + tmp = xrealloc(data, alloc); + if (!tmp) + { + free(data); + close(pipefd[0]); + return NULL; + } + + data = tmp; + r = read(pipefd[0], &data[pos], alloc - pos); + if (r > 0) + pos += r; + if (r < 0) + { + free(data); + close(pipefd[0]); + return NULL; + } + } while (r > 0); + + close(pipefd[0]); + close(pipefd[1]); + + if (alloc > 0) + { + data[pos] = '\0'; + *size = pos + 1; + } + return data; +} diff --git a/uwac/libuwac/uwac-display.c b/uwac/libuwac/uwac-display.c new file mode 100644 index 0000000..1b26e21 --- /dev/null +++ b/uwac/libuwac/uwac-display.c @@ -0,0 +1,794 @@ +/* + * Copyright © 2014 David FORT <contact@hardening-consulting.com> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ +#include "uwac-priv.h" +#include "uwac-utils.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> +#include <assert.h> +#include <errno.h> +#include <time.h> +#include <unistd.h> +#include <sys/epoll.h> + +#include "uwac-os.h" +#include "wayland-cursor.h" + +#define TARGET_COMPOSITOR_INTERFACE 3U +#define TARGET_SHM_INTERFACE 1U +#define TARGET_SHELL_INTERFACE 1U +#define TARGET_DDM_INTERFACE 1U +#define TARGET_SEAT_INTERFACE 5U +#define TARGET_XDG_VERSION 5U /* The version of xdg-shell that we implement */ + +#if !defined(NDEBUG) +static const char* event_names[] = { + "new seat", "removed seat", "new output", "configure", "pointer enter", + "pointer leave", "pointer motion", "pointer buttons", "pointer axis", "keyboard enter", + "key", "touch frame begin", "touch up", "touch down", "touch motion", + "touch cancel", "touch frame end", "frame done", "close", NULL +}; +#endif + +static bool uwac_default_error_handler(UwacDisplay* display, UwacReturnCode code, const char* msg, + ...) +{ + va_list args; + va_start(args, msg); + vfprintf(stderr, "%s", args); + va_end(args); + return false; +} + +UwacErrorHandler uwacErrorHandler = uwac_default_error_handler; + +void UwacInstallErrorHandler(UwacErrorHandler handler) +{ + if (handler) + uwacErrorHandler = handler; + else + uwacErrorHandler = uwac_default_error_handler; +} + +static void cb_shm_format(void* data, struct wl_shm* wl_shm, uint32_t format) +{ + 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[d->shm_formats_nb - 1] = format; +} + +static struct wl_shm_listener shm_listener = { cb_shm_format }; + +static void xdg_shell_ping(void* data, struct xdg_wm_base* xdg_wm_base, uint32_t serial) +{ + xdg_wm_base_pong(xdg_wm_base, serial); +} + +static const struct xdg_wm_base_listener xdg_wm_base_listener = { + xdg_shell_ping, +}; + +#ifdef BUILD_FULLSCREEN_SHELL +static void fullscreen_capability(void* data, + struct zwp_fullscreen_shell_v1* zwp_fullscreen_shell_v1, + uint32_t capability) +{ +} + +static const struct zwp_fullscreen_shell_v1_listener fullscreen_shell_listener = { + fullscreen_capability, +}; +#endif + +static void display_destroy_seat(UwacDisplay* d, uint32_t name) +{ + UwacSeat* seat = NULL; + UwacSeat* tmp = NULL; + wl_list_for_each_safe(seat, tmp, &d->seats, link) + { + if (seat->seat_id == name) + { + UwacSeatDestroy(seat); + } + } +} + +static void UwacSeatRegisterDDM(UwacSeat* seat) +{ + UwacDisplay* d = seat->display; + if (!d->data_device_manager) + return; + + if (!seat->data_device) + seat->data_device = + wl_data_device_manager_get_data_device(d->data_device_manager, seat->seat); +} + +static void UwacRegisterCursor(UwacSeat* seat) +{ + if (!seat || !seat->display || !seat->display->compositor) + return; + + seat->pointer_surface = wl_compositor_create_surface(seat->display->compositor); +} + +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 = NULL; + global = xzalloc(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) + { + 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 = NULL; + UwacOutputNewEvent* ev = NULL; + output = UwacCreateOutput(d, id, version); + + if (!output) + { + assert(uwacErrorHandler(d, UWAC_ERROR_NOMEMORY, "unable to create output\n")); + return; + } + + ev = (UwacOutputNewEvent*)UwacDisplayNewEvent(d, UWAC_EVENT_NEW_OUTPUT); + + if (ev) + ev->output = output; + } + else if (strcmp(interface, "wl_seat") == 0) + { + UwacSeatNewEvent* ev = NULL; + UwacSeat* seat = NULL; + seat = UwacSeatNew(d, id, min(version, TARGET_SEAT_INTERFACE)); + + if (!seat) + { + assert(uwacErrorHandler(d, UWAC_ERROR_NOMEMORY, "unable to create new seat\n")); + return; + } + + UwacSeatRegisterDDM(seat); + UwacSeatRegisterClipboard(seat); + UwacRegisterCursor(seat); + 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) + { + UwacSeat* seat = NULL; + UwacSeat* tmp = NULL; + + d->data_device_manager = wl_registry_bind(registry, id, &wl_data_device_manager_interface, + min(TARGET_DDM_INTERFACE, version)); + + wl_list_for_each_safe(seat, tmp, &d->seats, link) + { + UwacSeatRegisterDDM(seat); + UwacSeatRegisterClipboard(seat); + UwacRegisterCursor(seat); + } + } + 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_wm_base") == 0) + { + d->xdg_base = wl_registry_bind(registry, id, &xdg_wm_base_interface, 1); + xdg_wm_base_add_listener(d->xdg_base, &xdg_wm_base_listener, d); + } + else if (strcmp(interface, "wp_viewporter") == 0) + { + d->viewporter = wl_registry_bind(registry, id, &wp_viewporter_interface, 1); + } + else if (strcmp(interface, "zwp_keyboard_shortcuts_inhibit_manager_v1") == 0) + { + d->keyboard_inhibit_manager = + wl_registry_bind(registry, id, &zwp_keyboard_shortcuts_inhibit_manager_v1_interface, 1); + } + else if (strcmp(interface, "zxdg_decoration_manager_v1") == 0) + { + d->deco_manager = wl_registry_bind(registry, id, &zxdg_decoration_manager_v1_interface, 1); + } + else if (strcmp(interface, "org_kde_kwin_server_decoration_manager") == 0) + { + d->kde_deco_manager = + wl_registry_bind(registry, id, &org_kde_kwin_server_decoration_manager_interface, 1); + } +#if BUILD_IVI + 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, "zwp_fullscreen_shell_v1") == 0) + { + d->fullscreen_shell = wl_registry_bind(registry, id, &zwp_fullscreen_shell_v1_interface, 1); + zwp_fullscreen_shell_v1_add_listener(d->fullscreen_shell, &fullscreen_shell_listener, d); + } +#endif +#if 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) + { + //init_workspace_manager(d, id); + } + 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 = NULL; + UwacGlobal* tmp = NULL; + 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 = NULL; + display_destroy_seat(d, name); + ev = (UwacSeatRemovedEvent*)UwacDisplayNewEvent(d, UWAC_EVENT_REMOVED_SEAT); + + if (ev) + ev->id = name; + } + + wl_list_remove(&global->link); + free(global->interface); + free(global); + } +} + +static void UwacDestroyGlobal(UwacGlobal* global) +{ + free(global->interface); + wl_list_remove(&global->link); + free(global); +} + +static 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 = { registry_handle_global, + registry_handle_global_remove }; + +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); +} + +static void UwacDisplayUnwatchFd(UwacDisplay* display, int fd) +{ + epoll_ctl(display->epoll_fd, EPOLL_CTL_DEL, fd, NULL); +} + +static void display_exit(UwacDisplay* display) +{ + display->running = false; +} + +static void display_dispatch_events(UwacTask* task, uint32_t events) +{ + UwacDisplay* display = container_of(task, UwacDisplay, dispatch_fd_task); + struct epoll_event ep; + int ret = 0; + display->display_fd_events = events; + + if ((events & EPOLLERR) || (events & EPOLLHUP)) + { + display_exit(display); + return; + } + + if (events & EPOLLIN) + { + ret = wl_display_dispatch(display->display); + + if (ret == -1) + { + display_exit(display); + return; + } + } + + if (events & EPOLLOUT) + { + ret = wl_display_flush(display->display); + + 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) + { + display_exit(display); + return; + } + } +} + +UwacDisplay* UwacOpenDisplay(const char* name, UwacReturnCode* err) +{ + UwacDisplay* ret = NULL; + ret = (UwacDisplay*)xzalloc(sizeof(*ret)); + + if (!ret) + { + *err = UWAC_ERROR_NOMEMORY; + return NULL; + } + + wl_list_init(&ret->globals); + 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) + { + 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) + { + *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) + { + *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)) + { + 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) + { + uwacErrorHandler(ret, UWAC_ERROR_INTERNAL, "unable to watch display fd: %m\n"); + *err = UWAC_ERROR_INTERNAL; + goto out_free_registry; + } + + ret->running = true; + ret->last_error = *err = UWAC_SUCCESS; + return ret; +out_free_registry: + wl_registry_destroy(ret->registry); +out_close_epoll: + close(ret->epoll_fd); +out_disconnect: + wl_display_disconnect(ret->display); +out_free: + free(ret); + return NULL; +} + +int UwacDisplayDispatch(UwacDisplay* display, int timeout) +{ + int ret = 0; + int count = 0; + UwacTask* task = NULL; + 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) + { + 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) + { + return -1; + } + + count = epoll_wait(display->epoll_fd, ep, ARRAY_LENGTH(ep), timeout); + + for (int i = 0; i < count; i++) + { + task = ep[i].data.ptr; + task->run(task, ep[i].events); + } + + return 1; +} + +UwacReturnCode UwacDisplayGetLastError(const UwacDisplay* display) +{ + return display->last_error; +} + +UwacReturnCode UwacCloseDisplay(UwacDisplay** pdisplay) +{ + UwacDisplay* display = NULL; + UwacSeat* seat = NULL; + UwacSeat* tmpSeat = NULL; + UwacWindow* window = NULL; + UwacWindow* tmpWindow = NULL; + UwacOutput* output = NULL; + UwacOutput* tmpOutput = NULL; + UwacGlobal* global = NULL; + UwacGlobal* tmpGlobal = NULL; + assert(pdisplay); + display = *pdisplay; + + if (!display) + return UWAC_ERROR_INVALID_DISPLAY; + + /* destroy windows */ + wl_list_for_each_safe(window, tmpWindow, &display->windows, link) + { + UwacDestroyWindow(&window); + } + /* destroy seats */ + wl_list_for_each_safe(seat, tmpSeat, &display->seats, link) + { + UwacSeatDestroy(seat); + } + /* destroy output */ + wl_list_for_each_safe(output, tmpOutput, &display->outputs, link) + { + UwacDestroyOutput(output); + } + /* destroy globals */ + wl_list_for_each_safe(global, tmpGlobal, &display->globals, link) + { + UwacDestroyGlobal(global); + } + + if (display->compositor) + wl_compositor_destroy(display->compositor); + + if (display->keyboard_inhibit_manager) + zwp_keyboard_shortcuts_inhibit_manager_v1_destroy(display->keyboard_inhibit_manager); + + if (display->deco_manager) + zxdg_decoration_manager_v1_destroy(display->deco_manager); + + if (display->kde_deco_manager) + org_kde_kwin_server_decoration_manager_destroy(display->kde_deco_manager); + +#ifdef BUILD_FULLSCREEN_SHELL + + if (display->fullscreen_shell) + zwp_fullscreen_shell_v1_destroy(display->fullscreen_shell); + +#endif +#ifdef BUILD_IVI + + if (display->ivi_application) + ivi_application_destroy(display->ivi_application); + +#endif + + if (display->xdg_toplevel) + xdg_toplevel_destroy(display->xdg_toplevel); + + if (display->xdg_base) + xdg_wm_base_destroy(display->xdg_base); + + if (display->shell) + wl_shell_destroy(display->shell); + + if (display->shm) + wl_shm_destroy(display->shm); + + if (display->viewporter) + wp_viewporter_destroy(display->viewporter); + + 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; + display->push_queue = item->tail; + free(item); + } + + free(display); + *pdisplay = NULL; + return UWAC_SUCCESS; +} + +int UwacDisplayGetFd(UwacDisplay* display) +{ + return display->epoll_fd; +} + +static const char* errorStrings[] = { + "success", + "out of memory error", + "unable to connect to wayland display", + "invalid UWAC display", + "not enough resources", + "timed out", + "not found", + "closed connection", + + "internal 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 = NULL; + const UwacGlobal* tmp = NULL; + + if (!display) + return UWAC_ERROR_INVALID_DISPLAY; + + wl_list_for_each_safe(global, tmp, &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) + { + return 0; + } + + if (!display->shm) + { + display->last_error = UWAC_NOT_FOUND; + return 0; + } + + display->last_error = UWAC_SUCCESS; + return display->shm_formats_nb; +} + +UwacReturnCode UwacDisplayQueryShmFormats(const UwacDisplay* display, enum wl_shm_format* formats, + int formats_size, int* filled) +{ + if (!display) + return UWAC_ERROR_INVALID_DISPLAY; + + *filled = min((int64_t)display->shm_formats_nb, formats_size); + memcpy(formats, (const void*)display->shm_formats, *filled * sizeof(enum wl_shm_format)); + return UWAC_SUCCESS; +} + +uint32_t UwacDisplayGetNbOutputs(const UwacDisplay* display) +{ + return wl_list_length(&display->outputs); +} + +const UwacOutput* UwacDisplayGetOutput(UwacDisplay* display, int index) +{ + int i = 0; + int display_count = 0; + UwacOutput* ret = NULL; + + if (!display) + return NULL; + + display_count = wl_list_length(&display->outputs); + if (display_count <= index) + return NULL; + + wl_list_for_each(ret, &display->outputs, link) + { + if (i == index) + break; + i++; + } + + if (!ret) + { + display->last_error = UWAC_NOT_FOUND; + return NULL; + } + + display->last_error = UWAC_SUCCESS; + return ret; +} + +UwacReturnCode UwacOutputGetResolution(const UwacOutput* output, UwacSize* resolution) +{ + if ((output->resolution.height <= 0) || (output->resolution.width <= 0)) + return UWAC_ERROR_INTERNAL; + + *resolution = output->resolution; + return UWAC_SUCCESS; +} + +UwacReturnCode UwacOutputGetPosition(const UwacOutput* output, UwacPosition* pos) +{ + *pos = output->position; + return UWAC_SUCCESS; +} + +UwacEvent* UwacDisplayNewEvent(UwacDisplay* display, int type) +{ + UwacEventListItem* ret = NULL; + + if (!display) + { + return 0; + } + + ret = xzalloc(sizeof(UwacEventListItem)); + + 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) +{ + return display->pop_queue != NULL; +} + +UwacReturnCode UwacNextEvent(UwacDisplay* display, UwacEvent* event) +{ + UwacEventListItem* prevItem = NULL; + int ret = 0; + + if (!display) + return UWAC_ERROR_INVALID_DISPLAY; + + while (!display->pop_queue) + { + ret = UwacDisplayDispatch(display, 1 * 1000); + + if (ret < 0) + return UWAC_ERROR_INTERNAL; + else if (ret == 0) + return UWAC_ERROR_CLOSED; + } + + prevItem = display->pop_queue->head; + *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-input.c b/uwac/libuwac/uwac-input.c new file mode 100644 index 0000000..5ad52ae --- /dev/null +++ b/uwac/libuwac/uwac-input.c @@ -0,0 +1,1277 @@ +/* + * Copyright © 2014-2015 David FORT <contact@hardening-consulting.com> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ +#include "uwac-priv.h" +#include "uwac-utils.h" + +#include <stdio.h> +#include <inttypes.h> +#include <stdlib.h> +#include <stdint.h> +#include <string.h> +#include <assert.h> +#include <errno.h> +#include <time.h> +#include <unistd.h> +#include <sys/mman.h> +#include <sys/timerfd.h> +#include <sys/epoll.h> + +#include "uwac-os.h" +#include "wayland-cursor.h" +#include "wayland-client-protocol.h" + +static struct wl_buffer* create_pointer_buffer(UwacSeat* seat, const void* src, size_t size) +{ + struct wl_buffer* buffer = NULL; + int fd = 0; + void* data = NULL; + struct wl_shm_pool* pool = NULL; + + assert(seat); + + fd = uwac_create_anonymous_file(size); + + if (fd < 0) + return buffer; + + data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + + if (data == MAP_FAILED) + { + goto error_mmap; + } + memcpy(data, src, size); + + pool = wl_shm_create_pool(seat->display->shm, fd, size); + + if (!pool) + { + munmap(data, size); + goto error_mmap; + } + + buffer = + wl_shm_pool_create_buffer(pool, 0, seat->pointer_image->width, seat->pointer_image->height, + seat->pointer_image->width * 4, WL_SHM_FORMAT_ARGB8888); + wl_shm_pool_destroy(pool); + + if (munmap(data, size) < 0) + fprintf(stderr, "%s: munmap(%p, %zu) failed with [%d] %s\n", __func__, data, size, errno, + strerror(errno)); + +error_mmap: + close(fd); + return buffer; +} + +static void on_buffer_release(void* data, struct wl_buffer* wl_buffer) +{ + (void)data; + wl_buffer_destroy(wl_buffer); +} + +static const struct wl_buffer_listener buffer_release_listener = { on_buffer_release }; + +static UwacReturnCode set_cursor_image(UwacSeat* seat, uint32_t serial) +{ + struct wl_buffer* buffer = NULL; + struct wl_cursor* cursor = NULL; + struct wl_cursor_image* image = NULL; + struct wl_surface* surface = NULL; + int32_t x = 0; + int32_t y = 0; + + if (!seat || !seat->display || !seat->default_cursor || !seat->default_cursor->images) + return UWAC_ERROR_INTERNAL; + + int scale = 1; + if (seat->pointer_focus) + scale = seat->pointer_focus->display->actual_scale; + + switch (seat->pointer_type) + { + case 2: /* Custom poiner */ + image = seat->pointer_image; + buffer = create_pointer_buffer(seat, seat->pointer_data, seat->pointer_size); + if (!buffer) + return UWAC_ERROR_INTERNAL; + if (wl_buffer_add_listener(buffer, &buffer_release_listener, seat) < 0) + return UWAC_ERROR_INTERNAL; + + surface = seat->pointer_surface; + x = image->hotspot_x / scale; + y = image->hotspot_y / scale; + break; + case 1: /* NULL pointer */ + break; + default: /* Default system pointer */ + cursor = seat->default_cursor; + if (!cursor) + return UWAC_ERROR_INTERNAL; + image = cursor->images[0]; + if (!image) + return UWAC_ERROR_INTERNAL; + x = image->hotspot_x; + y = image->hotspot_y; + buffer = wl_cursor_image_get_buffer(image); + if (!buffer) + return UWAC_ERROR_INTERNAL; + surface = seat->pointer_surface; + break; + } + + if (surface && buffer) + { + wl_surface_set_buffer_scale(surface, scale); + wl_surface_attach(surface, buffer, 0, 0); + wl_surface_damage(surface, 0, 0, image->width, image->height); + wl_surface_commit(surface); + } + + wl_pointer_set_cursor(seat->pointer, serial, surface, x, y); + + return UWAC_SUCCESS; +} + +static void keyboard_repeat_func(UwacTask* task, uint32_t events) +{ + UwacSeat* input = container_of(task, UwacSeat, repeat_task); + assert(input); + UwacWindow* window = input->keyboard_focus; + uint64_t exp = 0; + + if (read(input->repeat_timer_fd, &exp, sizeof exp) != sizeof exp) + /* If we change the timer between the fd becoming + * readable and getting here, there'll be nothing to + * read and we get EAGAIN. */ + return; + + if (window) + { + UwacKeyEvent* key = NULL; + + key = (UwacKeyEvent*)UwacDisplayNewEvent(input->display, UWAC_EVENT_KEY); + if (!key) + return; + + key->window = window; + key->sym = input->repeat_sym; + key->raw_key = input->repeat_key; + key->pressed = true; + key->repeated = true; + } +} + +static void keyboard_handle_keymap(void* data, struct wl_keyboard* keyboard, uint32_t format, + int fd, uint32_t size) +{ + UwacSeat* input = data; + struct xkb_keymap* keymap = NULL; + struct xkb_state* state = NULL; + char* map_str = NULL; + int mapFlags = MAP_SHARED; + + if (!data) + { + close(fd); + return; + } + + if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) + { + close(fd); + return; + } + + if (input->seat_version >= 7) + mapFlags = MAP_PRIVATE; + + map_str = mmap(NULL, size, PROT_READ, mapFlags, fd, 0); + if (map_str == MAP_FAILED) + { + close(fd); + return; + } + + keymap = xkb_keymap_new_from_string(input->xkb_context, map_str, XKB_KEYMAP_FORMAT_TEXT_V1, 0); + munmap(map_str, size); + close(fd); + + if (!keymap) + { + assert(uwacErrorHandler(input->display, UWAC_ERROR_INTERNAL, "failed to compile keymap\n")); + return; + } + + state = xkb_state_new(keymap); + if (!state) + { + assert( + uwacErrorHandler(input->display, UWAC_ERROR_NOMEMORY, "failed to create XKB state\n")); + xkb_keymap_unref(keymap); + return; + } + + xkb_keymap_unref(input->xkb.keymap); + xkb_state_unref(input->xkb.state); + input->xkb.keymap = keymap; + input->xkb.state = state; + + input->xkb.control_mask = 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Control"); + input->xkb.alt_mask = 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Mod1"); + input->xkb.shift_mask = 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Shift"); + input->xkb.caps_mask = 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Lock"); + input->xkb.num_mask = 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Mod2"); +} + +static void keyboard_handle_key(void* data, struct wl_keyboard* keyboard, uint32_t serial, + uint32_t time, uint32_t key, uint32_t state_w); + +static void keyboard_handle_enter(void* data, struct wl_keyboard* keyboard, uint32_t serial, + struct wl_surface* surface, struct wl_array* keys) +{ + UwacSeat* input = (UwacSeat*)data; + assert(input); + + UwacKeyboardEnterLeaveEvent* event = (UwacKeyboardEnterLeaveEvent*)UwacDisplayNewEvent( + input->display, UWAC_EVENT_KEYBOARD_ENTER); + if (!event) + return; + + event->window = input->keyboard_focus = (UwacWindow*)wl_surface_get_user_data(surface); + event->seat = input; + + /* we may have the keys in the `keys` array, but as this function is called only + * when the window gets focus, so there may be keys from other unrelated windows, eg. + * this was leading to problems like passing CTRL+D to freerdp from closing terminal window + * if it was closing very fast and the keys was still pressed by the user while the freerdp + * gets focus + * + * currently just ignore this, as further key presses will be handled correctly anyway + */ +} + +static void keyboard_handle_leave(void* data, struct wl_keyboard* keyboard, uint32_t serial, + struct wl_surface* surface) +{ + struct itimerspec its = { 0 }; + uint32_t* pressedKey = NULL; + size_t i = 0; + + UwacSeat* input = (UwacSeat*)data; + assert(input); + + its.it_interval.tv_sec = 0; + its.it_interval.tv_nsec = 0; + its.it_value.tv_sec = 0; + its.it_value.tv_nsec = 0; + timerfd_settime(input->repeat_timer_fd, 0, &its, NULL); + + UwacPointerEnterLeaveEvent* event = + (UwacPointerEnterLeaveEvent*)UwacDisplayNewEvent(input->display, UWAC_EVENT_POINTER_LEAVE); + if (!event) + return; + + event->window = input->keyboard_focus; + + /* we are currently loosing input focus of the main window: + * check if we currently have some keys pressed and release them as if we enter the window again + * it will be still "virtually" pressed in remote even if in reality the key has been released + */ + for (pressedKey = input->pressed_keys.data, i = 0; i < input->pressed_keys.size; + i += sizeof(uint32_t)) + { + keyboard_handle_key(data, keyboard, serial, 0, *pressedKey, WL_KEYBOARD_KEY_STATE_RELEASED); + pressedKey++; + } +} + +static int update_key_pressed(UwacSeat* seat, uint32_t key) +{ + uint32_t* keyPtr = NULL; + assert(seat); + + /* check if the key is not already pressed */ + wl_array_for_each(keyPtr, &seat->pressed_keys) + { + if (*keyPtr == key) + return 1; + } + + keyPtr = wl_array_add(&seat->pressed_keys, sizeof(uint32_t)); + if (!keyPtr) + return -1; + + *keyPtr = key; + return 0; +} + +static int update_key_released(UwacSeat* seat, uint32_t key) +{ + size_t toMove = 0; + bool found = false; + + assert(seat); + + size_t i = 0; + uint32_t* keyPtr = seat->pressed_keys.data; + for (; i < seat->pressed_keys.size; i++, keyPtr++) + { + if (*keyPtr == key) + { + found = true; + break; + } + } + + if (found) + { + toMove = seat->pressed_keys.size - ((i + 1) * sizeof(uint32_t)); + if (toMove) + memmove(keyPtr, keyPtr + 1, toMove); + + seat->pressed_keys.size -= sizeof(uint32_t); + } + return 1; +} + +static void keyboard_handle_key(void* data, struct wl_keyboard* keyboard, uint32_t serial, + uint32_t time, uint32_t key, uint32_t state_w) +{ + UwacSeat* input = (UwacSeat*)data; + assert(input); + + UwacWindow* window = input->keyboard_focus; + UwacKeyEvent* keyEvent = NULL; + + uint32_t code = 0; + uint32_t num_syms = 0; + enum wl_keyboard_key_state state = state_w; + const xkb_keysym_t* syms = NULL; + xkb_keysym_t sym = 0; + struct itimerspec its; + + if (state_w == WL_KEYBOARD_KEY_STATE_PRESSED) + update_key_pressed(input, key); + else + update_key_released(input, key); + + input->display->serial = serial; + code = key + 8; + if (!window || !input->xkb.state) + return; + + /* We only use input grabs for pointer events for now, so just + * ignore key presses if a grab is active. We expand the key + * event delivery mechanism to route events to widgets to + * properly handle key grabs. In the meantime, this prevents + * key event delivery while a grab is active. */ + /*if (input->grab && input->grab_button == 0) + return;*/ + + num_syms = xkb_state_key_get_syms(input->xkb.state, code, &syms); + + sym = XKB_KEY_NoSymbol; + if (num_syms == 1) + sym = syms[0]; + + if (state == WL_KEYBOARD_KEY_STATE_RELEASED && key == input->repeat_key) + { + its.it_interval.tv_sec = 0; + its.it_interval.tv_nsec = 0; + its.it_value.tv_sec = 0; + its.it_value.tv_nsec = 0; + timerfd_settime(input->repeat_timer_fd, 0, &its, NULL); + } + else if (state == WL_KEYBOARD_KEY_STATE_PRESSED && + xkb_keymap_key_repeats(input->xkb.keymap, code)) + { + input->repeat_sym = sym; + input->repeat_key = key; + input->repeat_time = time; + its.it_interval.tv_sec = input->repeat_rate_sec; + its.it_interval.tv_nsec = input->repeat_rate_nsec; + its.it_value.tv_sec = input->repeat_delay_sec; + its.it_value.tv_nsec = input->repeat_delay_nsec; + timerfd_settime(input->repeat_timer_fd, 0, &its, NULL); + } + + keyEvent = (UwacKeyEvent*)UwacDisplayNewEvent(input->display, UWAC_EVENT_KEY); + if (!keyEvent) + return; + + keyEvent->window = window; + keyEvent->sym = sym; + keyEvent->raw_key = key; + keyEvent->pressed = (state == WL_KEYBOARD_KEY_STATE_PRESSED); + keyEvent->repeated = false; +} + +static void keyboard_handle_modifiers(void* data, struct wl_keyboard* keyboard, uint32_t serial, + uint32_t mods_depressed, uint32_t mods_latched, + uint32_t mods_locked, uint32_t group) +{ + UwacSeat* input = data; + assert(input); + + UwacKeyboardModifiersEvent* event = NULL; + xkb_mod_mask_t mask = 0; + + /* If we're not using a keymap, then we don't handle PC-style modifiers */ + if (!input->xkb.keymap) + return; + + xkb_state_update_mask(input->xkb.state, mods_depressed, mods_latched, mods_locked, 0, 0, group); + mask = xkb_state_serialize_mods(input->xkb.state, XKB_STATE_MODS_DEPRESSED | + XKB_STATE_MODS_LATCHED | + XKB_STATE_MODS_LOCKED); + input->modifiers = 0; + if (mask & input->xkb.control_mask) + input->modifiers |= UWAC_MOD_CONTROL_MASK; + if (mask & input->xkb.alt_mask) + input->modifiers |= UWAC_MOD_ALT_MASK; + if (mask & input->xkb.shift_mask) + input->modifiers |= UWAC_MOD_SHIFT_MASK; + if (mask & input->xkb.caps_mask) + input->modifiers |= UWAC_MOD_CAPS_MASK; + if (mask & input->xkb.num_mask) + input->modifiers |= UWAC_MOD_NUM_MASK; + + event = (UwacKeyboardModifiersEvent*)UwacDisplayNewEvent(input->display, + UWAC_EVENT_KEYBOARD_MODIFIERS); + if (!event) + return; + + event->modifiers = input->modifiers; +} + +static void set_repeat_info(UwacSeat* input, int32_t rate, int32_t delay) +{ + assert(input); + + input->repeat_rate_sec = input->repeat_rate_nsec = 0; + input->repeat_delay_sec = input->repeat_delay_nsec = 0; + + /* a rate of zero disables any repeating, regardless of the delay's + * value */ + if (rate == 0) + return; + + if (rate == 1) + input->repeat_rate_sec = 1; + else + input->repeat_rate_nsec = 1000000000 / rate; + + input->repeat_delay_sec = delay / 1000; + delay -= (input->repeat_delay_sec * 1000); + input->repeat_delay_nsec = delay * 1000 * 1000; +} + +static void keyboard_handle_repeat_info(void* data, struct wl_keyboard* keyboard, int32_t rate, + int32_t delay) +{ + UwacSeat* input = data; + assert(input); + + set_repeat_info(input, rate, delay); +} + +static const struct wl_keyboard_listener keyboard_listener = { + keyboard_handle_keymap, keyboard_handle_enter, keyboard_handle_leave, + keyboard_handle_key, keyboard_handle_modifiers, keyboard_handle_repeat_info +}; + +static bool touch_send_start_frame(UwacSeat* seat) +{ + assert(seat); + + UwacTouchFrameBegin* ev = + (UwacTouchFrameBegin*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_TOUCH_FRAME_BEGIN); + if (!ev) + return false; + + seat->touch_frame_started = true; + return true; +} + +static void touch_handle_down(void* data, struct wl_touch* wl_touch, uint32_t serial, uint32_t time, + struct wl_surface* surface, int32_t id, wl_fixed_t x_w, + wl_fixed_t y_w) +{ + UwacSeat* seat = data; + UwacTouchDown* tdata = NULL; + + assert(seat); + assert(seat->display); + + seat->display->serial = serial; + if (!seat->touch_frame_started && !touch_send_start_frame(seat)) + return; + + tdata = (UwacTouchDown*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_TOUCH_DOWN); + if (!tdata) + return; + + tdata->seat = seat; + tdata->id = id; + + float sx = wl_fixed_to_double(x_w); + float sy = wl_fixed_to_double(y_w); + + tdata->x = sx; + tdata->y = sy; + +#if 0 + struct widget *widget; + float sx = wl_fixed_to_double(x); + float sy = wl_fixed_to_double(y); + + + input->touch_focus = wl_surface_get_user_data(surface); + if (!input->touch_focus) { + DBG("Failed to find to touch focus for surface %p\n", (void*) surface); + return; + } + + if (surface != input->touch_focus->main_surface->surface) { + DBG("Ignoring input event from subsurface %p\n", (void*) surface); + input->touch_focus = NULL; + return; + } + + if (input->grab) + widget = input->grab; + else + widget = window_find_widget(input->touch_focus, + wl_fixed_to_double(x), + wl_fixed_to_double(y)); + if (widget) { + struct touch_point *tp = xmalloc(sizeof *tp); + if (tp) { + tp->id = id; + tp->widget = widget; + tp->x = sx; + tp->y = sy; + wl_list_insert(&input->touch_point_list, &tp->link); + + if (widget->touch_down_handler) + (*widget->touch_down_handler)(widget, input, + serial, time, id, + sx, sy, + widget->user_data); + } + } +#endif +} + +static void touch_handle_up(void* data, struct wl_touch* wl_touch, uint32_t serial, uint32_t time, + int32_t id) +{ + UwacSeat* seat = data; + UwacTouchUp* tdata = NULL; + + assert(seat); + + if (!seat->touch_frame_started && !touch_send_start_frame(seat)) + return; + + tdata = (UwacTouchUp*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_TOUCH_UP); + if (!tdata) + return; + + tdata->seat = seat; + tdata->id = id; + +#if 0 + struct touch_point *tp, *tmp; + + if (!input->touch_focus) { + DBG("No touch focus found for touch up event!\n"); + return; + } + + wl_list_for_each_safe(tp, tmp, &input->touch_point_list, link) { + if (tp->id != id) + continue; + + if (tp->widget->touch_up_handler) + (*tp->widget->touch_up_handler)(tp->widget, input, serial, + time, id, + tp->widget->user_data); + + wl_list_remove(&tp->link); + free(tp); + + return; + } +#endif +} + +static void touch_handle_motion(void* data, struct wl_touch* wl_touch, uint32_t time, int32_t id, + wl_fixed_t x_w, wl_fixed_t y_w) +{ + UwacSeat* seat = data; + assert(seat); + + UwacTouchMotion* tdata = NULL; + + if (!seat->touch_frame_started && !touch_send_start_frame(seat)) + return; + + tdata = (UwacTouchMotion*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_TOUCH_MOTION); + if (!tdata) + return; + + tdata->seat = seat; + tdata->id = id; + + float sx = wl_fixed_to_double(x_w); + float sy = wl_fixed_to_double(y_w); + + tdata->x = sx; + tdata->y = sy; + +#if 0 + struct touch_point *tp; + float sx = wl_fixed_to_double(x); + float sy = wl_fixed_to_double(y); + + DBG("touch_handle_motion: %i %i\n", id, wl_list_length(&seat->touch_point_list)); + + if (!seat->touch_focus) { + DBG("No touch focus found for touch motion event!\n"); + return; + } + + wl_list_for_each(tp, &seat->touch_point_list, link) { + if (tp->id != id) + continue; + + tp->x = sx; + tp->y = sy; + if (tp->widget->touch_motion_handler) + (*tp->widget->touch_motion_handler)(tp->widget, seat, time, + id, sx, sy, + tp->widget->user_data); + return; + } +#endif +} + +static void touch_handle_frame(void* data, struct wl_touch* wl_touch) +{ + UwacSeat* seat = data; + assert(seat); + + UwacTouchFrameEnd* ev = + (UwacTouchFrameEnd*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_TOUCH_FRAME_END); + if (!ev) + return; + + ev->seat = seat; + seat->touch_frame_started = false; +} + +static void touch_handle_cancel(void* data, struct wl_touch* wl_touch) +{ + UwacSeat* seat = data; + assert(seat); + + UwacTouchCancel* ev = + (UwacTouchCancel*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_TOUCH_CANCEL); + if (!ev) + return; + + ev->seat = seat; + seat->touch_frame_started = false; + +#if 0 + struct touch_point *tp, *tmp; + + DBG("touch_handle_cancel\n"); + + if (!input->touch_focus) { + DBG("No touch focus found for touch cancel event!\n"); + return; + } + + wl_list_for_each_safe(tp, tmp, &input->touch_point_list, link) { + if (tp->widget->touch_cancel_handler) + (*tp->widget->touch_cancel_handler)(tp->widget, input, + tp->widget->user_data); + + wl_list_remove(&tp->link); + free(tp); + } +#endif +} + +static void touch_handle_shape(void* data, struct wl_touch* wl_touch, int32_t id, wl_fixed_t major, + wl_fixed_t minor) +{ + UwacSeat* seat = data; + assert(seat); + + // TODO +} + +static void touch_handle_orientation(void* data, struct wl_touch* wl_touch, int32_t id, + wl_fixed_t orientation) +{ + UwacSeat* seat = data; + assert(seat); + + // TODO +} + +static const struct wl_touch_listener touch_listener = { + touch_handle_down, touch_handle_up, touch_handle_motion, touch_handle_frame, + touch_handle_cancel, touch_handle_shape, touch_handle_orientation +}; + +static void pointer_handle_enter(void* data, struct wl_pointer* pointer, uint32_t serial, + struct wl_surface* surface, wl_fixed_t sx_w, wl_fixed_t sy_w) +{ + UwacSeat* input = data; + UwacWindow* window = NULL; + UwacPointerEnterLeaveEvent* event = NULL; + + assert(input); + + float sx = wl_fixed_to_double(sx_w); + float sy = wl_fixed_to_double(sy_w); + + if (!surface) + { + /* enter event for a window we've just destroyed */ + return; + } + + input->display->serial = serial; + input->display->pointer_focus_serial = serial; + window = wl_surface_get_user_data(surface); + if (window) + window->pointer_enter_serial = serial; + input->pointer_focus = window; + input->sx = sx; + input->sy = sy; + + event = + (UwacPointerEnterLeaveEvent*)UwacDisplayNewEvent(input->display, UWAC_EVENT_POINTER_ENTER); + if (!event) + return; + + event->seat = input; + event->window = window; + event->x = sx; + event->y = sy; + + /* Apply cursor theme */ + set_cursor_image(input, serial); +} + +static void pointer_handle_leave(void* data, struct wl_pointer* pointer, uint32_t serial, + struct wl_surface* surface) +{ + UwacPointerEnterLeaveEvent* event = NULL; + UwacWindow* window = NULL; + UwacSeat* input = data; + assert(input); + + input->display->serial = serial; + + event = + (UwacPointerEnterLeaveEvent*)UwacDisplayNewEvent(input->display, UWAC_EVENT_POINTER_LEAVE); + if (!event) + return; + + window = wl_surface_get_user_data(surface); + + event->seat = input; + event->window = window; +} + +static void pointer_handle_motion(void* data, struct wl_pointer* pointer, uint32_t time, + wl_fixed_t sx_w, wl_fixed_t sy_w) +{ + UwacPointerMotionEvent* motion_event = NULL; + UwacSeat* input = data; + assert(input); + + UwacWindow* window = input->pointer_focus; + + int scale = window->display->actual_scale; + int sx_i = wl_fixed_to_int(sx_w) * scale; + int sy_i = wl_fixed_to_int(sy_w) * scale; + double sx_d = wl_fixed_to_double(sx_w) * scale; + double sy_d = wl_fixed_to_double(sy_w) * scale; + + if (!window || (sx_i < 0) || (sy_i < 0)) + return; + + input->sx = sx_d; + input->sy = sy_d; + + motion_event = + (UwacPointerMotionEvent*)UwacDisplayNewEvent(input->display, UWAC_EVENT_POINTER_MOTION); + if (!motion_event) + return; + + motion_event->seat = input; + motion_event->window = window; + motion_event->x = sx_i; + motion_event->y = sy_i; +} + +static void pointer_handle_button(void* data, struct wl_pointer* pointer, uint32_t serial, + uint32_t time, uint32_t button, uint32_t state_w) +{ + UwacPointerButtonEvent* event = NULL; + UwacSeat* seat = data; + assert(seat); + + UwacWindow* window = seat->pointer_focus; + + seat->display->serial = serial; + + event = (UwacPointerButtonEvent*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_POINTER_BUTTONS); + if (!event) + return; + + event->seat = seat; + event->window = window; + event->x = seat->sx; + event->y = seat->sy; + event->button = button; + event->state = (enum wl_pointer_button_state)state_w; +} + +static void pointer_handle_axis(void* data, struct wl_pointer* pointer, uint32_t time, + uint32_t axis, wl_fixed_t value) +{ + UwacPointerAxisEvent* event = NULL; + UwacSeat* seat = data; + assert(seat); + + UwacWindow* window = seat->pointer_focus; + + if (!window) + return; + + event = (UwacPointerAxisEvent*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_POINTER_AXIS); + if (!event) + return; + + event->seat = seat; + event->window = window; + event->x = seat->sx; + event->y = seat->sy; + event->axis = axis; + event->value = value; +} + +static void pointer_frame(void* data, struct wl_pointer* wl_pointer) +{ + UwacPointerFrameEvent* event = NULL; + UwacSeat* seat = data; + assert(seat); + + UwacWindow* window = seat->pointer_focus; + + if (!window) + return; + + event = (UwacPointerFrameEvent*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_POINTER_FRAME); + if (!event) + return; + + event->seat = seat; + event->window = window; +} + +static void pointer_axis_source(void* data, struct wl_pointer* wl_pointer, uint32_t axis_source) +{ + UwacPointerSourceEvent* event = NULL; + UwacSeat* seat = data; + assert(seat); + + UwacWindow* window = seat->pointer_focus; + + if (!window) + return; + + event = (UwacPointerSourceEvent*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_POINTER_SOURCE); + if (!event) + return; + + event->seat = seat; + event->window = window; + event->axis_source = axis_source; +} + +static void pointer_axis_stop(void* data, struct wl_pointer* wl_pointer, uint32_t time, + uint32_t axis) +{ + UwacSeat* seat = data; + assert(seat); +} + +static void pointer_axis_discrete(void* data, struct wl_pointer* wl_pointer, uint32_t axis, + int32_t discrete) +{ + /*UwacSeat *seat = data;*/ + UwacPointerAxisEvent* event = NULL; + UwacSeat* seat = data; + assert(seat); + + UwacWindow* window = seat->pointer_focus; + + if (!window) + return; + + event = + (UwacPointerAxisEvent*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_POINTER_AXIS_DISCRETE); + if (!event) + return; + + event->seat = seat; + event->window = window; + event->x = seat->sx; + event->y = seat->sy; + event->axis = axis; + event->value = discrete; +} + +static void pointer_axis_value120(void* data, struct wl_pointer* wl_pointer, uint32_t axis, + int32_t value120) +{ + /*UwacSeat *seat = data;*/ + UwacPointerAxisEvent* event = NULL; + UwacSeat* seat = data; + assert(seat); + + UwacWindow* window = seat->pointer_focus; + + if (!window) + return; + + event = + (UwacPointerAxisEvent*)UwacDisplayNewEvent(seat->display, UWAC_EVENT_POINTER_AXIS_DISCRETE); + if (!event) + return; + + event->seat = seat; + event->window = window; + event->x = seat->sx; + event->y = seat->sy; + event->axis = axis; + event->value = value120 / 120; +} + +static const struct wl_pointer_listener pointer_listener = { + pointer_handle_enter, pointer_handle_leave, pointer_handle_motion, pointer_handle_button, + pointer_handle_axis, pointer_frame, pointer_axis_source, pointer_axis_stop, + pointer_axis_discrete, pointer_axis_value120 +}; + +static void seat_handle_capabilities(void* data, struct wl_seat* seat, enum wl_seat_capability caps) +{ + UwacSeat* input = data; + assert(input); + + if ((caps & WL_SEAT_CAPABILITY_POINTER) && !input->pointer) + { + input->pointer = wl_seat_get_pointer(seat); + wl_pointer_set_user_data(input->pointer, input); + wl_pointer_add_listener(input->pointer, &pointer_listener, input); + + input->cursor_theme = wl_cursor_theme_load(NULL, 32, input->display->shm); + if (!input->cursor_theme) + { + assert(uwacErrorHandler(input->display, UWAC_ERROR_NOMEMORY, + "unable to get wayland cursor theme\n")); + return; + } + + input->default_cursor = wl_cursor_theme_get_cursor(input->cursor_theme, "left_ptr"); + if (!input->default_cursor) + { + assert(uwacErrorHandler(input->display, UWAC_ERROR_NOMEMORY, + "unable to get wayland cursor left_ptr\n")); + return; + } + } + else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && input->pointer) + { +#ifdef WL_POINTER_RELEASE_SINCE_VERSION + if (input->seat_version >= WL_POINTER_RELEASE_SINCE_VERSION) + wl_pointer_release(input->pointer); + else +#endif + wl_pointer_destroy(input->pointer); + if (input->cursor_theme) + wl_cursor_theme_destroy(input->cursor_theme); + + input->default_cursor = NULL; + input->cursor_theme = NULL; + input->pointer = NULL; + } + + if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !input->keyboard) + { + input->keyboard = wl_seat_get_keyboard(seat); + wl_keyboard_set_user_data(input->keyboard, input); + wl_keyboard_add_listener(input->keyboard, &keyboard_listener, input); + } + else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && input->keyboard) + { +#ifdef WL_KEYBOARD_RELEASE_SINCE_VERSION + if (input->seat_version >= WL_KEYBOARD_RELEASE_SINCE_VERSION) + wl_keyboard_release(input->keyboard); + else +#endif + wl_keyboard_destroy(input->keyboard); + input->keyboard = NULL; + } + + if ((caps & WL_SEAT_CAPABILITY_TOUCH) && !input->touch) + { + input->touch = wl_seat_get_touch(seat); + wl_touch_set_user_data(input->touch, input); + wl_touch_add_listener(input->touch, &touch_listener, input); + } + else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && input->touch) + { +#ifdef WL_TOUCH_RELEASE_SINCE_VERSION + if (input->seat_version >= WL_TOUCH_RELEASE_SINCE_VERSION) + wl_touch_release(input->touch); + else +#endif + wl_touch_destroy(input->touch); + input->touch = NULL; + } +} + +static void seat_handle_name(void* data, struct wl_seat* seat, const char* name) +{ + UwacSeat* input = data; + assert(input); + + if (input->name) + free(input->name); + + input->name = strdup(name); + if (!input->name) + assert(uwacErrorHandler(input->display, UWAC_ERROR_NOMEMORY, + "unable to strdup seat's name\n")); +} + +static const struct wl_seat_listener seat_listener = { seat_handle_capabilities, seat_handle_name }; + +UwacSeat* UwacSeatNew(UwacDisplay* d, uint32_t id, uint32_t version) +{ + UwacSeat* ret = xzalloc(sizeof(UwacSeat)); + if (!ret) + return NULL; + + ret->display = d; + ret->seat_id = id; + ret->seat_version = version; + + wl_array_init(&ret->pressed_keys); + ret->xkb_context = xkb_context_new(0); + if (!ret->xkb_context) + { + fprintf(stderr, "%s: unable to allocate a xkb_context\n", __func__); + goto fail; + } + + ret->seat = wl_registry_bind(d->registry, id, &wl_seat_interface, version); + wl_seat_add_listener(ret->seat, &seat_listener, ret); + wl_seat_set_user_data(ret->seat, ret); + + ret->repeat_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK); + if (ret->repeat_timer_fd < 0) + { + fprintf(stderr, "%s: error creating repeat timer\n", __func__); + goto fail; + } + ret->repeat_task.run = keyboard_repeat_func; + if (UwacDisplayWatchFd(d, ret->repeat_timer_fd, EPOLLIN, &ret->repeat_task) < 0) + { + fprintf(stderr, "%s: error polling repeat timer\n", __func__); + goto fail; + } + + wl_list_insert(d->seats.prev, &ret->link); + return ret; + +fail: + UwacSeatDestroy(ret); + return NULL; +} + +void UwacSeatDestroy(UwacSeat* s) +{ + if (!s) + return; + + UwacSeatInhibitShortcuts(s, false); + if (s->seat) + { +#ifdef WL_SEAT_RELEASE_SINCE_VERSION + if (s->seat_version >= WL_SEAT_RELEASE_SINCE_VERSION) + wl_seat_release(s->seat); + else +#endif + wl_seat_destroy(s->seat); + } + s->seat = NULL; + + free(s->name); + wl_array_release(&s->pressed_keys); + + xkb_state_unref(s->xkb.state); + xkb_context_unref(s->xkb_context); + + if (s->pointer) + { +#ifdef WL_POINTER_RELEASE_SINCE_VERSION + if (s->seat_version >= WL_POINTER_RELEASE_SINCE_VERSION) + wl_pointer_release(s->pointer); + else +#endif + wl_pointer_destroy(s->pointer); + } + + if (s->touch) + { +#ifdef WL_TOUCH_RELEASE_SINCE_VERSION + if (s->seat_version >= WL_TOUCH_RELEASE_SINCE_VERSION) + wl_touch_release(s->touch); + else +#endif + wl_touch_destroy(s->touch); + } + + if (s->keyboard) + { +#ifdef WL_KEYBOARD_RELEASE_SINCE_VERSION + if (s->seat_version >= WL_KEYBOARD_RELEASE_SINCE_VERSION) + wl_keyboard_release(s->keyboard); + else +#endif + wl_keyboard_destroy(s->keyboard); + } + + if (s->data_device) + wl_data_device_destroy(s->data_device); + + if (s->data_source) + wl_data_source_destroy(s->data_source); + + if (s->pointer_surface) + wl_surface_destroy(s->pointer_surface); + + free(s->pointer_image); + free(s->pointer_data); + + wl_list_remove(&s->link); + free(s); +} + +const char* UwacSeatGetName(const UwacSeat* seat) +{ + assert(seat); + return seat->name; +} + +UwacSeatId UwacSeatGetId(const UwacSeat* seat) +{ + assert(seat); + return seat->seat_id; +} + +UwacReturnCode UwacSeatInhibitShortcuts(UwacSeat* s, bool inhibit) +{ + if (!s) + return UWAC_ERROR_CLOSED; + + if (s->keyboard_inhibitor) + { + zwp_keyboard_shortcuts_inhibitor_v1_destroy(s->keyboard_inhibitor); + s->keyboard_inhibitor = NULL; + } + if (inhibit && s->display && s->display->keyboard_inhibit_manager) + s->keyboard_inhibitor = zwp_keyboard_shortcuts_inhibit_manager_v1_inhibit_shortcuts( + s->display->keyboard_inhibit_manager, s->keyboard_focus->surface, s->seat); + + if (inhibit && !s->keyboard_inhibitor) + return UWAC_ERROR_INTERNAL; + return UWAC_SUCCESS; +} + +UwacReturnCode UwacSeatSetMouseCursor(UwacSeat* seat, const void* data, size_t length, size_t width, + size_t height, size_t hot_x, size_t hot_y) +{ + if (!seat) + return UWAC_ERROR_CLOSED; + + free(seat->pointer_image); + seat->pointer_image = NULL; + + free(seat->pointer_data); + seat->pointer_data = NULL; + seat->pointer_size = 0; + + /* There is a cursor provided */ + if ((data != NULL) && (length != 0)) + { + seat->pointer_image = xzalloc(sizeof(struct wl_cursor_image)); + if (!seat->pointer_image) + return UWAC_ERROR_NOMEMORY; + seat->pointer_image->width = width; + seat->pointer_image->height = height; + seat->pointer_image->hotspot_x = hot_x; + seat->pointer_image->hotspot_y = hot_y; + + free(seat->pointer_data); + seat->pointer_data = xmalloc(length); + memcpy(seat->pointer_data, data, length); + seat->pointer_size = length; + + seat->pointer_type = 2; + } + /* We want to use the system cursor */ + else if (length != 0) + { + seat->pointer_type = 0; + } + /* Hide the cursor */ + else + { + seat->pointer_type = 1; + } + if (seat && !seat->default_cursor) + return UWAC_SUCCESS; + return set_cursor_image(seat, seat->display->pointer_focus_serial); +} diff --git a/uwac/libuwac/uwac-os.c b/uwac/libuwac/uwac-os.c new file mode 100644 index 0000000..c51c5a2 --- /dev/null +++ b/uwac/libuwac/uwac-os.c @@ -0,0 +1,290 @@ +/* + * Copyright © 2012 Collabora, Ltd. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +/* + * This file is an adaptation of src/wayland-os.h from the wayland project and + * shared/os-compatiblity.h from the weston project. + * + * Functions have been renamed just to prevent name clashes. + */ + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wreserved-id-macro" +#endif + +#define _GNU_SOURCE + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + +#if defined(__FreeBSD__) || defined(__DragonFly__) +#define USE_SHM +#endif + +/* uClibc and uClibc-ng don't provide O_TMPFILE */ +#if !defined(O_TMPFILE) && !defined(__FreeBSD__) +#define O_TMPFILE (020000000 | O_DIRECTORY) +#endif + +#include <sys/types.h> +#include <sys/socket.h> +#ifdef USE_SHM +#include <sys/mman.h> +#endif +#include <unistd.h> +#include <fcntl.h> +#include <errno.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <sys/epoll.h> + +#include <uwac/config.h> + +#include "uwac-os.h" +#include "uwac-utils.h" + +static int set_cloexec_or_close(int fd) +{ + long flags = 0; + + if (fd == -1) + return -1; + + flags = fcntl(fd, F_GETFD); + + if (flags == -1) + goto err; + + if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) + goto err; + + return fd; +err: + close(fd); + return -1; +} + +int uwac_os_socket_cloexec(int domain, int type, int protocol) +{ + int fd = 0; + fd = socket(domain, type | SOCK_CLOEXEC, protocol); + + if (fd >= 0) + return fd; + + if (errno != EINVAL) + return -1; + + fd = socket(domain, type, protocol); + return set_cloexec_or_close(fd); +} + +int uwac_os_dupfd_cloexec(int fd, long minfd) +{ + int newfd = 0; + newfd = fcntl(fd, F_DUPFD_CLOEXEC, minfd); + + if (newfd >= 0) + return newfd; + + if (errno != EINVAL) + return -1; + + newfd = fcntl(fd, F_DUPFD, minfd); + return set_cloexec_or_close(newfd); +} + +static ssize_t recvmsg_cloexec_fallback(int sockfd, struct msghdr* msg, int flags) +{ + ssize_t len = 0; + struct cmsghdr* cmsg = NULL; + unsigned char* data = NULL; + int* end = NULL; + len = recvmsg(sockfd, msg, flags); + + if (len == -1) + return -1; + + if (!msg->msg_control || msg->msg_controllen == 0) + return len; + + cmsg = CMSG_FIRSTHDR(msg); + + for (; cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg)) + { + if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) + continue; + + data = CMSG_DATA(cmsg); + end = (int*)(data + cmsg->cmsg_len - CMSG_LEN(0)); + + for (int* fd = (int*)data; fd < end; ++fd) + *fd = set_cloexec_or_close(*fd); + } + + return len; +} + +ssize_t uwac_os_recvmsg_cloexec(int sockfd, struct msghdr* msg, int flags) +{ + ssize_t len = 0; + len = recvmsg(sockfd, msg, flags | MSG_CMSG_CLOEXEC); + + if (len >= 0) + return len; + + if (errno != EINVAL) + return -1; + + return recvmsg_cloexec_fallback(sockfd, msg, flags); +} + +int uwac_os_epoll_create_cloexec(void) +{ + int fd = 0; +#ifdef EPOLL_CLOEXEC + fd = epoll_create1(EPOLL_CLOEXEC); + + if (fd >= 0) + return fd; + + if (errno != EINVAL) + return -1; + +#endif + fd = epoll_create(1); + return set_cloexec_or_close(fd); +} + +static int create_tmpfile_cloexec(char* tmpname) +{ + int fd = 0; +#ifdef USE_SHM + fd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600); +#elif defined(UWAC_HAVE_MKOSTEMP) + fd = mkostemp(tmpname, O_CLOEXEC); + + if (fd >= 0) + unlink(tmpname); + +#else + fd = mkstemp(tmpname); + + if (fd >= 0) + { + fd = set_cloexec_or_close(fd); + unlink(tmpname); + } + +#endif + return fd; +} + +/* + * Create a new, unique, anonymous file of the given size, and + * return the file descriptor for it. The file descriptor is set + * CLOEXEC. The file is immediately suitable for mmap()'ing + * the given size at offset zero. + * + * The file should not have a permanent backing store like a disk, + * but may have if XDG_RUNTIME_DIR is not properly implemented in OS. + * + * The file name is deleted from the file system. + * + * The file is suitable for buffer sharing between processes by + * transmitting the file descriptor over Unix sockets using the + * SCM_RIGHTS methods. + * + * If the C library implements posix_fallocate(), it is used to + * guarantee that disk space is available for the file at the + * given size. If disk space is insufficient, errno is set to ENOSPC. + * If posix_fallocate() is not supported, program may receive + * SIGBUS on accessing mmap()'ed file contents instead. + */ +int uwac_create_anonymous_file(off_t size) +{ + static const char template[] = "/weston-shared-XXXXXX"; + size_t length = 0; + char* name = NULL; + const char* path = NULL; + int fd = 0; + int ret = 0; + path = getenv("XDG_RUNTIME_DIR"); + + if (!path) + { + errno = ENOENT; + return -1; + } + +#ifdef O_TMPFILE + fd = open(path, O_TMPFILE | O_RDWR | O_EXCL, 0600); +#else + /* + * Some platforms (e.g. FreeBSD) won't support O_TMPFILE and can't + * reasonably emulate it at first blush. Opt to make them rely on + * the create_tmpfile_cloexec() path instead. + */ + fd = -1; +#endif + + if (fd < 0) + { + length = strlen(path) + sizeof(template); + name = xmalloc(length); + + if (!name) + return -1; + + snprintf(name, length, "%s%s", path, template); + fd = create_tmpfile_cloexec(name); + free(name); + } + + if (fd < 0) + return -1; + +#ifdef UWAC_HAVE_POSIX_FALLOCATE + ret = posix_fallocate(fd, 0, size); + + if (ret != 0) + { + close(fd); + errno = ret; + return -1; + } + +#else + ret = ftruncate(fd, size); + + if (ret < 0) + { + close(fd); + return -1; + } + +#endif + return fd; +} diff --git a/uwac/libuwac/uwac-os.h b/uwac/libuwac/uwac-os.h new file mode 100644 index 0000000..ef14bf4 --- /dev/null +++ b/uwac/libuwac/uwac-os.h @@ -0,0 +1,45 @@ +/* + * Copyright © 2012 Collabora, Ltd. + * Copyright © 2014 David FORT <contact@hardening-consulting.com> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +/* + * This file is an adaptation of src/wayland-os.h from the wayland project and + * shared/os-compatiblity.h from the weston project. + * + * Functions have been renamed just to prevent name clashes. + */ + +#ifndef UWAC_OS_H +#define UWAC_OS_H + +#include <sys/socket.h> + +int uwac_os_socket_cloexec(int domain, int type, int protocol); + +int uwac_os_dupfd_cloexec(int fd, long minfd); + +ssize_t uwac_os_recvmsg_cloexec(int sockfd, struct msghdr* msg, int flags); + +int uwac_os_epoll_create_cloexec(void); + +int uwac_create_anonymous_file(off_t size); +#endif /* UWAC_OS_H */ diff --git a/uwac/libuwac/uwac-output.c b/uwac/libuwac/uwac-output.c new file mode 100644 index 0000000..079018e --- /dev/null +++ b/uwac/libuwac/uwac-output.c @@ -0,0 +1,183 @@ +/* + * Copyright © 2014 David FORT <contact@hardening-consulting.com> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ +#include "uwac-priv.h" +#include "uwac-utils.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <assert.h> + +#define TARGET_OUTPUT_INTERFACE 2U + +static bool dupstr(char** dst, const char* src) +{ + assert(dst); + free(*dst); + *dst = NULL; + if (!src) + return true; + *dst = strdup(src); + return *dst != NULL; +} + +static void output_handle_geometry(void* data, struct wl_output* wl_output, int x, int y, + int physical_width, int physical_height, int subpixel, + const char* make, const char* model, int transform) +{ + UwacOutput* output = data; + assert(output); + + output->position.x = x; + output->position.y = y; + output->transform = transform; + + if (!dupstr(&output->make, make)) + { + assert(uwacErrorHandler(output->display, UWAC_ERROR_NOMEMORY, "%s: unable to strdup make\n", + __func__)); + } + + if (!dupstr(&output->model, model)) + { + assert(uwacErrorHandler(output->display, UWAC_ERROR_NOMEMORY, + "%s: unable to strdup model\n", __func__)); + } + + UwacEvent* event = UwacDisplayNewEvent(output->display, UWAC_EVENT_OUTPUT_GEOMETRY); + event->output_geometry.output = output; + event->output_geometry.x = x; + event->output_geometry.y = y; + event->output_geometry.physical_width = physical_width; + event->output_geometry.physical_height = physical_height; + event->output_geometry.subpixel = subpixel; + event->output_geometry.make = output->make; + event->output_geometry.model = output->model; + event->output_geometry.transform = transform; +} + +static void output_handle_done(void* data, struct wl_output* wl_output) +{ + UwacOutput* output = data; + assert(output); + + output->doneReceived = true; +} + +static void output_handle_scale(void* data, struct wl_output* wl_output, int32_t scale) +{ + UwacOutput* output = data; + assert(output); + + output->scale = scale; + if (scale > output->display->actual_scale) + output->display->actual_scale = scale; +} + +static void output_handle_name(void* data, struct wl_output* wl_output, const char* name) +{ + UwacOutput* output = data; + assert(output); + + if (!dupstr(&output->name, name)) + { + assert(uwacErrorHandler(output->display, UWAC_ERROR_NOMEMORY, "%s: unable to strdup make\n", + __func__)); + } +} + +static void output_handle_description(void* data, struct wl_output* wl_output, + const char* description) +{ + UwacOutput* output = data; + assert(output); + + if (!dupstr(&output->description, description)) + { + assert(uwacErrorHandler(output->display, UWAC_ERROR_NOMEMORY, "%s: unable to strdup make\n", + __func__)); + } +} + +static void output_handle_mode(void* data, struct wl_output* wl_output, uint32_t flags, int width, + int height, int refresh) +{ + UwacOutput* output = data; + assert(output); + // UwacDisplay *display = output->display; + + if (output->doneNeeded && output->doneReceived) + { + /* TODO: we should clear the mode list */ + } + + if (flags & WL_OUTPUT_MODE_CURRENT) + { + output->resolution.width = width; + output->resolution.height = height; + /* output->allocation.width = width; + output->allocation.height = height; + if (display->output_configure_handler) + (*display->output_configure_handler)( + output, display->user_data);*/ + } +} + +static const struct wl_output_listener output_listener = { + output_handle_geometry, output_handle_mode, output_handle_done, + output_handle_scale, output_handle_name, output_handle_description +}; + +UwacOutput* UwacCreateOutput(UwacDisplay* d, uint32_t id, uint32_t version) +{ + UwacOutput* o = xzalloc(sizeof *o); + if (!o) + return NULL; + + o->display = d; + o->server_output_id = id; + o->doneNeeded = (version > 1); + o->doneReceived = false; + o->output = wl_registry_bind(d->registry, id, &wl_output_interface, + min(TARGET_OUTPUT_INTERFACE, version)); + wl_output_add_listener(o->output, &output_listener, o); + + wl_list_insert(d->outputs.prev, &o->link); + return o; +} + +int UwacDestroyOutput(UwacOutput* output) +{ + if (!output) + return UWAC_SUCCESS; + + free(output->make); + free(output->model); + free(output->name); + free(output->description); + + wl_output_destroy(output->output); + wl_list_remove(&output->link); + free(output); + + return UWAC_SUCCESS; +} diff --git a/uwac/libuwac/uwac-priv.h b/uwac/libuwac/uwac-priv.h new file mode 100644 index 0000000..68799f4 --- /dev/null +++ b/uwac/libuwac/uwac-priv.h @@ -0,0 +1,291 @@ +/* + * Copyright © 2014 David FORT <contact@hardening-consulting.com> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef UWAC_PRIV_H_ +#define UWAC_PRIV_H_ + +#include <uwac/config.h> + +#include <stdbool.h> +#include <wayland-client.h> +#include "xdg-shell-client-protocol.h" +#include "keyboard-shortcuts-inhibit-unstable-v1-client-protocol.h" +#include "xdg-decoration-unstable-v1-client-protocol.h" +#include "server-decoration-client-protocol.h" +#include "viewporter-client-protocol.h" + +#ifdef BUILD_IVI +#include "ivi-application-client-protocol.h" +#endif +#ifdef BUILD_FULLSCREEN_SHELL +#include "fullscreen-shell-unstable-v1-client-protocol.h" +#endif + +#ifdef UWAC_HAVE_PIXMAN_REGION +#include <pixman-1/pixman.h> +#else +#include <freerdp/codec/region.h> +#endif + +#include <xkbcommon/xkbcommon.h> + +#include <uwac/uwac.h> + +extern UwacErrorHandler uwacErrorHandler; + +typedef struct uwac_task UwacTask; + +/** @brief task struct + */ +struct uwac_task +{ + void (*run)(UwacTask* task, uint32_t events); + struct wl_list link; +}; + +/** @brief a global registry object + */ +struct uwac_global +{ + uint32_t name; + char* interface; + uint32_t version; + struct wl_list link; +}; +typedef struct uwac_global UwacGlobal; + +struct uwac_event_list_item; +typedef struct uwac_event_list_item UwacEventListItem; + +/** @brief double linked list element + */ +struct uwac_event_list_item +{ + UwacEvent event; + UwacEventListItem *tail, *head; +}; + +/** @brief main connection object to a wayland display + */ +struct uwac_display +{ + struct wl_list globals; + + struct wl_display* display; + struct wl_registry* registry; + struct wl_compositor* compositor; + struct wp_viewporter* viewporter; + struct wl_subcompositor* subcompositor; + struct wl_shell* shell; + struct xdg_toplevel* xdg_toplevel; + struct xdg_wm_base* xdg_base; + struct wl_data_device_manager* devicemanager; + struct zwp_keyboard_shortcuts_inhibit_manager_v1* keyboard_inhibit_manager; + struct zxdg_decoration_manager_v1* deco_manager; + struct org_kde_kwin_server_decoration_manager* kde_deco_manager; +#ifdef BUILD_IVI + struct ivi_application* ivi_application; +#endif +#ifdef BUILD_FULLSCREEN_SHELL + struct zwp_fullscreen_shell_v1* fullscreen_shell; +#endif + + struct wl_shm* shm; + enum wl_shm_format* shm_formats; + uint32_t shm_formats_nb; + bool has_rgb565; + + struct wl_data_device_manager* data_device_manager; + struct text_cursor_position* text_cursor_position; + struct workspace_manager* workspace_manager; + + struct wl_list seats; + + int display_fd; + UwacReturnCode last_error; + uint32_t display_fd_events; + int epoll_fd; + bool running; + UwacTask dispatch_fd_task; + uint32_t serial; + uint32_t pointer_focus_serial; + int actual_scale; + + struct wl_list windows; + + struct wl_list outputs; + + UwacEventListItem *push_queue, *pop_queue; +}; + +/** @brief an output on a wayland display */ +struct uwac_output +{ + UwacDisplay* display; + + bool doneNeeded; + bool doneReceived; + + UwacPosition position; + UwacSize resolution; + int transform; + int scale; + char* make; + char* model; + uint32_t server_output_id; + struct wl_output* output; + + struct wl_list link; + char* name; + char* description; +}; + +/** @brief a seat attached to a wayland display */ +struct uwac_seat +{ + UwacDisplay* display; + char* name; + struct wl_seat* seat; + uint32_t seat_id; + uint32_t seat_version; + struct wl_data_device* data_device; + struct wl_data_source* data_source; + struct wl_pointer* pointer; + struct wl_surface* pointer_surface; + struct wl_cursor_image* pointer_image; + struct wl_cursor_theme* cursor_theme; + struct wl_cursor* default_cursor; + void* pointer_data; + size_t pointer_size; + int pointer_type; + struct wl_keyboard* keyboard; + struct wl_touch* touch; + struct wl_data_offer* offer; + struct xkb_context* xkb_context; + struct zwp_keyboard_shortcuts_inhibitor_v1* keyboard_inhibitor; + + struct + { + struct xkb_keymap* keymap; + struct xkb_state* state; + xkb_mod_mask_t control_mask; + xkb_mod_mask_t alt_mask; + xkb_mod_mask_t shift_mask; + xkb_mod_mask_t caps_mask; + xkb_mod_mask_t num_mask; + } xkb; + uint32_t modifiers; + int32_t repeat_rate_sec, repeat_rate_nsec; + int32_t repeat_delay_sec, repeat_delay_nsec; + uint32_t repeat_sym, repeat_key, repeat_time; + + struct wl_array pressed_keys; + + UwacWindow* pointer_focus; + + UwacWindow* keyboard_focus; + + UwacWindow* touch_focus; + bool touch_frame_started; + + int repeat_timer_fd; + UwacTask repeat_task; + float sx, sy; + struct wl_list link; + + void* data_context; + UwacDataTransferHandler transfer_data; + UwacCancelDataTransferHandler cancel_data; + bool ignore_announcement; +}; + +/** @brief a buffer used for drawing a surface frame */ +struct uwac_buffer +{ + bool used; + bool dirty; +#ifdef UWAC_HAVE_PIXMAN_REGION + pixman_region32_t damage; +#else + REGION16 damage; +#endif + struct wl_buffer* wayland_buffer; + void* data; + size_t size; +}; +typedef struct uwac_buffer UwacBuffer; + +/** @brief a window */ +struct uwac_window +{ + UwacDisplay* display; + int width, height, stride; + int surfaceStates; + enum wl_shm_format format; + + int nbuffers; + UwacBuffer* buffers; + + struct wl_region* opaque_region; + struct wl_region* input_region; + ssize_t drawingBufferIdx; + ssize_t pendingBufferIdx; + struct wl_surface* surface; + struct wp_viewport* viewport; + struct wl_shell_surface* shell_surface; + struct xdg_surface* xdg_surface; + struct xdg_toplevel* xdg_toplevel; + struct zxdg_toplevel_decoration_v1* deco; + struct org_kde_kwin_server_decoration* kde_deco; +#ifdef BUILD_IVI + struct ivi_surface* ivi_surface; +#endif + struct wl_list link; + + uint32_t pointer_enter_serial; + uint32_t pointer_cursor_serial; + int pointer_current_cursor; +}; + +/**@brief data to pass to wl_buffer release listener */ +struct uwac_buffer_release_data +{ + UwacWindow* window; + int bufferIdx; +}; +typedef struct uwac_buffer_release_data UwacBufferReleaseData; + +/* in uwa-display.c */ +UwacEvent* UwacDisplayNewEvent(UwacDisplay* d, int type); +int UwacDisplayWatchFd(UwacDisplay* display, int fd, uint32_t events, UwacTask* task); + +/* in uwac-input.c */ +UwacSeat* UwacSeatNew(UwacDisplay* d, uint32_t id, uint32_t version); +void UwacSeatDestroy(UwacSeat* s); + +/* in uwac-output.c */ +UwacOutput* UwacCreateOutput(UwacDisplay* d, uint32_t id, uint32_t version); +int UwacDestroyOutput(UwacOutput* output); + +UwacReturnCode UwacSeatRegisterClipboard(UwacSeat* s); + +#endif /* UWAC_PRIV_H_ */ diff --git a/uwac/libuwac/uwac-tools.c b/uwac/libuwac/uwac-tools.c new file mode 100644 index 0000000..760970e --- /dev/null +++ b/uwac/libuwac/uwac-tools.c @@ -0,0 +1,106 @@ +/* + * Copyright © 2015 David FORT <contact@hardening-consulting.com> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#include <wayland-util.h> +#include <string.h> +#include <uwac/uwac-tools.h> + +struct uwac_touch_automata +{ + struct wl_array tp; +}; + +void UwacTouchAutomataInit(UwacTouchAutomata* automata) +{ + wl_array_init(&automata->tp); +} + +void UwacTouchAutomataReset(UwacTouchAutomata* automata) +{ + automata->tp.size = 0; +} + +bool UwacTouchAutomataInjectEvent(UwacTouchAutomata* automata, UwacEvent* event) +{ + + UwacTouchPoint* tp = NULL; + + switch (event->type) + { + case UWAC_EVENT_TOUCH_FRAME_BEGIN: + break; + + case UWAC_EVENT_TOUCH_UP: + { + UwacTouchUp* touchUp = &event->touchUp; + size_t toMove = automata->tp.size - sizeof(UwacTouchPoint); + + wl_array_for_each(tp, &automata->tp) + { + if ((int64_t)tp->id == touchUp->id) + { + if (toMove) + memmove(tp, tp + 1, toMove); + return true; + } + + toMove -= sizeof(UwacTouchPoint); + } + break; + } + + case UWAC_EVENT_TOUCH_DOWN: + { + UwacTouchDown* touchDown = &event->touchDown; + + wl_array_for_each(tp, &automata->tp) + { + if ((int64_t)tp->id == touchDown->id) + { + tp->x = touchDown->x; + tp->y = touchDown->y; + return true; + } + } + + tp = wl_array_add(&automata->tp, sizeof(UwacTouchPoint)); + if (!tp) + return false; + + if (touchDown->id < 0) + return false; + + tp->id = (uint32_t)touchDown->id; + tp->x = touchDown->x; + tp->y = touchDown->y; + break; + } + + case UWAC_EVENT_TOUCH_FRAME_END: + break; + + default: + break; + } + + return true; +} diff --git a/uwac/libuwac/uwac-utils.c b/uwac/libuwac/uwac-utils.c new file mode 100644 index 0000000..f93b5f7 --- /dev/null +++ b/uwac/libuwac/uwac-utils.c @@ -0,0 +1,67 @@ +/* + * Copyright © 2012 Collabora, Ltd. + * Copyright © 2008 Kristian Høgsberg + * Copyright © 2014 David FORT <contact@hardening-consulting.com> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#include <uwac/config.h> + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <errno.h> + +#include "uwac-utils.h" + +/* + * This part is an adaptation of client/window.c from the weston project. + */ + +static void* fail_on_null(void* p) +{ + if (p == NULL) + { + fprintf(stderr, "out of memory\n"); + exit(EXIT_FAILURE); + } + + return p; +} + +void* xmalloc(size_t s) +{ + return fail_on_null(malloc(s)); +} + +void* xzalloc(size_t s) +{ + return fail_on_null(zalloc(s)); +} + +char* xstrdup(const char* s) +{ + return fail_on_null(strdup(s)); +} + +void* xrealloc(void* p, size_t s) +{ + return fail_on_null(realloc(p, s)); +} diff --git a/uwac/libuwac/uwac-utils.h b/uwac/libuwac/uwac-utils.h new file mode 100644 index 0000000..89852d5 --- /dev/null +++ b/uwac/libuwac/uwac-utils.h @@ -0,0 +1,56 @@ +/* + * Copyright © 2014 David FORT <contact@hardening-consulting.com> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef UWAC_UTILS_H_ +#define UWAC_UTILS_H_ + +#include <stdlib.h> + +#define min(a, b) \ + ({ \ + __typeof__(a) _a = (a); \ + __typeof__(b) _b = (b); \ + _a < _b ? _a : _b; \ + }) + +#define container_of(ptr, type, member) \ + ({ \ + __typeof__(((type*)0)->member)* __mptr = (ptr); \ + (type*)((char*)__mptr - offsetof(type, member)); \ + }) + +#define ARRAY_LENGTH(a) (sizeof(a) / sizeof(a)[0]) + +void* xmalloc(size_t s); + +static inline void* zalloc(size_t size) +{ + return calloc(1, size); +} + +void* xzalloc(size_t s); + +char* xstrdup(const char* s); + +void* xrealloc(void* p, size_t s); + +#endif /* UWAC_UTILS_H_ */ diff --git a/uwac/libuwac/uwac-window.c b/uwac/libuwac/uwac-window.c new file mode 100644 index 0000000..49728bd --- /dev/null +++ b/uwac/libuwac/uwac-window.c @@ -0,0 +1,883 @@ +/* + * Copyright © 2014 David FORT <contact@hardening-consulting.com> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <fcntl.h> +#include <unistd.h> +#include <assert.h> +#include <sys/mman.h> +#include <errno.h> + +#include "uwac-priv.h" +#include "uwac-utils.h" +#include "uwac-os.h" + +#include <uwac/config.h> + +#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 void buffer_release(void* data, struct wl_buffer* buffer) +{ + UwacBufferReleaseData* releaseData = data; + UwacBuffer* uwacBuffer = &releaseData->window->buffers[releaseData->bufferIdx]; + uwacBuffer->used = false; +} + +static const struct wl_buffer_listener buffer_listener = { buffer_release }; + +static void UwacWindowDestroyBuffers(UwacWindow* w) +{ + for (int i = 0; i < w->nbuffers; i++) + { + UwacBuffer* buffer = &w->buffers[i]; +#ifdef UWAC_HAVE_PIXMAN_REGION + pixman_region32_fini(&buffer->damage); +#else + region16_uninit(&buffer->damage); +#endif + UwacBufferReleaseData* releaseData = + (UwacBufferReleaseData*)wl_buffer_get_user_data(buffer->wayland_buffer); + wl_buffer_destroy(buffer->wayland_buffer); + free(releaseData); + munmap(buffer->data, buffer->size); + } + + w->nbuffers = 0; + free(w->buffers); + w->buffers = NULL; +} + +static int UwacWindowShmAllocBuffers(UwacWindow* w, int nbuffers, int allocSize, uint32_t width, + uint32_t height, enum wl_shm_format format); + +static void xdg_handle_toplevel_configure(void* data, struct xdg_toplevel* xdg_toplevel, + int32_t width, int32_t height, struct wl_array* states) +{ + UwacWindow* window = (UwacWindow*)data; + int scale = window->display->actual_scale; + width *= scale; + height *= scale; + UwacConfigureEvent* event = NULL; + int ret = 0; + int surfaceState = 0; + enum xdg_toplevel_state* state = NULL; + surfaceState = 0; + wl_array_for_each(state, states) + { + switch (*state) + { + case XDG_TOPLEVEL_STATE_MAXIMIZED: + surfaceState |= UWAC_WINDOW_MAXIMIZED; + break; + + case XDG_TOPLEVEL_STATE_FULLSCREEN: + surfaceState |= UWAC_WINDOW_FULLSCREEN; + break; + + case XDG_TOPLEVEL_STATE_ACTIVATED: + surfaceState |= UWAC_WINDOW_ACTIVATED; + break; + + case XDG_TOPLEVEL_STATE_RESIZING: + surfaceState |= UWAC_WINDOW_RESIZING; + break; + + default: + break; + } + } + window->surfaceStates = surfaceState; + event = (UwacConfigureEvent*)UwacDisplayNewEvent(window->display, UWAC_EVENT_CONFIGURE); + + if (!event) + { + assert(uwacErrorHandler(window->display, UWAC_ERROR_NOMEMORY, + "failed to allocate a configure event\n")); + return; + } + + event->window = window; + event->states = surfaceState; + + if ((width > 0 && height > 0) && (width != window->width || height != window->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) + { + assert( + uwacErrorHandler(window->display, ret, "failed to reallocate a wayland buffers\n")); + window->drawingBufferIdx = window->pendingBufferIdx = -1; + return; + } + + window->drawingBufferIdx = 0; + if (window->pendingBufferIdx != -1) + window->pendingBufferIdx = window->drawingBufferIdx; + + if (window->viewport) + { + wp_viewport_set_source(window->viewport, wl_fixed_from_int(0), wl_fixed_from_int(0), + wl_fixed_from_int(window->width * scale), + wl_fixed_from_int(window->height * scale)); + wp_viewport_set_destination(window->viewport, window->width * scale, + window->height * scale); + } + } + else + { + event->width = window->width; + event->height = window->height; + } +} + +static void xdg_handle_toplevel_close(void* data, struct xdg_toplevel* xdg_toplevel) +{ + UwacCloseEvent* event = NULL; + UwacWindow* window = (UwacWindow*)data; + event = (UwacCloseEvent*)UwacDisplayNewEvent(window->display, UWAC_EVENT_CLOSE); + + if (!event) + { + assert(uwacErrorHandler(window->display, UWAC_ERROR_INTERNAL, + "failed to allocate a close event\n")); + return; + } + + event->window = window; +} + +static const struct xdg_toplevel_listener xdg_toplevel_listener = { + xdg_handle_toplevel_configure, + xdg_handle_toplevel_close, +}; + +static void xdg_handle_surface_configure(void* data, struct xdg_surface* xdg_surface, + uint32_t serial) +{ + xdg_surface_ack_configure(xdg_surface, serial); +} + +static const struct xdg_surface_listener xdg_surface_listener = { + .configure = xdg_handle_surface_configure, +}; + +#if BUILD_IVI + +static void ivi_handle_configure(void* data, struct ivi_surface* surface, int32_t width, + int32_t height) +{ + UwacWindow* window = (UwacWindow*)data; + UwacConfigureEvent* event = NULL; + int ret = 0; + event = (UwacConfigureEvent*)UwacDisplayNewEvent(window->display, UWAC_EVENT_CONFIGURE); + + 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) + { + 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) + { + assert( + uwacErrorHandler(window->display, ret, "failed to reallocate a wayland buffers\n")); + window->drawingBufferIdx = window->pendingBufferIdx = -1; + return; + } + + window->drawingBufferIdx = 0; + if (window->pendingBufferIdx != -1) + window->pendingBufferIdx = window->drawingBufferIdx; + } + else + { + event->width = window->width; + event->height = window->height; + } +} + +static const struct ivi_surface_listener ivi_surface_listener = { + ivi_handle_configure, +}; +#endif + +static void shell_ping(void* data, struct wl_shell_surface* surface, uint32_t serial) +{ + wl_shell_surface_pong(surface, serial); +} + +static 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 = NULL; + int ret = 0; + event = (UwacConfigureEvent*)UwacDisplayNewEvent(window->display, UWAC_EVENT_CONFIGURE); + + 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) + { + 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) + { + assert( + uwacErrorHandler(window->display, ret, "failed to reallocate a wayland buffers\n")); + window->drawingBufferIdx = window->pendingBufferIdx = -1; + return; + } + + window->drawingBufferIdx = 0; + if (window->pendingBufferIdx != -1) + window->pendingBufferIdx = window->drawingBufferIdx; + } + else + { + event->width = window->width; + event->height = window->height; + } +} + +static void shell_popup_done(void* data, struct wl_shell_surface* surface) +{ +} + +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 ret = UWAC_SUCCESS; + UwacBuffer* newBuffers = NULL; + int fd = 0; + void* data = NULL; + struct wl_shm_pool* pool = NULL; + size_t pagesize = sysconf(_SC_PAGESIZE); + newBuffers = xrealloc(w->buffers, (w->nbuffers + nbuffers) * sizeof(UwacBuffer)); + + if (!newBuffers) + return UWAC_ERROR_NOMEMORY; + + /* round up to a multiple of PAGESIZE to page align data for each buffer */ + allocSize = (allocSize + pagesize - 1) & ~(pagesize - 1); + + w->buffers = newBuffers; + memset(w->buffers + w->nbuffers, 0, sizeof(UwacBuffer) * nbuffers); + fd = uwac_create_anonymous_file(1ull * allocSize * nbuffers); + + if (fd < 0) + { + return UWAC_ERROR_INTERNAL; + } + + data = mmap(NULL, 1ull * allocSize * nbuffers, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + + if (data == MAP_FAILED) + { + ret = UWAC_ERROR_NOMEMORY; + goto error_mmap; + } + + pool = wl_shm_create_pool(w->display->shm, fd, allocSize * nbuffers); + + if (!pool) + { + munmap(data, 1ull * allocSize * nbuffers); + ret = UWAC_ERROR_NOMEMORY; + goto error_mmap; + } + + for (int i = 0; i < nbuffers; i++) + { + int bufferIdx = w->nbuffers + i; + UwacBuffer* buffer = &w->buffers[bufferIdx]; +#ifdef UWAC_HAVE_PIXMAN_REGION + pixman_region32_init(&buffer->damage); +#else + region16_init(&buffer->damage); +#endif + buffer->data = &((char*)data)[allocSize * i]; + buffer->size = allocSize; + buffer->wayland_buffer = + wl_shm_pool_create_buffer(pool, allocSize * i, width, height, w->stride, format); + UwacBufferReleaseData* listener_data = xmalloc(sizeof(UwacBufferReleaseData)); + listener_data->window = w; + listener_data->bufferIdx = bufferIdx; + wl_buffer_add_listener(buffer->wayland_buffer, &buffer_listener, listener_data); + } + + wl_shm_pool_destroy(pool); + w->nbuffers += nbuffers; +error_mmap: + close(fd); + return ret; +} + +static UwacBuffer* UwacWindowFindFreeBuffer(UwacWindow* w, ssize_t* index) +{ + int ret = 0; + + if (index) + *index = -1; + + size_t i = 0; + for (; i < w->nbuffers; i++) + { + if (!w->buffers[i].used) + { + w->buffers[i].used = true; + if (index) + *index = i; + return &w->buffers[i]; + } + } + + ret = UwacWindowShmAllocBuffers(w, 2, w->stride * w->height, w->width, w->height, w->format); + + if (ret != UWAC_SUCCESS) + { + w->display->last_error = ret; + return NULL; + } + + w->buffers[i].used = true; + if (index) + *index = i; + return &w->buffers[i]; +} + +static UwacReturnCode UwacWindowSetDecorations(UwacWindow* w) +{ + if (!w || !w->display) + return UWAC_ERROR_INTERNAL; + + if (w->display->deco_manager) + { + w->deco = zxdg_decoration_manager_v1_get_toplevel_decoration(w->display->deco_manager, + w->xdg_toplevel); + if (!w->deco) + { + uwacErrorHandler(w->display, UWAC_NOT_FOUND, + "Current window manager does not allow decorating with SSD"); + } + else + zxdg_toplevel_decoration_v1_set_mode(w->deco, + ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE); + } + else if (w->display->kde_deco_manager) + { + w->kde_deco = + org_kde_kwin_server_decoration_manager_create(w->display->kde_deco_manager, w->surface); + if (!w->kde_deco) + { + uwacErrorHandler(w->display, UWAC_NOT_FOUND, + "Current window manager does not allow decorating with SSD"); + } + else + org_kde_kwin_server_decoration_request_mode(w->kde_deco, + ORG_KDE_KWIN_SERVER_DECORATION_MODE_SERVER); + } + return UWAC_SUCCESS; +} + +UwacWindow* UwacCreateWindowShm(UwacDisplay* display, uint32_t width, uint32_t height, + enum wl_shm_format format) +{ + UwacWindow* w = NULL; + int allocSize = 0; + int ret = 0; + + if (!display) + { + return NULL; + } + + w = xzalloc(sizeof(*w)); + + if (!w) + { + display->last_error = UWAC_ERROR_NOMEMORY; + return NULL; + } + + w->display = display; + w->format = format; + w->width = width; + 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) + { + display->last_error = ret; + goto out_error_free; + } + + w->buffers[0].used = true; + w->drawingBufferIdx = 0; + w->pendingBufferIdx = -1; + w->surface = wl_compositor_create_surface(display->compositor); + + if (!w->surface) + { + display->last_error = UWAC_ERROR_NOMEMORY; + goto out_error_surface; + } + + wl_surface_set_user_data(w->surface, w); + +#if BUILD_IVI + uint32_t ivi_surface_id = 1; + char* env = getenv("IVI_SURFACE_ID"); + if (env) + { + unsigned long val = 0; + char* endp = NULL; + + errno = 0; + val = strtoul(env, &endp, 10); + + if (!errno && val != 0 && val != UINT32_MAX) + ivi_surface_id = val; + } + + if (display->ivi_application) + { + w->ivi_surface = + ivi_application_surface_create(display->ivi_application, ivi_surface_id, w->surface); + assert(w->ivi_surface); + ivi_surface_add_listener(w->ivi_surface, &ivi_surface_listener, w); + } + else +#endif +#if BUILD_FULLSCREEN_SHELL + if (display->fullscreen_shell) + { + zwp_fullscreen_shell_v1_present_surface(display->fullscreen_shell, w->surface, + ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_CENTER, + NULL); + } + else +#endif + if (display->xdg_base) + { + w->xdg_surface = xdg_wm_base_get_xdg_surface(display->xdg_base, w->surface); + + if (!w->xdg_surface) + { + display->last_error = UWAC_ERROR_NOMEMORY; + goto out_error_shell; + } + + xdg_surface_add_listener(w->xdg_surface, &xdg_surface_listener, w); + + w->xdg_toplevel = xdg_surface_get_toplevel(w->xdg_surface); + if (!w->xdg_toplevel) + { + display->last_error = UWAC_ERROR_NOMEMORY; + goto out_error_shell; + } + + assert(w->xdg_surface); + xdg_toplevel_add_listener(w->xdg_toplevel, &xdg_toplevel_listener, w); + wl_surface_commit(w->surface); + wl_display_roundtrip(w->display->display); + } + 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); + } + + if (display->viewporter) + { + w->viewport = wp_viewporter_get_viewport(display->viewporter, w->surface); + if (display->actual_scale != 1) + wl_surface_set_buffer_scale(w->surface, display->actual_scale); + } + + wl_list_insert(display->windows.prev, &w->link); + display->last_error = UWAC_SUCCESS; + UwacWindowSetDecorations(w); + return w; +out_error_shell: + wl_surface_destroy(w->surface); +out_error_surface: + UwacWindowDestroyBuffers(w); +out_error_free: + free(w); + return NULL; +} + +UwacReturnCode UwacDestroyWindow(UwacWindow** pwindow) +{ + UwacWindow* w = NULL; + assert(pwindow); + w = *pwindow; + UwacWindowDestroyBuffers(w); + + if (w->deco) + zxdg_toplevel_decoration_v1_destroy(w->deco); + + if (w->kde_deco) + org_kde_kwin_server_decoration_destroy(w->kde_deco); + + 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) + wl_region_destroy(w->opaque_region); + + if (w->input_region) + wl_region_destroy(w->input_region); + + if (w->viewport) + wp_viewport_destroy(w->viewport); + + 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) +{ + assert(window); + + if (window->opaque_region) + wl_region_destroy(window->opaque_region); + + window->opaque_region = wl_compositor_create_region(window->display->compositor); + + if (!window->opaque_region) + return UWAC_ERROR_NOMEMORY; + + wl_region_add(window->opaque_region, x, y, width, height); + wl_surface_set_opaque_region(window->surface, window->opaque_region); + return UWAC_SUCCESS; +} + +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; + + wl_region_add(window->input_region, x, y, width, height); + wl_surface_set_input_region(window->surface, window->input_region); + return UWAC_SUCCESS; +} + +void* UwacWindowGetDrawingBuffer(UwacWindow* window) +{ + UwacBuffer* buffer = NULL; + + if (window->drawingBufferIdx < 0) + return NULL; + + buffer = &window->buffers[window->drawingBufferIdx]; + if (!buffer) + return NULL; + + return buffer->data; +} + +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 }; + +#ifdef UWAC_HAVE_PIXMAN_REGION +static void damage_surface(UwacWindow* window, UwacBuffer* buffer, int scale) +{ + int nrects = 0; + const pixman_box32_t* box = pixman_region32_rectangles(&buffer->damage, &nrects); + + for (int i = 0; i < nrects; i++, box++) + { + const int x = ((int)floor(box->x1 / scale)) - 1; + const int y = ((int)floor(box->y1 / scale)) - 1; + const int w = ((int)ceil((box->x2 - box->x1) / scale)) + 2; + const int h = ((int)ceil((box->y2 - box->y1) / scale)) + 2; + wl_surface_damage(window->surface, x, y, w, h); + } + + pixman_region32_clear(&buffer->damage); +} +#else +static void damage_surface(UwacWindow* window, UwacBuffer* buffer, int scale) +{ + uint32_t nrects = 0; + const RECTANGLE_16* box = region16_rects(&buffer->damage, &nrects); + + for (UINT32 i = 0; i < nrects; i++, box++) + { + const int x = ((int)floor(box->left / scale)) - 1; + const int y = ((int)floor(box->top / scale)) - 1; + const int w = ((int)ceil((box->right - box->left) / scale)) + 2; + const int h = ((int)ceil((box->bottom - box->top) / scale)) + 2; + wl_surface_damage(window->surface, x, y, w, h); + } + + region16_clear(&buffer->damage); +} +#endif + +static void UwacSubmitBufferPtr(UwacWindow* window, UwacBuffer* buffer) +{ + wl_surface_attach(window->surface, buffer->wayland_buffer, 0, 0); + + int scale = window->display->actual_scale; + damage_surface(window, buffer, scale); + + struct wl_callback* frame_callback = wl_surface_frame(window->surface); + wl_callback_add_listener(frame_callback, &frame_listener, window); + wl_surface_commit(window->surface); + buffer->dirty = false; +} + +static void frame_done_cb(void* data, struct wl_callback* callback, uint32_t time) +{ + UwacWindow* window = (UwacWindow*)data; + UwacFrameDoneEvent* event = NULL; + + wl_callback_destroy(callback); + window->pendingBufferIdx = -1; + event = (UwacFrameDoneEvent*)UwacDisplayNewEvent(window->display, UWAC_EVENT_FRAME_DONE); + + if (event) + event->window = window; +} + +#ifdef UWAC_HAVE_PIXMAN_REGION +UwacReturnCode UwacWindowAddDamage(UwacWindow* window, uint32_t x, uint32_t y, uint32_t width, + uint32_t height) +{ + UwacBuffer* buf = NULL; + + if (window->drawingBufferIdx < 0) + return UWAC_ERROR_INTERNAL; + + buf = &window->buffers[window->drawingBufferIdx]; + if (!pixman_region32_union_rect(&buf->damage, &buf->damage, x, y, width, height)) + return UWAC_ERROR_INTERNAL; + + buf->dirty = true; + return UWAC_SUCCESS; +} +#else +UwacReturnCode UwacWindowAddDamage(UwacWindow* window, uint32_t x, uint32_t y, uint32_t width, + uint32_t height) +{ + RECTANGLE_16 box; + UwacBuffer* buf = NULL; + + box.left = x; + box.top = y; + box.right = x + width; + box.bottom = y + height; + + if (window->drawingBufferIdx < 0) + return UWAC_ERROR_INTERNAL; + + buf = &window->buffers[window->drawingBufferIdx]; + if (!buf) + return UWAC_ERROR_INTERNAL; + + if (!region16_union_rect(&buf->damage, &buf->damage, &box)) + return UWAC_ERROR_INTERNAL; + + buf->dirty = true; + return UWAC_SUCCESS; +} +#endif + +UwacReturnCode UwacWindowGetDrawingBufferGeometry(UwacWindow* window, UwacSize* geometry, + size_t* stride) +{ + if (!window || (window->drawingBufferIdx < 0)) + return UWAC_ERROR_INTERNAL; + + if (geometry) + { + geometry->width = window->width; + geometry->height = window->height; + } + + if (stride) + *stride = window->stride; + + return UWAC_SUCCESS; +} + +UwacReturnCode UwacWindowSubmitBuffer(UwacWindow* window, bool copyContentForNextFrame) +{ + UwacBuffer* currentDrawingBuffer = NULL; + UwacBuffer* nextDrawingBuffer = NULL; + UwacBuffer* pendingBuffer = NULL; + + if (window->drawingBufferIdx < 0) + return UWAC_ERROR_INTERNAL; + + currentDrawingBuffer = &window->buffers[window->drawingBufferIdx]; + + if ((window->pendingBufferIdx >= 0) || !currentDrawingBuffer->dirty) + return UWAC_SUCCESS; + + window->pendingBufferIdx = window->drawingBufferIdx; + nextDrawingBuffer = UwacWindowFindFreeBuffer(window, &window->drawingBufferIdx); + pendingBuffer = &window->buffers[window->pendingBufferIdx]; + + if ((!nextDrawingBuffer) || (window->drawingBufferIdx < 0)) + return UWAC_ERROR_NOMEMORY; + + if (copyContentForNextFrame) + memcpy(nextDrawingBuffer->data, pendingBuffer->data, + 1ull * window->stride * window->height); + + UwacSubmitBufferPtr(window, pendingBuffer); + return UWAC_SUCCESS; +} + +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_toplevel) + { + if (isFullscreen) + { + xdg_toplevel_set_fullscreen(window->xdg_toplevel, output ? output->output : NULL); + } + else + { + xdg_toplevel_unset_fullscreen(window->xdg_toplevel); + } + } + else if (window->shell_surface) + { + if (isFullscreen) + { + wl_shell_surface_set_fullscreen(window->shell_surface, + WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, + output ? output->output : NULL); + } + else + { + wl_shell_surface_set_toplevel(window->shell_surface); + } + } + + return UWAC_SUCCESS; +} + +void UwacWindowSetTitle(UwacWindow* window, const char* name) +{ + if (window->xdg_toplevel) + xdg_toplevel_set_title(window->xdg_toplevel, name); + else if (window->shell_surface) + wl_shell_surface_set_title(window->shell_surface, name); +} + +void UwacWindowSetAppId(UwacWindow* window, const char* app_id) +{ + if (window->xdg_toplevel) + xdg_toplevel_set_app_id(window->xdg_toplevel, app_id); +} |