Peppermint
/
bubbles
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
bubbles/iso_configs/plymouth/lines/lines.script

1138 lines
38 KiB
Plaintext
Raw Normal View History

Updated
2023-07-11 06:48:53 +00:00
# lines.script - boot splash using script plugin
#
# Copyright (C) 2009 Canonical Ltd.
# Copyright © 2010-2014 Aurélien Couderc <coucouf@debian.org>
# Copyright © 2014 Juliette Taka <juliette.belin@logilab.fr>
#
# 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 <alberto.milone@canonical.com>
#
# Based on the example provided with the "script plugin" written by:
# Charlie Brej <cbrej@cs.man.ac.uk>
#
#------------------------------- 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:<number_devices>:<progress>:<l10n_string>
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);