From 14bdb7cadcfb2d3aac54b89b91217ef58abd8377 Mon Sep 17 00:00:00 2001

From: Ray Strode <rstrode@redhat.com>

Date: Thu, 24 Sep 2015 09:21:18 -0400

Subject: [PATCH 1/6] device-manager: activate new renderers after adding to

 renderers list

When a new renderer gets created, we should activate it, if the device

manager is already active.

At the moment we call create_pixel_displays_for_renderer which would

implicitly activate it (from a callback), except we call it one line

too early, so the renderer isn't in the list of known renderers yet.

This commit swaps the two lines and also adds an explicit renderer

activation for clarity.  For symmetry it makes the same change to

keyboards that it makes to renderers.

---

 src/libply-splash-core/ply-device-manager.c | 20 ++++++++++++++++++--

 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/src/libply-splash-core/ply-device-manager.c b/src/libply-splash-core/ply-device-manager.c

index f09448a..14d7616 100644

--- a/src/libply-splash-core/ply-device-manager.c

+++ b/src/libply-splash-core/ply-device-manager.c

@@ -45,60 +45,62 @@ static void create_devices_for_terminal_and_renderer_type (ply_device_manager_t

                                                            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_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_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;

   uint32_t                    serial_consoles_detected : 1;

+  uint32_t                    renderers_activated : 1;

+  uint32_t                    keyboards_activated : 1;

 };

 static void

 detach_from_event_loop (ply_device_manager_t *manager)

 {

   assert (manager != NULL);

   manager->loop = NULL;

 }

 static void

 attach_to_event_loop (ply_device_manager_t *manager,

                       ply_event_loop_t     *loop)

 {

   assert (manager != NULL);

   assert (loop != NULL);

   assert (manager->loop == NULL);

   manager->loop = loop;

   ply_event_loop_watch_for_exit (loop, (ply_event_loop_exit_handler_t)

                                  detach_from_event_loop,

                                  manager);

 }

 static bool

 drm_device_in_use (ply_device_manager_t *manager,

                    const char           *device_path)

 {

   ply_renderer_t *renderer;

@@ -696,85 +698,92 @@ create_devices_for_terminal_and_renderer_type (ply_device_manager_t *manager,

       ply_trace ("ignoring device %s since it's already managed",

                  device_path);

       return;

     }

   ply_trace ("creating devices for %s (renderer type: %u) (terminal: %s)",

              device_path? : "", renderer_type, terminal? ply_terminal_get_name (terminal): "none");

   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);

           renderer = NULL;

           if (renderer_type != PLY_RENDERER_TYPE_AUTO)

             return;

         }

     }

   if (renderer != NULL)

     {

       keyboard = ply_keyboard_new_for_renderer (renderer);

       ply_list_append_data (manager->keyboards, keyboard);

       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);

+      create_pixel_displays_for_renderer (manager, renderer);

+

+      if (manager->renderers_activated)

+        {

+          ply_trace ("activating renderer");

+          ply_renderer_activate (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 (terminal == manager->local_console_terminal)

         {

           manager->local_console_is_text = renderer == NULL;

           manager->local_console_managed = true;

         }

     }

-  if (keyboard != NULL)

+  if (keyboard != NULL && manager->keyboards_activated)

     {

+      ply_trace ("activating keyboards");

       ply_keyboard_watch_for_input (keyboard);

     }

 }

 static void

 create_devices_for_terminal (const char           *device_path,

                              ply_terminal_t       *terminal,

                              ply_device_manager_t *manager)

 {

   create_devices_for_terminal_and_renderer_type (manager,

                                                  device_path,

                                                  terminal,

                                                  PLY_RENDERER_TYPE_NONE);

 }

 static bool

 create_devices_from_terminals (ply_device_manager_t *manager)

 {

   bool has_serial_consoles;

   ply_trace ("checking for consoles");

   if (manager->flags & PLY_DEVICE_MANAGER_FLAGS_IGNORE_SERIAL_CONSOLES)

     {

       has_serial_consoles = false;

       ply_trace ("ignoring all consoles but default console because explicitly told to.");

     }

   else

     {

       has_serial_consoles = add_consoles_from_file (manager, "/sys/class/tty/console/active");

     }

@@ -946,91 +955,98 @@ ply_device_manager_get_text_displays (ply_device_manager_t *manager)

 }

 ply_terminal_t *

 ply_device_manager_get_default_terminal (ply_device_manager_t *manager)

 {

   return manager->local_console_terminal;

 }

 bool

 ply_device_manager_has_serial_consoles (ply_device_manager_t *manager)

 {

   return manager->serial_consoles_detected;

 }

 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_trace ("activating renderers");

   ply_hashtable_foreach (manager->renderers,

                          (ply_hashtable_foreach_func_t *)

                          activate_renderer,

                          manager);

+

+  manager->renderers_activated = true;

 }

 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_trace ("deactivating renderers");

   ply_hashtable_foreach (manager->renderers,

                          (ply_hashtable_foreach_func_t *)

                          deactivate_renderer,

                          manager);

+  manager->renderers_activated = false;

 }

 void

 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->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 (manager->keyboards, node);

       ply_keyboard_watch_for_input (keyboard);

       node = next_node;

     }

+

+  manager->keyboards_activated = true;

 }

 void

 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->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 (manager->keyboards, node);

       ply_keyboard_stop_watching_for_input (keyboard);

       node = next_node;

     }

+

+  manager->keyboards_activated = false;

 }

-- 

2.5.0

From 61ca85cd95de1e467e4996a5563c5f77221e569f Mon Sep 17 00:00:00 2001

From: Ray Strode <rstrode@redhat.com>

Date: Thu, 24 Sep 2015 15:53:01 -0400

Subject: [PATCH 2/6] plugins: unset draw handler when freeing view

If the view is freed, we definitely shouldn't draw

the view's display anymore.

---

 src/plugins/splash/fade-throbber/plugin.c | 4 ++--

 src/plugins/splash/space-flares/plugin.c  | 4 ++--

 src/plugins/splash/throbgress/plugin.c    | 4 ++--

 src/plugins/splash/two-step/plugin.c      | 3 ++-

 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/plugins/splash/fade-throbber/plugin.c b/src/plugins/splash/fade-throbber/plugin.c

index 4af6cae..7b097c0 100644

--- a/src/plugins/splash/fade-throbber/plugin.c

+++ b/src/plugins/splash/fade-throbber/plugin.c

@@ -240,60 +240,62 @@ free_stars (view_t *view)

 static void detach_from_event_loop (ply_boot_splash_plugin_t *plugin);

 static view_t *

 view_new (ply_boot_splash_plugin_t *plugin,

           ply_pixel_display_t      *display)

 {

   view_t *view;

   view = calloc (1, sizeof (view_t));

   view->plugin = plugin;

   view->display = display;

   view->entry = ply_entry_new (plugin->image_dir);

   view->stars = ply_list_new ();

   view->label = ply_label_new ();

   view->message_label = ply_label_new ();

   return view;

 }

 static void

 view_free (view_t *view)

 {

   ply_entry_free (view->entry);

   ply_label_free (view->message_label);

   free_stars (view);

+  ply_pixel_display_set_draw_handler (view->display, NULL, NULL);

+

   free (view);

 }

 static bool

 view_load (view_t *view)

 {

   ply_trace ("loading entry");

   if (!ply_entry_load (view->entry))

     return false;

   return true;

 }

 static bool

 load_views (ply_boot_splash_plugin_t *plugin)

 {

   ply_list_node_t *node;

   bool view_loaded;

   view_loaded = false;

   node = ply_list_get_first_node (plugin->views);

   while (node != NULL)

     {

       ply_list_node_t *next_node;

       view_t *view;

       view = ply_list_node_get_data (node);

       next_node = ply_list_get_next_node (plugin->views, node);

@@ -753,62 +755,60 @@ add_pixel_display (ply_boot_splash_plugin_t *plugin,

                    ply_pixel_display_t      *display)

 {

   view_t *view;

   view = view_new (plugin, display);

   ply_pixel_display_set_draw_handler (view->display,

                                       (ply_pixel_display_draw_handler_t)

                                       on_draw, view);

   ply_list_append_data (plugin->views, view);

 }

 static void

 remove_pixel_display (ply_boot_splash_plugin_t *plugin,

                       ply_pixel_display_t      *display)

 {

   ply_list_node_t *node;

   node = ply_list_get_first_node (plugin->views);

   while (node != NULL)

     {

       view_t *view;

       ply_list_node_t *next_node;

       view = ply_list_node_get_data (node);

       next_node = ply_list_get_next_node (plugin->views, node);

       if (view->display == display)

         {

-

-          ply_pixel_display_set_draw_handler (view->display, NULL, NULL);

           view_free (view);

           ply_list_remove_node (plugin->views, node);

           return;

         }

       node = next_node;

     }

 }

 static bool

 show_splash_screen (ply_boot_splash_plugin_t *plugin,

                     ply_event_loop_t         *loop,

                     ply_buffer_t             *boot_buffer,

                     ply_boot_splash_mode_t    mode)

 {

   assert (plugin != NULL);

   assert (plugin->logo_image != NULL);

   plugin->loop = loop;

   plugin->mode = mode;

   ply_trace ("loading logo image");

   if (!ply_image_load (plugin->logo_image))

     return false;

   ply_trace ("loading star image");

   if (!ply_image_load (plugin->star_image))

     return false;

   ply_trace ("loading lock image");

diff --git a/src/plugins/splash/space-flares/plugin.c b/src/plugins/splash/space-flares/plugin.c

index e31dce8..45863ff 100644

--- a/src/plugins/splash/space-flares/plugin.c

+++ b/src/plugins/splash/space-flares/plugin.c

@@ -210,60 +210,62 @@ static view_t *

 view_new (ply_boot_splash_plugin_t *plugin,

           ply_pixel_display_t      *display)

 {

   view_t *view;

   view = calloc (1, sizeof (view_t));

   view->plugin = plugin;

   view->display = display;

   view->entry = ply_entry_new (plugin->image_dir);

   view->label = ply_label_new ();

   view->message_label = ply_label_new ();

   view->sprites = ply_list_new ();

   return view;

 }

 static void view_free_sprites (view_t *view);

 static void

 view_free (view_t *view)

 {

   ply_entry_free (view->entry);

   ply_label_free (view->label);

   ply_label_free (view->message_label);

   view_free_sprites (view);

   ply_list_free (view->sprites);

+  ply_pixel_display_set_draw_handler (view->display, NULL, NULL);

+

   ply_image_free (view->scaled_background_image);

   free (view);

 }

 static void

 free_views (ply_boot_splash_plugin_t *plugin)

 {

   ply_list_node_t *node;

   node = ply_list_get_first_node (plugin->views);

   while (node != NULL)

     {

       ply_list_node_t *next_node;

       view_t *view;

       view = ply_list_node_get_data (node);

       next_node = ply_list_get_next_node (plugin->views, node);

       view_free (view);

       node = next_node;

     }

   ply_list_free (plugin->views);

   plugin->views = NULL;

 }

 static bool

 view_load (view_t *view)

@@ -1428,62 +1430,60 @@ add_pixel_display (ply_boot_splash_plugin_t *plugin,

                    ply_pixel_display_t      *display)

 {

   view_t *view;

   view = view_new (plugin, display);

   ply_pixel_display_set_draw_handler (view->display,

                                       (ply_pixel_display_draw_handler_t)

                                       on_draw, view);

   ply_list_append_data (plugin->views, view);

 }

 static void

 remove_pixel_display (ply_boot_splash_plugin_t *plugin,

                       ply_pixel_display_t      *display)

 {

   ply_list_node_t *node;

   node = ply_list_get_first_node (plugin->views);

   while (node != NULL)

     {

       view_t *view;

       ply_list_node_t *next_node;

       view = ply_list_node_get_data (node);

       next_node = ply_list_get_next_node (plugin->views, node);

       if (view->display == display)

         {

-

-          ply_pixel_display_set_draw_handler (view->display, NULL, NULL);

           view_free (view);

           ply_list_remove_node (plugin->views, node);

           return;

         }

       node = next_node;

     }

 }

 static void

 view_setup_scene (view_t *view)

 {

   ply_boot_splash_plugin_t *plugin;

   sprite_t *sprite;

   int i;

   int x, y;

   int width = 360;

   int height = 460;

   unsigned long screen_width, screen_height;

   plugin = view->plugin;

   screen_width = ply_pixel_display_get_width (view->display);

   screen_height = ply_pixel_display_get_height (view->display);

     {

       star_bg_t* star_bg;

       if (view->scaled_background_image)

         ply_image_free (view->scaled_background_image);

       view->scaled_background_image = ply_image_resize (plugin->logo_image, screen_width, screen_height);

diff --git a/src/plugins/splash/throbgress/plugin.c b/src/plugins/splash/throbgress/plugin.c

index fba809b..d669a74 100644

--- a/src/plugins/splash/throbgress/plugin.c

+++ b/src/plugins/splash/throbgress/plugin.c

@@ -115,60 +115,62 @@ static void become_idle (ply_boot_splash_plugin_t *plugin,

 static view_t *

 view_new (ply_boot_splash_plugin_t *plugin,

           ply_pixel_display_t      *display)

 {

   view_t *view;

   view = calloc (1, sizeof (view_t));

   view->plugin = plugin;

   view->display = display;

   view->entry = ply_entry_new (plugin->image_dir);

   view->throbber = ply_throbber_new (plugin->image_dir,

                                      "throbber-");

   view->progress_bar = ply_progress_bar_new ();

   view->label = ply_label_new ();

   view->message_label = ply_label_new ();

   return view;

 }

 static void

 view_free (view_t *view)

 {

   ply_entry_free (view->entry);

   ply_throbber_free (view->throbber);

   ply_progress_bar_free (view->progress_bar);

   ply_label_free (view->label);

   ply_label_free (view->message_label);

+  ply_pixel_display_set_draw_handler (view->display, NULL, NULL);

+

   free (view);

 }

 static void

 free_views (ply_boot_splash_plugin_t *plugin)

 {

   ply_list_node_t *node;

   node = ply_list_get_first_node (plugin->views);

   while (node != NULL)

     {

       ply_list_node_t *next_node;

       view_t *view;

       view = ply_list_node_get_data (node);

       next_node = ply_list_get_next_node (plugin->views, node);

       view_free (view);

       ply_list_remove_node (plugin->views, node);

       node = next_node;

     }

   ply_list_free (plugin->views);

   plugin->views = NULL;

 }

 static bool

 view_load (view_t *view)

@@ -631,62 +633,60 @@ add_pixel_display (ply_boot_splash_plugin_t *plugin,

   view_t *view;

   ply_trace ("adding pixel display to plugin");

   view = view_new (plugin, display);

   ply_pixel_display_set_draw_handler (view->display,

                                       (ply_pixel_display_draw_handler_t)

                                       on_draw, view);

   ply_list_append_data (plugin->views, view);

 }

 static void

 remove_pixel_display (ply_boot_splash_plugin_t *plugin,

                       ply_pixel_display_t      *display)

 {

   ply_list_node_t *node;

   ply_trace ("removing pixel display from plugin");

   node = ply_list_get_first_node (plugin->views);

   while (node != NULL)

     {

       view_t *view;

       ply_list_node_t *next_node;

       view = ply_list_node_get_data (node);

       next_node = ply_list_get_next_node (plugin->views, node);

       if (view->display == display)

         {

-

-          ply_pixel_display_set_draw_handler (view->display, NULL, NULL);

           view_free (view);

           ply_list_remove_node (plugin->views, node);

           return;

         }

       node = next_node;

     }

 }

 static bool

 show_splash_screen (ply_boot_splash_plugin_t *plugin,

                     ply_event_loop_t         *loop,

                     ply_buffer_t             *boot_buffer,

                     ply_boot_splash_mode_t    mode)

 {

   assert (plugin != NULL);

   assert (plugin->logo_image != NULL);

   plugin->loop = loop;

   plugin->mode = mode;

   ply_trace ("loading logo image");

   if (!ply_image_load (plugin->logo_image))

     return false;

   ply_trace ("loading lock image");

   if (!ply_image_load (plugin->lock_image))

     return false;

   ply_trace ("loading box image");

diff --git a/src/plugins/splash/two-step/plugin.c b/src/plugins/splash/two-step/plugin.c

index f48b41e..0253aac 100644

--- a/src/plugins/splash/two-step/plugin.c

+++ b/src/plugins/splash/two-step/plugin.c

@@ -155,60 +155,62 @@ view_new (ply_boot_splash_plugin_t *plugin,

   view->entry = ply_entry_new (plugin->animation_dir);

   view->end_animation = ply_animation_new (plugin->animation_dir,

                                            "animation-");

   view->progress_animation = ply_progress_animation_new (plugin->animation_dir,

                                                          "progress-");

   view->throbber = ply_throbber_new (plugin->animation_dir,

                                      "throbber-");

   ply_progress_animation_set_transition (view->progress_animation,

                                          plugin->transition,

                                          plugin->transition_duration);

   view->label = ply_label_new ();

   view->message_label = ply_label_new ();

   return view;

 }

 static void

 view_free (view_t *view)

 {

   ply_entry_free (view->entry);

   ply_animation_free (view->end_animation);