# lines.script - boot splash using script plugin # # Copyright (C) 2009 Canonical Ltd. # Copyright © 2010-2014 Aurélien Couderc # Copyright © 2014 Juliette Taka # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License along # with this program; if not, write to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # # Written by: Alberto Milone # # Based on the example provided with the "script plugin" written by: # Charlie Brej # #------------------------------- Constants ----------------------------------------- ELECTRONS_DISPLAYED = 3; SECS_BETWEEN_ANIMS = 2.5; #------------------------------- Globals ------------------------------------------- # are we currently prompting for a password? prompt_active = 0; anim_iter = 0; anim_status = "stopped"; #------------------------------- Background ---------------------------------------- bg_image = Image("background.png"); # Compute screen/image ratio and scale the background accordingly window_max_width = Window.GetX() * 2 + Window.GetWidth(); window_max_height = Window.GetY() * 2 + Window.GetHeight(); screen_ratio = window_max_width / window_max_height; bg_image_ratio = bg_image.GetWidth() / bg_image.GetHeight(); if (screen_ratio > bg_image_ratio) bg_scale_factor = window_max_width / bg_image.GetWidth(); else bg_scale_factor = window_max_height / bg_image.GetHeight(); scaled_bg_image = bg_image.Scale(bg_image.GetWidth() * bg_scale_factor, bg_image.GetHeight() * bg_scale_factor); # Display background bg_sprite = Sprite(scaled_bg_image); bg_sprite.SetPosition(Window.GetX() + Window.GetWidth() / 2 - scaled_bg_image.GetWidth() / 2, Window.GetY() + Window.GetHeight() / 2 - scaled_bg_image.GetHeight() / 2, -10000); #------------------------------- Logo ---------------------------------------------- logo_image = Image("logo.png"); logo_height = Math.Min(Window.GetWidth(), Window.GetHeight()) * 0.7; logo_scale_factor = logo_height / logo_image.GetHeight(); logo_image = logo_image.Scale(logo_image.GetWidth() * logo_scale_factor, logo_image.GetHeight() * logo_scale_factor); logo_sprite = Sprite(logo_image); logo_to_top_edge = Window.GetHeight() * 0; logo_right_shift = logo_image.GetWidth() * 0.092; logo_sprite.SetPosition(Window.GetX() + Window.GetWidth() / 2 - logo_image.GetWidth() / 2 + logo_right_shift, Window.GetY() + logo_to_top_edge, -100); #------------------------------- Debian ---------------------------------------------- debian_image = Image("debian.png"); debian_width = logo_image.GetWidth(); debian_scale_factor = debian_width / debian_image.GetWidth() * 0.24; if (debian_scale_factor < 1) { debian_image = debian_image.Scale(debian_image.GetWidth() * debian_scale_factor, debian_image.GetHeight() * debian_scale_factor); } debian_sprite = Sprite(debian_image); debian_to_bottom_edge = Window.GetHeight() * 0.10; debian_sprite.SetPosition(Window.GetX() + Window.GetWidth() / 2 - debian_image.GetWidth() / 2, Window.GetY() + Window.GetHeight() - debian_to_bottom_edge - debian_image.GetHeight(), -90); #------------------------------- Electrons -------------------------------------------- electron_image = Image("electron.png"); electron_image = electron_image.Scale( electron_image.GetWidth() * 0.06 * logo_scale_factor, electron_image.GetHeight() * 0.06 * logo_scale_factor); #main center coords ellipses[0].x = logo_sprite.GetX() + logo_image.GetWidth() * 0.4245; ellipses[0].y = logo_sprite.GetY() + logo_image.GetHeight() * 0.611; #main small / large axis ellipses[0].height = logo_image.GetHeight() * 0.3303; ellipses[0].width = logo_image.GetWidth() * 0.295; #main animation parameters ellipses[0].anim.start_iter = 0; ellipses[0].anim.stop_iter = 150; ellipses[0].anim.start_angle = Math.Pi; ellipses[0].anim.arc = 2*Math.Pi; ellipses[0].anim.rotat_dir = -1; #left center coords ellipses[1].x = logo_sprite.GetX() + logo_image.GetWidth() * 0.3825; ellipses[1].y = logo_sprite.GetY() + logo_image.GetHeight() * 0.411; #left small / large axis ellipses[1].height = logo_image.GetHeight() * 0.1645; ellipses[1].width = logo_image.GetWidth() * 0.2248; #left animation parameters ellipses[1].anim.start_iter = 50; ellipses[1].anim.stop_iter = 130; ellipses[1].anim.start_angle = 0; ellipses[1].anim.arc = 2*Math.Pi; ellipses[1].anim.rotat_dir = 1; #right center coords ellipses[2].x = logo_sprite.GetX() + logo_image.GetWidth() * 0.7065; ellipses[2].y = logo_sprite.GetY() + logo_image.GetHeight() * 0.460; #right small / large axis ellipses[2].height = logo_image.GetHeight() * 0.2343; ellipses[2].width = logo_image.GetWidth() * 0.2945; #right animation parameters ellipses[2].anim.start_iter = 20; ellipses[2].anim.stop_iter = 100; ellipses[2].anim.start_angle = 0; ellipses[2].anim.arc = 2*Math.Pi; ellipses[2].anim.rotat_dir = 1; # Define 5 sprites for each electron to create gradient along the ellipses for (i = 0; i < ELECTRONS_DISPLAYED; i++) { anim = ellipses[i].anim; anim.angle_incr = anim.arc / (anim.stop_iter - anim.start_iter) * anim.rotat_dir; for (j = 0; j < 5; j++) { electron_sprite[i][j] = Sprite(electron_image); electron_sprite[i][j].SetOpacity(0); electron_sprite[i][j].base_opacity = 1-(0.2*j); electron_sprite[i][j].angle_diff = -(anim.rotat_dir*j*0.01); } } # Set the text colour in (rgb / 256) text_colour.red = 1.0; text_colour.green = 1.0; text_colour.blue = 1.0; # Tinted text #988592 tinted_text_colour.red = 1.0; tinted_text_colour.green = 1.0; tinted_text_colour.blue = 1.0; # Action Text - #ffffff - RGB 255 255 255 action_text_colour.red = 1.0; action_text_colour.green = 1.0; action_text_colour.blue = 1.0; # Orange - #ff4012 - RGB 255 64 18 debugsprite = Sprite(); debugsprite_bottom = Sprite(); debugsprite_bottom.SetPosition(0, (Window.GetHeight (0) - 20), 1); debugsprite_medium = Sprite(); debugsprite_medium.SetPosition(0, (Window.GetHeight (0) - 100), 1); # General purpose function to create text fun WriteText (text, colour) { image = Image.Text (text, colour.red, colour.green, colour.blue); return image; } fun ImageFromText (text) { image = WriteText (text, text_colour); return image; } fun ImageFromTintedText (text) { image = WriteText (text, tinted_text_colour); return image; } fun ImageFromActionText (text) { image = WriteText (text, action_text_colour); return image; } fun Debug(text) { debugsprite.SetImage(ImageFromText (text)); } fun DebugBottom(text) { debugsprite_bottom.SetImage(ImageFromText (text)); } fun DebugMedium(text) { debugsprite_medium.SetImage(ImageFromText (text)); } fun TextYOffset() { local.y; local.text_height; local.min_height; # Put the 1st line below the logo + some spacing y = logo_sprite.GetY() + logo_image.GetHeight(); #Debug("y = " + y); text_height = first_line_height * 7.5; min_height = window_max.height; if (y + text_height > min_height) y = min_height - text_height; # Ensure we don’t bump into the Debian image. # The approx height of the 3 text lines + password input is 140 px. y = Math.Min(y, debian_sprite.GetY() - 140); return y; } #------------------------------String functions------------------------------- # This is the equivalent for strstr() fun StringString(string, substring) { start = 0; while (String(string).CharAt (start)) { walk = 0; while (String(substring).CharAt (walk) == String(string).CharAt (start + walk) ) { walk++; if (!String(substring).CharAt (walk)) return start; } start++; } return NULL; } fun StringLength (string) { index = 0; while (String(string).CharAt(index)) index++; return index; } fun StringCopy (source, beginning, end) { local.destination = ""; for (index = beginning; ( ( (end == NULL) || (index <= end) ) && (String(source).CharAt(index)) ); index++) { local.destination += String(source).CharAt(index); } return local.destination; } fun StringReplace (source, pattern, replacement) { local.found = StringString(source, pattern); if (local.found == NULL) return source; local.new_string = StringCopy (source, 0, local.found - 1) + replacement + StringCopy (source, local.found + StringLength(pattern), NULL); return local.new_string; } # it makes sense to use it only for # numbers up to 100 fun StringToInteger (str) { int = -1; for (i=0; i<=100; i++) { if (i+"" == str) { int = i; break; } } return int; } #----------------------------------------------------------------------------- # Top background colour # #489291 --> 0.282, 0.572, 0.569 # New background colour # #0a3649 --> 0.039, 0.212, 0.286 # Window.SetBackgroundTopColor (0.282, 0.572, 0.569); # Nice colour on top of the screen fading to Window.SetBackgroundBottomColor (0.039, 0.212, 0.286); # an equally nice colour on the bottom bits_per_pixel = Window.GetBitsPerPixel (); # TODO need to handle 16 colors ? #if (bits_per_pixel == 4) { # logo_filename = "debian_logo16.png"; # progress_dot_off_filename = "progress_dot_off16.png"; # progress_dot_on_filename = "progress_dot_on16.png"; # password_dot_filename = "password_dot.png"; # password_field_filename = "password_field16.png"; #} else { # logo_filename = "debian_logo.png"; # progress_dot_off_filename = "progress_dot_off.png"; # progress_dot_on_filename = "progress_dot_on.png"; password_dot_filename = "password_dot.png"; password_field_filename = "password_field.png"; #} message_notification[0].image = ImageFromTintedText (""); message_notification[1].image = ImageFromTintedText (""); fsck_notification.image = ImageFromActionText (""); status = "normal"; # use a fixed string with ascending and descending stems to calibrate the # bounding box for the first message, so the messages below don't move up # and down according to *their* height. first_line_height = ImageFromTintedText ("AfpqtM").GetHeight(); # if the user has a 640x480 or 800x600 display, we can't quite fit everything # (including passphrase prompts) with the target spacing, so scoot the text up # a bit if needed. top_of_the_text = TextYOffset(); #-----------------------------------------Logo functions------------------------------ # Call this when updating the screen fun draw_logo () { # logo.sprite.SetX (logo.x); # logo.sprite.SetY (logo.y); # logo.sprite.SetZ (logo.z); # logo.sprite.SetOpacity (1); # logo_sprite.SetOpacity (1); } #-----------------------------------------Progress Indicator-------------------------- # Implement in boot progress callback fun animate_progress_indicator (time, progress) { # Start electrons animation at launch and every 3 seconds if (global.progress_time == NULL || (time - global.progress_time) >= SECS_BETWEEN_ANIMS) { global.progress_time = time; global.anim_status = "start"; } #Debug ("global progress time =" + global.progress_time + " global anim status = " + global.anim_status + " progress = " + progress + ", time = " + time); } #-----------------------------------------Label utility functions--------------------- # label should be either a string or NULL # Images for n lines will be created and returned as items of the # message_label array # fun get_message_label (label, is_fake, is_action_line) { #Debug("Get Label position"); local.message_label; if (is_fake) # Create a fake label so as to get the y coordinate of # a standard-length label. local.message_image = ImageFromTintedText ("This is a fake message"); else local.message_image = (is_action_line) && ImageFromActionText (label) || ImageFromTintedText (label); message_label.width = message_image.GetWidth (); message_label.height = message_image.GetHeight (); # Center the line horizontally message_label.x = Window.GetX () + Window.GetWidth () / 2 - message_label.width / 2; message_label.y = top_of_the_text; # Put the 2nd line below the fsck line if (is_action_line) { local.fsck_label.y = message_label.y + (first_line_height + first_line_height / 2); message_label.y = local.fsck_label.y + (first_line_height * 2); } #Debug("action label x = " + message_label.x + " y = " + message_label.y ); # message_debug = "msg_x = " + message_label.x + " msg_y = " + message_label.y + # "msg_width = " + message_label.width + " msg_height = " + # message_label.height + " message = " + label; # Debug(message_debug); return message_label; } # Create an fsck label and/or get its position fun get_fsck_label (label, is_fake) { # Debug("Get Label position"); local.fsck_label = global.progress_label; if (is_fake) fsck_label.image = ImageFromTintedText ("This is a fake message"); else fsck_label.image = ImageFromTintedText (label); fsck_label.width = fsck_label.image.GetWidth (); fsck_label.height = fsck_label.image.GetHeight (); # Centre the label horizontally fsck_label.x = Window.GetX () + Window.GetWidth () / 2 - fsck_label.width / 2; local.first_label = get_message_label (label, 1, 0); # Place the label below the 1st message line fsck_label.y = local.first_label.y + local.first_label.height + (local.first_label.height / 2); # message_debug = "msg_x = " + fsck_label.x + " msg_y = " + fsck_label.y + # "msg_width = " + fsck_label.width + " msg_height = " + # fsck_label.height + " message = " + label; # Debug(message_debug); return fsck_label; } #-----------------------------------------Message stuff -------------------------------- # # Set up a message label # # NOTE: this is called when doing something like 'plymouth message "hello world"' # fun setup_message (message_text, x, y, z, index) { #DebugMedium("Message setup: " + message_text); global.message_notification[index].image = (index) && ImageFromActionText (message_text) || ImageFromTintedText (message_text); # Set up the text message, if any message_notification[index].x = x; message_notification[index].y = y; message_notification[index].z = z; message_notification[index].sprite = Sprite (); message_notification[index].sprite.SetImage (message_notification[index].image); message_notification[index].sprite.SetX (message_notification[index].x); message_notification[index].sprite.SetY (message_notification[index].y); message_notification[index].sprite.SetZ (message_notification[index].z); } fun show_message (index) { if (global.message_notification[index].sprite) global.message_notification[index].sprite.SetOpacity(1); } fun hide_message (index) { if (global.message_notification[index].sprite) global.message_notification[index].sprite.SetOpacity(0); } # the callback function is called when new message should be displayed. # First arg is message to display. fun message_callback (message) { # Debug("Message callback"); is_fake = 0; if (!message || (message == "")) is_fake = 1; local.substring = "keys:"; # Look for the "keys:" prefix local.keys = StringString(message, local.substring); local.is_action_line = (keys != NULL); #Debug("keys " + local.keys + " substring length = " + StringLength(local.substring)); # Get the message without the "keys:" prefix if (keys != NULL) message = StringCopy (message, keys + StringLength(local.substring), NULL); # Get the message without the "fsckd-cancel-msg" prefix as we don't support i18n substring = "fsckd-cancel-msg:"; keys = StringString(message, substring); if (keys != NULL) message = StringCopy(message, keys + StringLength(substring), NULL); local.label.is_fake = is_fake; label = get_message_label(message, is_fake, is_action_line); label.z = 10000; setup_message (message, label.x, label.y, label.z, is_action_line); if (prompt_active && local.is_action_line) hide_message (is_action_line); else show_message (is_action_line); } #-----------------------------------------Display Password stuff ----------------------- # fun password_dialogue_setup (message_label) { #Debug("Password dialog setup"); local.entry; local.bullet_image; bullet_image = Image (password_dot_filename); entry.image = Image (password_field_filename); # Hide the normal labels prompt_active = 1; if (message_notification[1].sprite) hide_message (1); # Set the prompt label label = get_message_label(message_label, 0, 1); label.z = 10000; setup_message (message_label, label.x, label.y, label.z, 2); show_message (2); # Set up the text entry which contains the bullets entry.sprite = Sprite (); entry.sprite.SetImage (entry.image); # Centre the box horizontally entry.x = Window.GetX () + Window.GetWidth () / 2 - entry.image.GetWidth () / 2; # Put the entry below the second label. entry.y = message_notification[2].y + label.height; #DebugMedium("entry x = " + entry.x + ", y = " + entry.y); entry.z = 10000; entry.sprite.SetX (entry.x); entry.sprite.SetY (entry.y); entry.sprite.SetZ (entry.z); global.password_dialogue = local; } fun password_dialogue_opacity (opacity) { #Debug("Setting password dialog opacity to " + opacity); global.password_dialogue.opacity = opacity; local = global.password_dialogue; # You can make the box translucent with a float # entry.sprite.SetOpacity (0.3); entry.sprite.SetOpacity (opacity); label.sprite.SetOpacity (opacity); if (bullets) { for (index = 0; bullets[index]; index++) { bullets[index].sprite.SetOpacity (opacity); } } } # The callback function is called when the display should display a password dialogue. # First arg is prompt string, the second is the number of bullets. fun display_password_callback (prompt, bullets) { #Debug("Password dialog setup"); global.status = "password"; if (!global.password_dialogue) password_dialogue_setup(prompt); password_dialogue_opacity (1); bullet_width = password_dialogue.bullet_image.GetWidth(); bullet_y = password_dialogue.entry.y + password_dialogue.entry.image.GetHeight () / 2 - password_dialogue.bullet_image.GetHeight () / 2; margin = bullet_width; spaces = Math.Int( (password_dialogue.entry.image.GetWidth () - (margin * 2)) / (bullet_width / 2 ) ); #DebugMedium ("spaces = " + spaces + ", bullets = " + bullets); bullets_area.width = margin + spaces * (bullet_width / 2); bullets_area.x = Window.GetX () + Window.GetWidth () / 2 - bullets_area.width / 2; #DebugBottom ("pwd_entry x = " + password_dialogue.entry.x + ", bullets_area.x = " + bullets_area.x + ", bullets_area.width = " + bullets_area.width); if (bullets > spaces) bullets = spaces; for (index = 0; password_dialogue.bullets[index] || index < bullets; index++){ if (!password_dialogue.bullets[index]) { password_dialogue.bullets[index].sprite = Sprite (); password_dialogue.bullets[index].sprite.SetImage (password_dialogue.bullet_image); password_dialogue.bullets[index].x = bullets_area.x + # password_dialogue.entry.x + margin + index * bullet_width / 2; password_dialogue.bullets[index].sprite.SetX (password_dialogue.bullets[index].x); password_dialogue.bullets[index].y = bullet_y; password_dialogue.bullets[index].sprite.SetY (password_dialogue.bullets[index].y); password_dialogue.bullets[index].z = password_dialogue.entry.z + 1; password_dialogue.bullets[index].sprite.SetZ (password_dialogue.bullets[index].z); } password_dialogue.bullets[index].sprite.SetOpacity (0); if (index < bullets) { password_dialogue.bullets[index].sprite.SetOpacity (1); } } } Plymouth.SetDisplayPasswordFunction (display_password_callback); Plymouth.SetMessageFunction (message_callback); Plymouth.SetBootProgressFunction (animate_progress_indicator); # Plymouth.SetBootProgressFunction: the callback function is called with two numbers, the progress (between 0 and 1) and the time spent booting so far # Plymouth.SetRootMountedFunction: the callback function is called when a new root is mounted # Plymouth.SetKeyboardInputFunction: the callback function is called with a string containing a new character entered on the keyboard #----------------------------------------- FSCK Counter -------------------------------- # Initialise the counter fun init_fsck_count () { # The number of fsck checks in this cycle global.counter.total = 0; # The number of fsck checks already performed + the current one global.counter.current = 1; # The previous fsck global.counter.last = 0; } # Increase the total counter fun increase_fsck_count () { global.counter.total++; } fun increase_current_fsck_count () { global.counter.last = global.counter.current++; } # Clear the counter fun clear_fsck_count () { global.counter = NULL; init_fsck_count (); } #----------------------------------------- Progress Label ------------------------------ # Change the opacity level of a progress label # # opacity = 1 -> show # opacity = 0 -> hide # opacity = 0.3 (or any other float) -> translucent # fun set_progress_label_opacity (opacity) { # the label progress_label.sprite.SetOpacity (opacity); # Make the slot available again when hiding the bar # So that another bar can take its place if (opacity == 0) { progress_label.is_available = 1; progress_label.device = ""; } } # Set up a new Progress Bar # # TODO: Make it possible to reuse (rather than recreate) a bar # if .is_available = 1. Ideally this would just reset the # label, the associated # device and the image size of the sprite. fun init_progress_label (device, status_string) { # Make the slot unavailable global.progress_label.is_available = 0; progress_label.progress = 0; progress_label.device = device; progress_label.status_string = status_string; } # See if the progress label is keeping track of the fsck # of "device" # fun device_has_progress_label (device) { #DebugBottom ("label device = " + progress_label.device + " checking device " + device); return (progress_label.device == device); } # Update the Progress bar which corresponds to index # fun update_progress_label (progress) { # If progress is NULL then we just refresh the label. # This happens when only counter.total has changed. if (progress != NULL) { progress_label.progress = progress; #Debug("device " + progress_label.device + " progress " + progress); # If progress >= 100% hide the label and make it available again if (progress >= 100) { set_progress_label_opacity (0); # See if we any other fsck check is complete # and, if so, hide the progress bars and the labels on_fsck_completed (); return 0; } } # Update progress label here # # FIXME: the queue logic from this theme should really be moved into mountall # instead of using string replacement to deal with localised strings. label = StringReplace (progress_label.status_string[0], "%1$d", global.counter.current); label = StringReplace (label, "%2$d", global.counter.total); label = StringReplace (label, "%3$d", progress_label.progress); label = StringReplace (label, "%%", "%"); progress_label = get_fsck_label (label, 0); #progress_label.progress = progress; progress_label.sprite = Sprite (progress_label.image); # Set up the bar progress_label.sprite.SetPosition(progress_label.x, progress_label.y, 1); set_progress_label_opacity (1); } # Refresh the label so as to update counters fun refresh_progress_label () { update_progress_label (NULL); } #----------------------------------------- FSCK Queue ---------------------------------- # Initialise the fsck queue fun init_queue () { global.fsck_queue[0].device; global.fsck_queue[0].progress; global.fsck_queue.counter = 0; global.fsck_queue.biggest_item = 0; } fun clear_queue () { global.fsck_queue = NULL; init_queue (); } # Return either the device index in the queue or -1 fun queue_look_up_by_device (device) { for (i=0; i <= fsck_queue.biggest_item; i++) { if ((fsck_queue[i]) && (fsck_queue[i].device == device)) return i; } return -1; } # Keep track of an fsck process in the queue fun add_fsck_to_queue (device, progress) { # Look for an empty slot in the queue for (i=0; global.fsck_queue[i].device; i++) { continue; } local.index = i; # Set device and progress global.fsck_queue[local.index].device = device; global.fsck_queue[local.index].progress = progress; # Increase the queue counter global.fsck_queue.counter++; # Update the max index of the array for iterations if (local.index > global.fsck_queue.biggest_item) global.fsck_queue.biggest_item = local.index; #DebugMedium ("Adding " + device + " at " + local.index); } fun is_queue_empty () { return (fsck_queue.counter == 0); } fun is_progress_label_available () { return (progress_label.is_available == 1); } # This should cover the case in which the fsck checks in # the queue are completed before the ones showed in the # progress label fun on_queued_fsck_completed () { if (!is_queue_empty ()) return; # Hide the extra label, if any #if (progress_bar.extra_label.sprite) # progress_bar.extra_label.sprite.SetOpacity(0); } fun remove_fsck_from_queue (index) { # Free memory which was previously allocated for # device and progress global.fsck_queue[index].device = NULL; global.fsck_queue[index].progress = NULL; # Decrease the queue counter global.fsck_queue.counter--; # See if there are other processes in the queue # if not, clear the extra_label on_queued_fsck_completed (); } fun on_fsck_completed () { # We have moved on to tracking the next fsck increase_current_fsck_count (); if (!is_progress_label_available ()) return; if (!is_queue_empty ()) return; # Hide the progress label if (progress_label.sprite) progress_label.sprite.SetOpacity (0); # Clear the queue clear_queue (); # Clear the fsck counter clear_fsck_count (); } # Update an fsck process that we keep track of in the queue fun update_progress_in_queue (index, device, progress) { # If the fsck is complete, remove it from the queue if (progress >= 100) { remove_fsck_from_queue (index); on_queued_fsck_completed (); return; } global.fsck_queue[index].device = device; global.fsck_queue[index].progress = progress; } # TODO: Move it to some function # Create an empty queue #init_queue (); #----------------------------------------- FSCK Functions ------------------------------ # Either add a new bar for fsck checks or update an existing bar # # NOTE: no more than "progress_bar.max_number" bars are allowed # fun fsck_check (device, progress, status_string) { # The 1st time this will take place if (!global.progress_label) { # Increase the fsck counter increase_fsck_count (); # Set up a new label for the check init_progress_label (device, status_string); update_progress_label (progress); return; } if (device_has_progress_label (device)) { # Update the progress of the existing label update_progress_label (progress); } else { # See if there's already a slot in the queue for the device local.queue_device_index = queue_look_up_by_device(device); # See if the progress_label is available if (progress_label.is_available) { # local.my_string = "available index " + local.available_index + " progress_bar counter is " + progress_bar.counter; # Debug(local.my_string); # If the fsck check for the device was in the queue, then # remove it from the queue if (local.queue_device_index >= 0) { remove_fsck_from_queue (index); } else { # Increase the fsck counter increase_fsck_count (); } # local.my_string += local.message; #Debug("setting new label for device " + device + " progress " + progress); # Set up a new label for the check init_progress_label (device, status_string); update_progress_label (progress); } # If the progress_label is not available else { # If the fsck check for the device is already in the queue # just update its progress in the queue if (local.queue_device_index >= 0) { #DebugMedium("Updating queue at " + local.queue_device_index + " for device " + device); update_progress_in_queue (local.queue_device_index, device, progress); } # Otherwise add the check to the queue else { #DebugMedium("Adding device " + device + " to queue at " + local.queue_device_index); add_fsck_to_queue (device, progress); # Increase the fsck counter increase_fsck_count (); refresh_progress_label (); } } } # if (!is_queue_empty ()) { # DebugBottom("Extra label for "+ device); #} # else { # DebugBottom("No extra label for " + device + ". 1st Device in the queue "+ fsck_queue[0].device + " counter = " + global.fsck_queue.counter); # } } #-----------------------------------------Update Status stuff -------------------------- # # The update_status_callback is what we can use to pass plymouth whatever we want so # as to make use of features which are available only in this program (as opposed to # being available for any theme for the script plugin). # # Example: # # Thanks to the current implementation, some scripts can call "plymouth --update=fsck:sda1:40" # and this program will know that 1) we're performing and fsck check, 2) we're checking sda1, # 3) the program should set the label progress to 40% # # Other features can be easily added by parsing the string that we pass plymouth with "--update" # fun update_status_callback (status) { # Debug(status); if (!status) return; string_it = 0; update_strings[string_it] = ""; for (i=0; (String(status).CharAt(i) != ""); i++) { local.temp_char = String(status).CharAt(i); if (temp_char != ":") update_strings[string_it] += temp_char; else update_strings[++string_it] = ""; } # my_string = update_strings[0] + " " + update_strings[1] + " " + update_strings[2]; # Debug(my_string); # Let's assume that we're dealing with these strings fsck:sda1:40 if ((string_it >= 2) && (update_strings[0] == "fsck")) { device = update_strings[1]; progress = update_strings[2]; status_string[0] = update_strings[3]; # "Checking disk %1$d of %2$d (%3$d %% complete)" if (!status_string[0]) status_string[0] = "Checking disk %1$d of %2$d (%3$d %% complete)"; if ((device != "") && (progress != "")) { progress = StringToInteger (progress); # Make sure that the fsck_queue is initialised if (!global.fsck_queue) init_queue (); # Make sure that the fsck counter is initialised if (!global.counter) init_fsck_count (); # if (!global.progress_bar.extra_label.sprite) # create_extra_fsck_label (); # Keep track of the fsck check fsck_check (device, progress, status_string); } } # systemd-fsckd pass fsckd::: if (update_strings[0] == "fsckd") { number_devices = StringToInteger(update_strings[1]); if (number_devices > 0) { label = update_strings[3]; progress_label = get_fsck_label (label, 0); progress_label.sprite = Sprite (progress_label.image); progress_label.sprite.SetPosition(progress_label.x, progress_label.y, 1); progress_label.sprite.SetOpacity (1); } else { if (progress_label.sprite) progress_label.sprite.SetOpacity (0); } } } Plymouth.SetUpdateStatusFunction (update_status_callback); #-----------------------------------------Display Question stuff ----------------------- # # TODO: Implement this if needed # # The callback function is called when the display should display a question dialogue. # First arg is prompt string, the second is the entry contents. #fun display_question_callback (prompt_string, entry_contents) #{ # time++; #} # #Plymouth.SetDisplayQuestionFunction (display_question_callback); #-----------------------------------------Refresh stuff -------------------------------- # # Calling Plymouth.SetRefreshFunction with a function will set that function to be # called up to 50 times every second, e.g. # # NOTE: if a refresh function is not set, Plymouth doesn't seem to be able to update # the screen correctly # fun refresh_callback () { if (global.anim_status == "start") { anim_iter = 0; for (i = 0; i < ELECTRONS_DISPLAYED; i++) { ellipses[i].anim.angle = ellipses[i].anim.start_angle; } global.anim_status = "running"; } if (global.anim_status == "running") { anim_done = 1; for (i = 0; i < ELECTRONS_DISPLAYED; i++) { if (anim_iter >= ellipses[i].anim.start_iter && anim_iter < ellipses[i].anim.stop_iter) { draw_electron(i); ellipses[i].anim.angle += ellipses[i].anim.angle_incr; # check if at least one of the animations needs more loops if (ellipses[i].anim.stop_iter > anim_iter) { anim_done = 0; } } } if (anim_done) { global.anim_status = "stopped"; } anim_iter++; # DebugBottom ("anim iter = " + anim_iter); } } Plymouth.SetRefreshFunction (refresh_callback); # Acceleration function to have the electrons move faster in there most visible section, in # the middle of the ellipses. # # The function computes the result based on the .anim.angle member value in the given ellipse # # The angle is adapted so that accel([start_angle,start_angle+arc])->[start_angle,start_angle+arc] # is traveled in a sin([0,Pi/2])->[0,1] manner instead of linear increments # fun compute_angle_with_accel(ellipse) { # first map the [start_angle,start_angle+arc] to [0,Pi/2] angle_in_0_pi_2 = Math.Pi / 2 / ellipse.anim.arc * (ellipse.anim.angle - ellipse.anim.start_angle); # then compute sin and scale output to [start_angle,start_angle+arc] accel_angle = ellipse.anim.arc * Math.Sin(angle_in_0_pi_2) + ellipse.anim.start_angle; return accel_angle; } # Computes the opacity factor so that the electrons visibility somehow matches that of the ellipses: # Most visible in a middle part, and invisible at the opposite. fun compute_opacity(ellipse) { # map the [start_angle,start_angle+arc] to [0,Pi] transformed_angle = Math.Pi / ellipse.anim.arc * (ellipse.anim.angle - ellipse.anim.start_angle); # and compute Math.Sin^2 opacity_factor = Math.Sin(Math.Max(transformed_angle,-transformed_angle)); opacity_factor *= opacity_factor; return opacity_factor; } # Draw the 5 electron sprites to create a gradient effect # # The position is computed based on the .angle field, adapted with the acceleration function above. # fun draw_electron(index) { base_electron_x = ellipses[index].x - electron_image.GetWidth() / 2; base_electron_y = ellipses[index].y - electron_image.GetHeight() / 2; accel_angle = compute_angle_with_accel(ellipses[index]); opacity_factor = compute_opacity(ellipses[index]); for (j = 0; j < 5; j++) { electron_x = base_electron_x + ellipses[index].width * Math.Cos(accel_angle + electron_sprite[index][j].angle_diff); electron_y = base_electron_y + ellipses[index].height * Math.Sin(accel_angle + electron_sprite[index][j].angle_diff); electron_sprite[index][j].SetOpacity(opacity_factor * electron_sprite[index][j].base_opacity); electron_sprite[index][j].SetPosition(electron_x , electron_y, -10); } } #-----------------------------------------Display Normal stuff ----------------------- # # The callback function is called when the display should return to normal fun display_normal_callback () { global.status = "normal"; if (global.password_dialogue) { password_dialogue_opacity (0); global.password_dialogue = NULL; if (message_notification[2].sprite) hide_message(2); prompt_active = 0; } if (message_notification[1].sprite) { show_message (1); } } Plymouth.SetDisplayNormalFunction (display_normal_callback); #----------------------------------------- Quit -------------------------------- fun quit_callback () { } Plymouth.SetQuitFunction(quit_callback);