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;
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
}
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;
}
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);
#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
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
}
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;
}
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);
}
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;
}
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);
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")) {
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");
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);
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,
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)
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))
(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);
}
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;
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;
}
}
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
manager->udev_queue = NULL;
- create_seats_from_udev (manager);
+ create_devices_from_udev (manager);
}
static void
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;
}
ply_trace ("could not watch for udev to show up: %m");
close (fd);
- create_fallback_seat (manager);
+ create_fallback_devices (manager);
return;
}
}
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;
}
}
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 *
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
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;
}
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;
}
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);
* 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");
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");
}
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)
{
}
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)
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
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
}
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;
}
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);
projects / thirdparty / plymouth.git / commitdiff
