From: Ray Strode Date: Thu, 23 Jul 2015 18:16:48 +0000 (-0400) Subject: device-manager: drop seat abstraction X-Git-Tag: 0.9.3~55 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=c0ee9474a3b671b537d15caf5614058055e286ed;p=thirdparty%2Fplymouth.git device-manager: drop seat abstraction The seat abstraction isn't really right, since it forces creating a link between terminal and video output device, which isn't really necessary (and other reasons). This commit drops the abstraction, and moves all the code that was in ply-seat.c directly to ply-device-manager.c. --- diff --git a/src/libply-splash-core/Makefile.am b/src/libply-splash-core/Makefile.am index d07d7f18..70365696 100644 --- a/src/libply-splash-core/Makefile.am +++ b/src/libply-splash-core/Makefile.am @@ -21,7 +21,6 @@ libply_splash_core_HEADERS = \ ply-pixel-display.h \ ply-renderer.h \ ply-renderer-plugin.h \ - ply-seat.h \ ply-terminal.h \ ply-text-display.h \ ply-text-progress-bar.h \ @@ -47,7 +46,6 @@ libply_splash_core_la_SOURCES = \ ply-terminal.c \ ply-pixel-buffer.c \ ply-renderer.c \ - ply-seat.c \ ply-boot-splash.c MAINTAINERCLEANFILES = Makefile.in diff --git a/src/libply-splash-core/ply-boot-splash.c b/src/libply-splash-core/ply-boot-splash.c index 310d4d5a..e853e1f5 100644 --- a/src/libply-splash-core/ply-boot-splash.c +++ b/src/libply-splash-core/ply-boot-splash.c @@ -57,7 +57,10 @@ struct _ply_boot_splash ply_boot_splash_mode_t mode; ply_buffer_t *boot_buffer; ply_trigger_t *idle_trigger; - ply_list_t *seats; + + ply_keyboard_t *keyboard; + ply_list_t *pixel_displays; + ply_list_t *text_displays; char *theme_path; char *plugin_dir; @@ -94,160 +97,102 @@ ply_boot_splash_new (const char *theme_path, splash->mode = PLY_BOOT_SPLASH_MODE_INVALID; splash->boot_buffer = boot_buffer; - splash->seats = ply_list_new (); + splash->pixel_displays = ply_list_new (); + splash->text_displays = ply_list_new (); return splash; } -static void -detach_from_seat (ply_boot_splash_t *splash, - ply_seat_t *seat) +void +ply_boot_splash_set_keyboard (ply_boot_splash_t *splash, + ply_keyboard_t *keyboard) { - ply_keyboard_t *keyboard; - ply_list_t *displays; - ply_list_node_t *node, *next_node; - - ply_trace ("removing keyboard"); - if (splash->plugin_interface->unset_keyboard != NULL) { - keyboard = ply_seat_get_keyboard (seat); - splash->plugin_interface->unset_keyboard (splash->plugin, keyboard); - } - - ply_trace ("removing pixel displays"); - displays = ply_seat_get_pixel_displays (seat); - - node = ply_list_get_first_node (displays); - while (node != NULL) { - ply_pixel_display_t *display; - ply_list_node_t *next_node; - unsigned long width, height; - - display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (displays, node); - - width = ply_pixel_display_get_width (display); - height = ply_pixel_display_get_height (display); - - ply_trace ("Removing %lux%lu pixel display", width, height); - - if (splash->plugin_interface->remove_pixel_display != NULL) - splash->plugin_interface->remove_pixel_display (splash->plugin, display); - - node = next_node; - } - - ply_trace ("removing text displays"); - displays = ply_seat_get_text_displays (seat); - - node = ply_list_get_first_node (displays); - while (node != NULL) { - ply_text_display_t *display; - int number_of_columns, number_of_rows; - - display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (displays, node); - - number_of_columns = ply_text_display_get_number_of_columns (display); - number_of_rows = ply_text_display_get_number_of_rows (display); - - ply_trace ("Removing %dx%d text display", number_of_columns, number_of_rows); - - if (splash->plugin_interface->remove_text_display != NULL) - splash->plugin_interface->remove_text_display (splash->plugin, display); + if (splash->plugin_interface->set_keyboard == NULL) + return; - node = next_node; - } + splash->plugin_interface->set_keyboard (splash->plugin, keyboard); + splash->keyboard = keyboard; } -static void -attach_to_seat (ply_boot_splash_t *splash, - ply_seat_t *seat) +void +ply_boot_splash_unset_keyboard (ply_boot_splash_t *splash) { - ply_keyboard_t *keyboard; - ply_list_t *displays; - ply_list_node_t *node, *next_node; - - if (splash->plugin_interface->set_keyboard != NULL) { - keyboard = ply_seat_get_keyboard (seat); - splash->plugin_interface->set_keyboard (splash->plugin, keyboard); - } - - if (splash->plugin_interface->add_pixel_display != NULL) { - displays = ply_seat_get_pixel_displays (seat); - - ply_trace ("adding pixel displays"); - node = ply_list_get_first_node (displays); - while (node != NULL) { - ply_pixel_display_t *display; - ply_list_node_t *next_node; - unsigned long width, height; - - display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (displays, node); + if (splash->plugin_interface->unset_keyboard == NULL) + return; - width = ply_pixel_display_get_width (display); - height = ply_pixel_display_get_height (display); + splash->plugin_interface->unset_keyboard (splash->plugin, splash->keyboard); +} - ply_trace ("Adding %lux%lu pixel display", width, height); +void +ply_boot_splash_add_pixel_display (ply_boot_splash_t *splash, + ply_pixel_display_t *display) +{ + unsigned long width, height; - splash->plugin_interface->add_pixel_display (splash->plugin, display); + if (splash->plugin_interface->add_pixel_display == NULL) + return; - node = next_node; - } - } + width = ply_pixel_display_get_width (display); + height = ply_pixel_display_get_height (display); - if (splash->plugin_interface->add_text_display != NULL) { - displays = ply_seat_get_text_displays (seat); + ply_trace ("adding %lux%lu pixel display", width, height); - ply_trace ("adding text displays"); - node = ply_list_get_first_node (displays); - while (node != NULL) { - ply_text_display_t *display; - int number_of_columns, number_of_rows; + splash->plugin_interface->add_pixel_display (splash->plugin, display); + ply_list_append_data (splash->pixel_displays, display); +} - display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (displays, node); +void +ply_boot_splash_remove_pixel_display (ply_boot_splash_t *splash, + ply_pixel_display_t *display) +{ + unsigned long width, height; - number_of_columns = ply_text_display_get_number_of_columns (display); - number_of_rows = ply_text_display_get_number_of_rows (display); + if (splash->plugin_interface->remove_pixel_display == NULL) + return; - ply_trace ("Adding %dx%d text display", number_of_columns, number_of_rows); + width = ply_pixel_display_get_width (display); + height = ply_pixel_display_get_height (display); - splash->plugin_interface->add_text_display (splash->plugin, display); + ply_trace ("removing %lux%lu pixel display", width, height); - node = next_node; - } - } + splash->plugin_interface->remove_pixel_display (splash->plugin, display); + ply_list_remove_data (splash->pixel_displays, display); } void -ply_boot_splash_attach_to_seat (ply_boot_splash_t *splash, - ply_seat_t *seat) +ply_boot_splash_add_text_display (ply_boot_splash_t *splash, + ply_text_display_t *display) { - ply_list_node_t *node; - - node = ply_list_find_node (splash->seats, seat); + int number_of_columns, number_of_rows; - if (node != NULL) + if (splash->plugin_interface->add_text_display == NULL) return; - ply_list_append_data (splash->seats, seat); - attach_to_seat (splash, seat); + number_of_columns = ply_text_display_get_number_of_columns (display); + number_of_rows = ply_text_display_get_number_of_rows (display); + + ply_trace ("adding %dx%d text display", number_of_columns, number_of_rows); + + splash->plugin_interface->add_text_display (splash->plugin, display); + ply_list_append_data (splash->text_displays, display); } void -ply_boot_splash_detach_from_seat (ply_boot_splash_t *splash, - ply_seat_t *seat) +ply_boot_splash_remove_text_display (ply_boot_splash_t *splash, + ply_text_display_t *display) { - ply_list_node_t *node; - - node = ply_list_find_node (splash->seats, seat); + int number_of_columns, number_of_rows; - if (node == NULL) + if (splash->plugin_interface->remove_text_display == NULL) return; - ply_list_remove_data (splash->seats, seat); - detach_from_seat (splash, seat); + number_of_columns = ply_text_display_get_number_of_columns (display); + number_of_rows = ply_text_display_get_number_of_rows (display); + + ply_trace ("removing %dx%d text display", number_of_columns, number_of_rows); + + splash->plugin_interface->remove_text_display (splash->plugin, display); + ply_list_remove_data (splash->text_displays, display); } bool @@ -378,23 +323,60 @@ ply_boot_splash_unload (ply_boot_splash_t *splash) } static void -detach_from_seats (ply_boot_splash_t *splash) +remove_pixel_displays (ply_boot_splash_t *splash) +{ + ply_list_node_t *node; + + if (splash->plugin_interface->remove_pixel_display == NULL) + return; + + ply_trace ("removing pixel displays"); + + node = ply_list_get_first_node (splash->pixel_displays); + while (node != NULL) { + ply_pixel_display_t *display; + ply_list_node_t *next_node; + unsigned long width, height; + + display = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (splash->pixel_displays, node); + + width = ply_pixel_display_get_width (display); + height = ply_pixel_display_get_height (display); + + ply_trace ("Removing %lux%lu pixel display", width, height); + + splash->plugin_interface->remove_pixel_display (splash->plugin, display); + + node = next_node; + } +} + +static void +remove_text_displays (ply_boot_splash_t *splash) { ply_list_node_t *node; - ply_trace ("detaching from seats"); + if (splash->plugin_interface->remove_text_display == NULL) + return; + + ply_trace ("removing text displays"); - node = ply_list_get_first_node (splash->seats); + node = ply_list_get_first_node (splash->text_displays); while (node != NULL) { - ply_seat_t *seat; + ply_text_display_t *display; ply_list_node_t *next_node; + int number_of_columns, number_of_rows; - seat = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (splash->seats, node); + display = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (splash->text_displays, node); - detach_from_seat (splash, seat); + number_of_columns = ply_text_display_get_number_of_columns (display); + number_of_rows = ply_text_display_get_number_of_rows (display); + + ply_trace ("Removing %dx%d text display", number_of_columns, number_of_rows); - ply_list_remove_node (splash->seats, node); + splash->plugin_interface->remove_text_display (splash->plugin, display); node = next_node; } @@ -419,8 +401,13 @@ ply_boot_splash_free (ply_boot_splash_t *splash) splash); } - detach_from_seats (splash); - ply_list_free (splash->seats); + ply_boot_splash_unset_keyboard (splash); + + remove_pixel_displays (splash); + ply_list_free (splash->pixel_displays); + + remove_text_displays (splash); + ply_list_free (splash->text_displays); if (splash->module_handle != NULL) ply_boot_splash_unload (splash); diff --git a/src/libply-splash-core/ply-boot-splash.h b/src/libply-splash-core/ply-boot-splash.h index 0ad6f22b..09e31c87 100644 --- a/src/libply-splash-core/ply-boot-splash.h +++ b/src/libply-splash-core/ply-boot-splash.h @@ -50,10 +50,17 @@ ply_boot_splash_t *ply_boot_splash_new (const char *theme_path, bool ply_boot_splash_load (ply_boot_splash_t *splash); bool ply_boot_splash_load_built_in (ply_boot_splash_t *splash); void ply_boot_splash_unload (ply_boot_splash_t *splash); -void ply_boot_splash_attach_to_seat (ply_boot_splash_t *splash, - ply_seat_t *seat); -void ply_boot_splash_detach_from_seat (ply_boot_splash_t *splash, - ply_seat_t *seat); +void ply_boot_splash_set_keyboard (ply_boot_splash_t *splash, + ply_keyboard_t *keyboard); +void ply_boot_splash_unset_keyboard (ply_boot_splash_t *splash); +void ply_boot_splash_add_pixel_display (ply_boot_splash_t *splash, + ply_pixel_display_t *pixel_display); +void ply_boot_splash_remove_pixel_display (ply_boot_splash_t *splash, + ply_pixel_display_t *pixel_display); +void ply_boot_splash_add_text_display (ply_boot_splash_t *splash, + ply_text_display_t *text_display); +void ply_boot_splash_remove_text_display (ply_boot_splash_t *splash, + ply_text_display_t *text_display); void ply_boot_splash_free (ply_boot_splash_t *splash); bool ply_boot_splash_show (ply_boot_splash_t *splash, ply_boot_splash_mode_t mode); diff --git a/src/libply-splash-core/ply-device-manager.c b/src/libply-splash-core/ply-device-manager.c index 67eba323..de792d9e 100644 --- a/src/libply-splash-core/ply-device-manager.c +++ b/src/libply-splash-core/ply-device-manager.c @@ -41,27 +41,36 @@ #define SUBSYSTEM_DRM "drm" #define SUBSYSTEM_FRAME_BUFFER "graphics" -static void create_seat_for_terminal_and_renderer_type (ply_device_manager_t *manager, - const char *device_path, - ply_terminal_t *terminal, - ply_renderer_type_t renderer_type); +static void create_devices_for_terminal_and_renderer_type (ply_device_manager_t *manager, + const char *device_path, + ply_terminal_t *terminal, + ply_renderer_type_t renderer_type); struct _ply_device_manager { ply_device_manager_flags_t flags; ply_event_loop_t *loop; ply_hashtable_t *terminals; + ply_hashtable_t *renderers; ply_terminal_t *local_console_terminal; - ply_seat_t *local_console_seat; - ply_list_t *seats; + ply_list_t *keyboards; + ply_list_t *text_displays; + ply_list_t *pixel_displays; struct udev *udev_context; struct udev_queue *udev_queue; int udev_queue_fd; ply_fd_watch_t *udev_queue_fd_watch; struct udev_monitor *udev_monitor; - ply_seat_added_handler_t seat_added_handler; - ply_seat_removed_handler_t seat_removed_handler; - void *seat_event_handler_data; + ply_keyboard_added_handler_t keyboard_added_handler; + ply_keyboard_removed_handler_t keyboard_removed_handler; + ply_pixel_display_added_handler_t pixel_display_added_handler; + ply_pixel_display_removed_handler_t pixel_display_removed_handler; + ply_text_display_added_handler_t text_display_added_handler; + ply_text_display_removed_handler_t text_display_removed_handler; + void *event_handler_data; + + uint32_t local_console_managed : 1; + uint32_t local_console_is_text : 1; }; static void @@ -118,33 +127,11 @@ static bool drm_device_in_use (ply_device_manager_t *manager, const char *device_path) { - ply_list_node_t *node; - - node = ply_list_get_first_node (manager->seats); - while (node != NULL) { - ply_seat_t *seat; - ply_renderer_t *renderer; - ply_list_node_t *next_node; - const char *renderer_device_path; + ply_renderer_t *renderer; - seat = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (manager->seats, node); - renderer = ply_seat_get_renderer (seat); - - if (renderer != NULL) { - renderer_device_path = ply_renderer_get_device_name (renderer); - - if (renderer_device_path != NULL) { - if (strcmp (device_path, renderer_device_path) == 0) { - return true; - } - } - } + renderer = ply_hashtable_lookup (manager->renderers, (void *) device_path); - node = next_node; - } - - return false; + return renderer != NULL; } static bool @@ -196,8 +183,8 @@ fb_device_has_drm_device (ply_device_manager_t *manager, } static void -create_seat_for_udev_device (ply_device_manager_t *manager, - struct udev_device *device) +create_devices_for_udev_device (ply_device_manager_t *manager, + struct udev_device *device) { bool for_local_console; const char *device_path; @@ -231,7 +218,7 @@ create_seat_for_udev_device (ply_device_manager_t *manager, } if (renderer_type != PLY_RENDERER_TYPE_NONE) { - create_seat_for_terminal_and_renderer_type (manager, + create_devices_for_terminal_and_renderer_type (manager, device_path, terminal, renderer_type); @@ -240,37 +227,27 @@ create_seat_for_udev_device (ply_device_manager_t *manager, } static void -free_seat_from_device_path (ply_device_manager_t *manager, - const char *device_path) +free_displays_for_renderer (ply_device_manager_t *manager, + ply_renderer_t *renderer) { ply_list_node_t *node; - node = ply_list_get_first_node (manager->seats); + node = ply_list_get_first_node (manager->pixel_displays); while (node != NULL) { - ply_seat_t *seat; - ply_renderer_t *renderer; ply_list_node_t *next_node; - const char *renderer_device_path; + ply_pixel_display_t *display; + ply_renderer_t *display_renderer; - seat = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (manager->seats, node); - renderer = ply_seat_get_renderer (seat); + display = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (manager->pixel_displays, node); + display_renderer = ply_pixel_display_get_renderer (display); - if (renderer != NULL) { - renderer_device_path = ply_renderer_get_device_name (renderer); + if (display_renderer == renderer) { + if (manager->pixel_display_removed_handler != NULL) + manager->pixel_display_removed_handler (manager->event_handler_data, display); + ply_pixel_display_free (display); + ply_list_remove_node (manager->pixel_displays, node); - if (renderer_device_path != NULL) { - if (strcmp (device_path, renderer_device_path) == 0) { - ply_trace ("removing seat associated with %s", device_path); - - if (manager->seat_removed_handler != NULL) - manager->seat_removed_handler (manager->seat_event_handler_data, seat); - - ply_seat_free (seat); - ply_list_remove_node (manager->seats, node); - break; - } - } } node = next_node; @@ -278,26 +255,48 @@ free_seat_from_device_path (ply_device_manager_t *manager, } static void -free_seat_for_udev_device (ply_device_manager_t *manager, - struct udev_device *device) +free_devices_from_device_path (ply_device_manager_t *manager, + const char *device_path) +{ + char *key = NULL; + ply_renderer_t *renderer = NULL; + + ply_hashtable_lookup_full (manager->renderers, + (void *) device_path, + (void **) &key, + (void **) &renderer); + + if (renderer == NULL) + return; + + free_displays_for_renderer (manager, renderer); + + ply_hashtable_remove (manager->renderers, (void *) device_path); + free (key); + ply_renderer_free (renderer); +} + +static void +free_devices_for_udev_device (ply_device_manager_t *manager, + struct udev_device *device) { const char *device_path; device_path = udev_device_get_devnode (device); if (device_path != NULL) - free_seat_from_device_path (manager, device_path); + free_devices_from_device_path (manager, device_path); } static bool -create_seats_for_subsystem (ply_device_manager_t *manager, - const char *subsystem) +create_devices_for_subsystem (ply_device_manager_t *manager, + const char *subsystem) { struct udev_enumerate *matches; struct udev_list_entry *entry; bool found_device = false; - ply_trace ("creating seats for %s devices", + ply_trace ("creating objects for %s devices", strcmp (subsystem, SUBSYSTEM_FRAME_BUFFER) == 0 ? "frame buffer" : subsystem); @@ -326,7 +325,7 @@ create_seats_for_subsystem (ply_device_manager_t *manager, if (udev_device_get_is_initialized (device)) { ply_trace ("device is initialized"); - /* We only care about devices assigned to a (any) seat. Floating + /* We only care about devices assigned to a (any) devices. Floating * devices should be ignored. */ if (udev_device_has_tag (device, "seat")) { @@ -335,10 +334,10 @@ create_seats_for_subsystem (ply_device_manager_t *manager, if (node != NULL) { ply_trace ("found node %s", node); found_device = true; - create_seat_for_udev_device (manager, device); + create_devices_for_udev_device (manager, device); } } else { - ply_trace ("device doesn't have a seat tag"); + ply_trace ("device doesn't have a devices tag"); } } else { ply_trace ("it's not initialized"); @@ -376,12 +375,16 @@ on_udev_event (ply_device_manager_t *manager) subsystem = udev_device_get_subsystem (device); if (strcmp (subsystem, SUBSYSTEM_DRM) == 0 || - coldplug_complete) - create_seat_for_udev_device (manager, device); - else + coldplug_complete) { + if (coldplug_complete && manager->local_console_managed && manager->local_console_is_text) + ply_trace ("ignoring since we're already using text splash for local console"); + else + create_devices_for_udev_device (manager, device); + } else { ply_trace ("ignoring since we only handle subsystem %s devices after coldplug completes", subsystem); + } } else if (strcmp (action, "remove") == 0) { - free_seat_for_udev_device (manager, device); + free_devices_for_udev_device (manager, device); } udev_device_unref (device); @@ -414,30 +417,6 @@ watch_for_udev_events (ply_device_manager_t *manager) manager); } -static void -free_seats (ply_device_manager_t *manager) -{ - ply_list_node_t *node; - - ply_trace ("removing seats"); - node = ply_list_get_first_node (manager->seats); - while (node != NULL) { - ply_seat_t *seat; - ply_list_node_t *next_node; - - seat = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (manager->seats, node); - - if (manager->seat_removed_handler != NULL) - manager->seat_removed_handler (manager->seat_event_handler_data, seat); - - ply_seat_free (seat); - ply_list_remove_node (manager->seats, node); - - node = next_node; - } -} - static void free_terminal (char *device, ply_terminal_t *terminal, @@ -491,6 +470,23 @@ done: return terminal; } +static void +free_renderer (char *device_path, + ply_renderer_t *renderer, + ply_device_manager_t *manager) +{ + free_devices_from_device_path (manager, device_path); +} + +static void +free_renderers (ply_device_manager_t *manager) +{ + ply_hashtable_foreach (manager->renderers, + (ply_hashtable_foreach_func_t *) + free_renderer, + manager); +} + ply_device_manager_t * ply_device_manager_new (const char *default_tty, ply_device_manager_flags_t flags) @@ -500,11 +496,14 @@ ply_device_manager_new (const char *default_tty, manager = calloc (1, sizeof(ply_device_manager_t)); manager->loop = NULL; manager->terminals = ply_hashtable_new (ply_hashtable_string_hash, ply_hashtable_string_compare); + manager->renderers = ply_hashtable_new (ply_hashtable_string_hash, ply_hashtable_string_compare); manager->local_console_terminal = ply_terminal_new (default_tty); ply_hashtable_insert (manager->terminals, (void *) ply_terminal_get_name (manager->local_console_terminal), manager->local_console_terminal); - manager->seats = ply_list_new (); + manager->keyboards = ply_list_new (); + manager->text_displays = ply_list_new (); + manager->pixel_displays = ply_list_new (); manager->flags = flags; if (!(flags & PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV)) @@ -527,12 +526,13 @@ ply_device_manager_free (ply_device_manager_t *manager) (ply_event_loop_exit_handler_t) detach_from_event_loop, manager); - free_seats (manager); - ply_list_free (manager->seats); free_terminals (manager); ply_hashtable_free (manager->terminals); + free_renderers (manager); + ply_hashtable_free (manager->renderers); + if (manager->udev_monitor != NULL) udev_monitor_unref (manager->udev_monitor); @@ -615,53 +615,140 @@ add_consoles_from_file (ply_device_manager_t *manager, } static void -create_seat_for_terminal_and_renderer_type (ply_device_manager_t *manager, - const char *device_path, - ply_terminal_t *terminal, - ply_renderer_type_t renderer_type) +create_pixel_displays_for_renderer (ply_device_manager_t *manager, + ply_renderer_t *renderer) +{ + ply_list_t *heads; + ply_list_node_t *node; + + heads = ply_renderer_get_heads (renderer); + + ply_trace ("Adding displays for %d heads", + ply_list_get_length (heads)); + + node = ply_list_get_first_node (heads); + while (node != NULL) { + ply_list_node_t *next_node; + ply_renderer_head_t *head; + ply_pixel_display_t *display; + + head = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (heads, node); + + display = ply_pixel_display_new (renderer, head); + + ply_list_append_data (manager->pixel_displays, display); + + if (manager->pixel_display_added_handler != NULL) + manager->pixel_display_added_handler (manager->event_handler_data, display); + node = next_node; + } +} + +static void +create_text_displays_for_terminal (ply_device_manager_t *manager, + ply_terminal_t *terminal) +{ + ply_text_display_t *display; + + if (!ply_terminal_is_open (terminal)) { + if (!ply_terminal_open (terminal)) { + ply_trace ("could not add terminal %s: %m", + ply_terminal_get_name (terminal)); + return; + } + } + + ply_trace ("adding text display for terminal %s", + ply_terminal_get_name (terminal)); + + display = ply_text_display_new (terminal); + ply_list_append_data (manager->text_displays, display); + + if (manager->text_display_added_handler != NULL) + manager->text_display_added_handler (manager->event_handler_data, display); +} + +static void +create_devices_for_terminal_and_renderer_type (ply_device_manager_t *manager, + const char *device_path, + ply_terminal_t *terminal, + ply_renderer_type_t renderer_type) { - ply_seat_t *seat; + ply_renderer_t *renderer = NULL; + ply_keyboard_t *keyboard = NULL; + bool is_local_terminal = false; if (terminal != NULL && manager->local_console_terminal == terminal) is_local_terminal = true; - if (is_local_terminal && manager->local_console_seat != NULL) { - ply_trace ("trying to create seat for local console when one already exists"); + if (is_local_terminal && manager->local_console_managed) { + ply_trace ("trying to create devices for local console when one already exists"); return; } - ply_trace ("creating seat for %s (renderer type: %u) (terminal: %s)", + ply_trace ("creating devices for %s (renderer type: %u) (terminal: %s)", device_path ? : "", renderer_type, terminal ? ply_terminal_get_name (terminal) : "none"); - seat = ply_seat_new (terminal); - if (!ply_seat_open (seat, renderer_type, device_path)) { - ply_trace ("could not create seat"); - ply_seat_free (seat); - return; + if (renderer_type != PLY_RENDERER_TYPE_NONE) { + renderer = ply_renderer_new (renderer_type, device_path, terminal); + + if (!ply_renderer_open (renderer)) { + ply_trace ("could not open renderer for %s", device_path); + ply_renderer_free (renderer); + + if (renderer_type != PLY_RENDERER_TYPE_AUTO) + return; + } } - ply_list_append_data (manager->seats, seat); + if (renderer != NULL) { + keyboard = ply_keyboard_new_for_renderer (renderer); + ply_list_append_data (manager->keyboards, keyboard); - if (is_local_terminal) - manager->local_console_seat = seat; + if (manager->keyboard_added_handler != NULL) + manager->keyboard_added_handler (manager->event_handler_data, keyboard); + + create_pixel_displays_for_renderer (manager, renderer); + ply_hashtable_insert (manager->renderers, strdup (device_path), renderer); + } else if (terminal != NULL) { + keyboard = ply_keyboard_new_for_terminal (terminal); + ply_list_append_data (manager->keyboards, keyboard); + + if (manager->keyboard_added_handler != NULL) + manager->keyboard_added_handler (manager->event_handler_data, keyboard); + } + + if (terminal != NULL) { + create_text_displays_for_terminal (manager, terminal); - if (manager->seat_added_handler != NULL) - manager->seat_added_handler (manager->seat_event_handler_data, seat); + if (is_local_terminal) + { + manager->local_console_is_text = true; + } + } + + if (keyboard != NULL) { + ply_keyboard_watch_for_input (keyboard); + } + + if (is_local_terminal) + manager->local_console_managed = true; } static void -create_seat_for_terminal (const char *device_path, +create_devices_for_terminal (const char *device_path, ply_terminal_t *terminal, ply_device_manager_t *manager) { - create_seat_for_terminal_and_renderer_type (manager, + create_devices_for_terminal_and_renderer_type (manager, device_path, terminal, PLY_RENDERER_TYPE_NONE); } static bool -create_seats_from_terminals (ply_device_manager_t *manager) +create_devices_from_terminals (ply_device_manager_t *manager) { bool has_serial_consoles; @@ -678,7 +765,7 @@ create_seats_from_terminals (ply_device_manager_t *manager) ply_trace ("serial consoles detected, managing them with details forced"); ply_hashtable_foreach (manager->terminals, (ply_hashtable_foreach_func_t *) - create_seat_for_terminal, + create_devices_for_terminal, manager); return true; } @@ -687,32 +774,32 @@ create_seats_from_terminals (ply_device_manager_t *manager) } static void -create_seats_from_udev (ply_device_manager_t *manager) +create_devices_from_udev (ply_device_manager_t *manager) { bool found_drm_device, found_fb_device; ply_trace ("Looking for devices from udev"); - found_drm_device = create_seats_for_subsystem (manager, SUBSYSTEM_DRM); - found_fb_device = create_seats_for_subsystem (manager, SUBSYSTEM_FRAME_BUFFER); + found_drm_device = create_devices_for_subsystem (manager, SUBSYSTEM_DRM); + found_fb_device = create_devices_for_subsystem (manager, SUBSYSTEM_FRAME_BUFFER); if (found_drm_device || found_fb_device) return; - ply_trace ("Creating non-graphical seat, since there's no suitable graphics hardware"); - create_seat_for_terminal_and_renderer_type (manager, + ply_trace ("Creating non-graphical devices, since there's no suitable graphics hardware"); + create_devices_for_terminal_and_renderer_type (manager, ply_terminal_get_name (manager->local_console_terminal), manager->local_console_terminal, PLY_RENDERER_TYPE_NONE); } static void -create_fallback_seat (ply_device_manager_t *manager) +create_fallback_devices (ply_device_manager_t *manager) { - create_seat_for_terminal_and_renderer_type (manager, - ply_terminal_get_name (manager->local_console_terminal), - manager->local_console_terminal, - PLY_RENDERER_TYPE_AUTO); + create_devices_for_terminal_and_renderer_type (manager, + ply_terminal_get_name (manager->local_console_terminal), + manager->local_console_terminal, + PLY_RENDERER_TYPE_AUTO); } static void @@ -731,7 +818,7 @@ on_udev_queue_changed (ply_device_manager_t *manager) manager->udev_queue = NULL; - create_seats_from_udev (manager); + create_devices_from_udev (manager); } static void @@ -744,7 +831,7 @@ watch_for_coldplug_completion (ply_device_manager_t *manager) if (udev_queue_get_queue_is_empty (manager->udev_queue)) { ply_trace ("udev coldplug completed already "); - create_seats_from_udev (manager); + create_devices_from_udev (manager); return; } @@ -755,7 +842,7 @@ watch_for_coldplug_completion (ply_device_manager_t *manager) ply_trace ("could not watch for udev to show up: %m"); close (fd); - create_fallback_seat (manager); + create_fallback_devices (manager); return; } @@ -771,27 +858,35 @@ watch_for_coldplug_completion (ply_device_manager_t *manager) } void -ply_device_manager_watch_seats (ply_device_manager_t *manager, - ply_seat_added_handler_t seat_added_handler, - ply_seat_removed_handler_t seat_removed_handler, - void *data) -{ - bool done_with_initial_seat_setup; - - manager->seat_added_handler = seat_added_handler; - manager->seat_removed_handler = seat_removed_handler; - manager->seat_event_handler_data = data; - - /* Try to create seats for each serial device right away, if possible +ply_device_manager_watch_devices (ply_device_manager_t *manager, + ply_keyboard_added_handler_t keyboard_added_handler, + ply_keyboard_removed_handler_t keyboard_removed_handler, + ply_pixel_display_added_handler_t pixel_display_added_handler, + ply_pixel_display_removed_handler_t pixel_display_removed_handler, + ply_text_display_added_handler_t text_display_added_handler, + ply_text_display_removed_handler_t text_display_removed_handler, + void *data) +{ + bool done_with_initial_devices_setup; + + manager->keyboard_added_handler = keyboard_added_handler; + manager->keyboard_removed_handler = keyboard_removed_handler; + manager->pixel_display_added_handler = pixel_display_added_handler; + manager->pixel_display_removed_handler = pixel_display_removed_handler; + manager->text_display_added_handler = text_display_added_handler; + manager->text_display_removed_handler = text_display_removed_handler; + manager->event_handler_data = data; + + /* Try to create devices for each serial device right away, if possible */ - done_with_initial_seat_setup = create_seats_from_terminals (manager); + done_with_initial_devices_setup = create_devices_from_terminals (manager); - if (done_with_initial_seat_setup) + if (done_with_initial_devices_setup) return; if ((manager->flags & PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV)) { - ply_trace ("udev support disabled, creating fallback seat"); - create_fallback_seat (manager); + ply_trace ("udev support disabled, creating fallback devices"); + create_fallback_devices (manager); return; } @@ -800,31 +895,28 @@ ply_device_manager_watch_seats (ply_device_manager_t *manager, } bool -ply_device_manager_has_open_seats (ply_device_manager_t *manager) +ply_device_manager_has_displays (ply_device_manager_t *manager) { - ply_list_node_t *node; - - node = ply_list_get_first_node (manager->seats); - while (node != NULL) { - ply_seat_t *seat; - ply_list_node_t *next_node; - - seat = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (manager->seats, node); - - if (ply_seat_is_open (seat)) - return true; + return ply_list_get_length (manager->pixel_displays) > 0 || + ply_list_get_length (manager->text_displays) > 0; +} - node = next_node; - } +ply_list_t * +ply_device_manager_get_keyboards (ply_device_manager_t *manager) +{ + return manager->keyboards; +} - return false; +ply_list_t * +ply_device_manager_get_pixel_displays (ply_device_manager_t *manager) +{ + return manager->pixel_displays; } ply_list_t * -ply_device_manager_get_seats (ply_device_manager_t *manager) +ply_device_manager_get_text_displays (ply_device_manager_t *manager) { - return manager->seats; + return manager->text_displays; } ply_terminal_t * @@ -833,44 +925,39 @@ ply_device_manager_get_default_terminal (ply_device_manager_t *manager) return manager->local_console_terminal; } +static void +activate_renderer (char *device_path, + ply_renderer_t *renderer, + ply_device_manager_t *manager) +{ + ply_renderer_activate (renderer); +} + void ply_device_manager_activate_renderers (ply_device_manager_t *manager) { - ply_list_node_t *node; - ply_trace ("activating renderers"); - node = ply_list_get_first_node (manager->seats); - while (node != NULL) { - ply_seat_t *seat; - ply_list_node_t *next_node; - - seat = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (manager->seats, node); - - ply_seat_activate_renderer (seat); + ply_hashtable_foreach (manager->renderers, + (ply_hashtable_foreach_func_t *) + activate_renderer, + manager); +} - node = next_node; - } +static void +deactivate_renderer (char *device_path, + ply_renderer_t *renderer, + ply_device_manager_t *manager) +{ + ply_renderer_deactivate (renderer); } void ply_device_manager_deactivate_renderers (ply_device_manager_t *manager) { - ply_list_node_t *node; - - ply_trace ("deactivating renderers"); - node = ply_list_get_first_node (manager->seats); - while (node != NULL) { - ply_seat_t *seat; - ply_list_node_t *next_node; - - seat = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (manager->seats, node); - - ply_seat_deactivate_renderer (seat); - - node = next_node; - } + ply_hashtable_foreach (manager->renderers, + (ply_hashtable_foreach_func_t *) + deactivate_renderer, + manager); } void @@ -879,15 +966,15 @@ ply_device_manager_activate_keyboards (ply_device_manager_t *manager) ply_list_node_t *node; ply_trace ("activating keyboards"); - node = ply_list_get_first_node (manager->seats); + node = ply_list_get_first_node (manager->keyboards); while (node != NULL) { - ply_seat_t *seat; + ply_keyboard_t *keyboard; ply_list_node_t *next_node; - seat = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (manager->seats, node); + keyboard = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (manager->keyboards, node); - ply_seat_activate_keyboard (seat); + ply_keyboard_watch_for_input (keyboard); node = next_node; } @@ -899,15 +986,15 @@ ply_device_manager_deactivate_keyboards (ply_device_manager_t *manager) ply_list_node_t *node; ply_trace ("deactivating keyboards"); - node = ply_list_get_first_node (manager->seats); + node = ply_list_get_first_node (manager->keyboards); while (node != NULL) { - ply_seat_t *seat; + ply_keyboard_t *keyboard; ply_list_node_t *next_node; - seat = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (manager->seats, node); + keyboard = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (manager->keyboards, node); - ply_seat_deactivate_keyboard (seat); + ply_keyboard_stop_watching_for_input (keyboard); node = next_node; } diff --git a/src/libply-splash-core/ply-device-manager.h b/src/libply-splash-core/ply-device-manager.h index c3e6487b..599be905 100644 --- a/src/libply-splash-core/ply-device-manager.h +++ b/src/libply-splash-core/ply-device-manager.h @@ -21,7 +21,11 @@ #define PLY_DEVICE_MANAGER_H #include -#include "ply-seat.h" + +#include "ply-keyboard.h" +#include "ply-pixel-display.h" +#include "ply-renderer.h" +#include "ply-text-display.h" typedef enum { @@ -31,20 +35,28 @@ typedef enum } ply_device_manager_flags_t; typedef struct _ply_device_manager ply_device_manager_t; -typedef void (*ply_seat_added_handler_t) (void *, - ply_seat_t *); -typedef void (*ply_seat_removed_handler_t) (void *, - ply_seat_t *); +typedef void (* ply_keyboard_added_handler_t) (void *, ply_keyboard_t *); +typedef void (* ply_keyboard_removed_handler_t) (void *, ply_keyboard_t *); +typedef void (* ply_pixel_display_added_handler_t) (void *, ply_pixel_display_t *); +typedef void (* ply_pixel_display_removed_handler_t) (void *, ply_pixel_display_t *); +typedef void (* ply_text_display_added_handler_t) (void *, ply_text_display_t *); +typedef void (* ply_text_display_removed_handler_t) (void *, ply_text_display_t *); #ifndef PLY_HIDE_FUNCTION_DECLARATIONS ply_device_manager_t *ply_device_manager_new (const char *default_tty, ply_device_manager_flags_t flags); -void ply_device_manager_watch_seats (ply_device_manager_t *manager, - ply_seat_added_handler_t seat_added_handler, - ply_seat_removed_handler_t seat_removed_handler, - void *data); -bool ply_device_manager_has_open_seats (ply_device_manager_t *manager); -ply_list_t *ply_device_manager_get_seats (ply_device_manager_t *manager); +void ply_device_manager_watch_devices (ply_device_manager_t *manager, + ply_keyboard_added_handler_t keyboard_added_handler, + ply_keyboard_removed_handler_t keyboard_removed_handler, + ply_pixel_display_added_handler_t pixel_display_added_handler, + ply_pixel_display_removed_handler_t pixel_display_removed_handler, + ply_text_display_added_handler_t text_display_added_handler, + ply_text_display_removed_handler_t text_display_removed_handler, + void *data); +bool ply_device_manager_has_displays (ply_device_manager_t *manager); +ply_list_t *ply_device_manager_get_keyboards (ply_device_manager_t *manager); +ply_list_t *ply_device_manager_get_pixel_displays (ply_device_manager_t *manager); +ply_list_t *ply_device_manager_get_text_displays (ply_device_manager_t *manager); void ply_device_manager_free (ply_device_manager_t *manager); void ply_device_manager_activate_keyboards (ply_device_manager_t *manager); void ply_device_manager_deactivate_keyboards (ply_device_manager_t *manager); diff --git a/src/main.c b/src/main.c index da6e95d6..89cb6073 100644 --- a/src/main.c +++ b/src/main.c @@ -136,8 +136,8 @@ static ply_boot_splash_t *load_theme (state_t *state, static ply_boot_splash_t *show_theme (state_t *state, const char *theme_path); -static void attach_splash_to_seats (state_t *state, - ply_boot_splash_t *splash); +static void attach_splash_to_devices (state_t *state, + ply_boot_splash_t *splash); static bool attach_to_running_session (state_t *state); static void detach_from_running_session (state_t *state); static void on_escape_pressed (state_t *state); @@ -520,14 +520,14 @@ on_ask_for_password (state_t *state, * arrive shortly so just sit tight */ if (state->is_shown) { - bool has_open_seats; + bool has_displays; cancel_pending_delayed_show (state); - has_open_seats = ply_device_manager_has_open_seats (state->device_manager); + has_displays = ply_device_manager_has_displays (state->device_manager); - if (has_open_seats) { - ply_trace ("seats open now, showing splash immediately"); + if (has_displays) { + ply_trace ("displays available now, showing splash immediately"); show_splash (state); } else { ply_trace ("splash still coming up, waiting a bit"); @@ -891,7 +891,7 @@ plymouth_should_show_default_splash (state_t *state) static void on_show_splash (state_t *state) { - bool has_open_seats; + bool has_displays; if (state->is_shown) { ply_trace ("show splash called while already shown"); @@ -910,48 +910,19 @@ on_show_splash (state_t *state) } state->is_shown = true; - has_open_seats = ply_device_manager_has_open_seats (state->device_manager); + has_displays = ply_device_manager_has_displays (state->device_manager); - if (!state->is_attached && state->should_be_attached && has_open_seats) + if (!state->is_attached && state->should_be_attached && has_displays) attach_to_running_session (state); - if (has_open_seats) { - ply_trace ("at least one seat already open, so loading splash"); + if (has_displays) { + ply_trace ("at least one display already available, so loading splash"); show_splash (state); } else { - ply_trace ("no seats available to show splash on, waiting..."); + ply_trace ("no displays available to show splash on, waiting..."); } } -static void -on_seat_removed (state_t *state, - ply_seat_t *seat) -{ - ply_keyboard_t *keyboard; - - keyboard = ply_seat_get_keyboard (seat); - - ply_trace ("no longer listening for keystrokes"); - ply_keyboard_remove_input_handler (keyboard, - (ply_keyboard_input_handler_t) - on_keyboard_input); - ply_trace ("no longer listening for escape"); - ply_keyboard_remove_escape_handler (keyboard, - (ply_keyboard_escape_handler_t) - on_escape_pressed); - ply_trace ("no longer listening for backspace"); - ply_keyboard_remove_backspace_handler (keyboard, - (ply_keyboard_backspace_handler_t) - on_backspace); - ply_trace ("no longer listening for enter"); - ply_keyboard_remove_enter_handler (keyboard, - (ply_keyboard_enter_handler_t) - on_enter); - - if (state->boot_splash != NULL) - ply_boot_splash_detach_from_seat (state->boot_splash, seat); -} - static void show_splash (state_t *state) { @@ -991,23 +962,9 @@ show_splash (state_t *state) } static void -on_seat_added (state_t *state, - ply_seat_t *seat) +on_keyboard_added (state_t *state, + ply_keyboard_t *keyboard) { - ply_keyboard_t *keyboard; - - if (state->is_shown && !state->is_inactive) { - if (state->boot_splash == NULL) { - ply_trace ("seat added before splash loaded, so loading splash now"); - show_splash (state); - } else { - ply_trace ("seat added after splash loaded, so attaching to splash"); - ply_boot_splash_attach_to_seat (state->boot_splash, seat); - } - } - - keyboard = ply_seat_get_keyboard (seat); - ply_trace ("listening for keystrokes"); ply_keyboard_add_input_handler (keyboard, (ply_keyboard_input_handler_t) @@ -1024,6 +981,86 @@ on_seat_added (state_t *state, ply_keyboard_add_enter_handler (keyboard, (ply_keyboard_enter_handler_t) on_enter, state); + + if (state->boot_splash != NULL) { + ply_trace ("keyboard set after splash loaded, so attaching to splash"); + ply_boot_splash_set_keyboard (state->boot_splash, keyboard); + } +} + +static void +on_keyboard_removed (state_t *state, + ply_keyboard_t *keyboard) +{ + ply_trace ("no longer listening for keystrokes"); + ply_keyboard_remove_input_handler (keyboard, + (ply_keyboard_input_handler_t) + on_keyboard_input); + ply_trace ("no longer listening for escape"); + ply_keyboard_remove_escape_handler (keyboard, + (ply_keyboard_escape_handler_t) + on_escape_pressed); + ply_trace ("no longer listening for backspace"); + ply_keyboard_remove_backspace_handler (keyboard, + (ply_keyboard_backspace_handler_t) + on_backspace); + ply_trace ("no longer listening for enter"); + ply_keyboard_remove_enter_handler (keyboard, + (ply_keyboard_enter_handler_t) + on_enter); + + if (state->boot_splash != NULL) + ply_boot_splash_unset_keyboard (state->boot_splash); +} + +static void +on_pixel_display_added (state_t *state, + ply_pixel_display_t *display) +{ + if (state->is_shown) { + if (state->boot_splash == NULL) { + ply_trace ("pixel display added before splash loaded, so loading splash now"); + show_splash (state); + } else { + ply_trace ("pixel display added after splash loaded, so attaching to splash"); + ply_boot_splash_add_pixel_display (state->boot_splash, display); + } + } +} + +static void +on_pixel_display_removed (state_t *state, + ply_pixel_display_t *display) +{ + if (state->boot_splash == NULL) + return; + + ply_boot_splash_remove_pixel_display (state->boot_splash, display); +} + +static void +on_text_display_added (state_t *state, + ply_text_display_t *display) +{ + if (state->is_shown) { + if (state->boot_splash == NULL) { + ply_trace ("text display added before splash loaded, so loading splash now"); + show_splash (state); + } else { + ply_trace ("text display added after splash loaded, so attaching to splash"); + ply_boot_splash_add_text_display (state->boot_splash, display); + } + } +} + +static void +on_text_display_removed (state_t *state, + ply_text_display_t *display) +{ + if (state->boot_splash == NULL) + return; + + ply_boot_splash_remove_text_display (state->boot_splash, display); } static void @@ -1033,12 +1070,20 @@ load_devices (state_t *state, state->device_manager = ply_device_manager_new (state->default_tty, flags); state->local_console_terminal = ply_device_manager_get_default_terminal (state->device_manager); - ply_device_manager_watch_seats (state->device_manager, - (ply_seat_added_handler_t) - on_seat_added, - (ply_seat_removed_handler_t) - on_seat_removed, - state); + ply_device_manager_watch_devices (state->device_manager, + (ply_keyboard_added_handler_t) + on_keyboard_added, + (ply_keyboard_removed_handler_t) + on_keyboard_removed, + (ply_pixel_display_added_handler_t) + on_pixel_display_added, + (ply_pixel_display_removed_handler_t) + on_pixel_display_removed, + (ply_text_display_added_handler_t) + on_text_display_added, + (ply_text_display_removed_handler_t) + on_text_display_removed, + state); } static void @@ -1507,22 +1552,52 @@ on_enter (state_t *state, } static void -attach_splash_to_seats (state_t *state, - ply_boot_splash_t *splash) +attach_splash_to_devices (state_t *state, + ply_boot_splash_t *splash) { - ply_list_t *seats; + ply_list_t *keyboards; + ply_list_t *pixel_displays; + ply_list_t *text_displays; ply_list_node_t *node; - seats = ply_device_manager_get_seats (state->device_manager); - node = ply_list_get_first_node (seats); + keyboards = ply_device_manager_get_keyboards (state->device_manager); + node = ply_list_get_first_node (keyboards); + while (node != NULL) { + ply_keyboard_t *keyboard; + ply_list_node_t *next_node; + + keyboard = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (keyboards, node); + + ply_boot_splash_set_keyboard (splash, keyboard); + + node = next_node; + } + + pixel_displays = ply_device_manager_get_pixel_displays (state->device_manager); + node = ply_list_get_first_node (pixel_displays); + while (node != NULL) { + ply_pixel_display_t *pixel_display; + ply_list_node_t *next_node; + + pixel_display = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (pixel_displays, node); + + ply_boot_splash_add_pixel_display (splash, pixel_display); + + node = next_node; + } + + text_displays = ply_device_manager_get_text_displays (state->device_manager); + node = ply_list_get_first_node (text_displays); while (node != NULL) { - ply_seat_t *seat; + ply_text_display_t *text_display; ply_list_node_t *next_node; - seat = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (seats, node); + text_display = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (text_displays, node); - ply_boot_splash_attach_to_seat (splash, seat); + ply_boot_splash_add_text_display (splash, text_display); node = next_node; } @@ -1623,7 +1698,7 @@ show_theme (state_t *state, if (splash == NULL) return NULL; - attach_splash_to_seats (state, splash); + attach_splash_to_devices (state, splash); ply_device_manager_activate_renderers (state->device_manager); splash_mode = get_splash_mode_from_mode (state->mode);