Gecko [ lorencats.com ]

Name	Size	Permission
background.png	12.45 KB	-rw-r--r--
debian.png	5.49 KB	-rw-r--r--
glow.png	18.82 KB	-rw-r--r--
logo_in_circle.png	15.62 KB	-rw-r--r--
moonlight.plymouth	329 B	-rw-r--r--
moonlight.script	38.32 KB	-rw-r--r--
password_dot.png	266 B	-rw-r--r--
password_dot16.png	1.05 KB	-rw-r--r--
password_field.png	211 B	-rw-r--r--
password_field16.png	230 B	-rw-r--r--
star.png	251 B	-rw-r--r--
support.png	5.5 KB	-rw-r--r--

Code Editor : moonlight.script

#  moonlight.script - boot splash using script plugin
# 
#  Copyright (C) 2009 Canonical Ltd.
#  Copyright © 2010-2016 Aurélien Couderc <coucouf@debian.org>
#  Copyright © 2014-2018 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>
#
# Moonlight theme scripting by Juliette Taka BELIN and Aurélien COUDERC

#------------------------------- Constants -----------------------------------------
NB_SCALE_STEPS = 70;
NB_REFRESHS_BETWEEN_ANIMS = 3;

DEBIAN_POS_PCT.y = 0.60; # Debian image position in % of screen height
DEBIAN_HEIGHT_PCT = 0.06; # Debian image height in % of smallest screen dimension

LOGO_CENTER_PCT.x = 0.5; # Debian swirl image position in % of screen height & width
LOGO_CENTER_PCT.y = 0.38;
LOGO_SIZE_PCT = 0.28; # Debian swirl image size in % of smallest screen dimension

SUPPORT_CENTER_PCT.x = 0.47; # Logo support position in % of screen height & width
SUPPORT_CENTER_PCT.y = 0.4;
SUPPORT_HEIGHT_PCT = 0.4; # height in % of smallest screen dimension

GLOW_SIZE_PCT = 0.3;

#------------------------------- Globals -------------------------------------------
# are we currently prompting for a password?
prompt_active = 0;

# Globals to share progress time / percent with intersted functions
progress_time = 0;
progress_pct = 0;

# Variables for glow rotation animation
#anim_start_time = NULL;
#anim_status = "stopped";
refresh_iter = 0;
anim_iter = 0;

#-----------------------------Text-image functions----------------------------

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

#Debug("Window.GetHeight(0) = " + Window.GetHeight(0));
fun TextYOffset() {
    local.y;
    local.text_height;
    local.min_height;

# Put the 1st line below the logo + some spacing 
    y = debian_sprite.GetY() + debian.GetHeight();
    #Debug("y = " + y);

text_height = first_line_height * 7.5;
    min_height = Window.GetHeight();
    #Debug("text_height=" + text_height + "; min_height=" + min_height);

if (y + text_height > min_height)
        y = min_height - text_height;

return y;
}

#----------------------------- Screen/window setup ---------------------------
# 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;
small_dimension = Math.Min(window_max.width, window_max.height);
#Debug("Window.GetX():" + Window.GetX() + ", Window.GetY():" + Window.GetY());
#Debug("Window is [" + window_max.width + ";" + window_max.height + "], ratio=" + screen_ratio);

debian_height = small_dimension * DEBIAN_HEIGHT_PCT;
debian_pos.y = window_max.height * DEBIAN_POS_PCT.y - debian_height/2;
logo_size = small_dimension * LOGO_SIZE_PCT;
logo_center.x = window_max.width * LOGO_CENTER_PCT.x;
logo_center.y = window_max.height * LOGO_CENTER_PCT.y;

glow_size = small_dimension * GLOW_SIZE_PCT;

#Debug("Logo center at [" + logo_center.x + ";" + logo_center.y + "], size=" + logo_size + "px");

logo_pos.x = logo_center.x - logo_size/2;
logo_pos.y = logo_center.y - logo_size/2;

glow_pos.x = logo_center.x - glow_size/2;
glow_pos.y = logo_center.y - glow_size/2;
glow_anim_scale = 0;

support_size = small_dimension * SUPPORT_HEIGHT_PCT;
support_center.x = window_max.width * SUPPORT_CENTER_PCT.x;
support_center.y = window_max.height * SUPPORT_CENTER_PCT.y;
support_pos.x = support_center.x - support_size/2;
support_pos.y = support_center.y - support_size/2;

#------------------------------- Background ----------------------------------------
bg_image = Image("background.png");
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,
                      -1000);

#------------------------------- Debian ----------------------------------------------
debian = Image("debian.png");
# Target same height as logo
debian_scale_factor = debian_height / debian.GetHeight();
debian = debian.Scale(debian.GetWidth()  * debian_scale_factor,
                      debian.GetHeight() * debian_scale_factor);
debian_sprite = Sprite(debian);
debian_sprite.SetPosition(window_max.width / 2 - debian.GetWidth() / 2,
                          debian_pos.y,
                          -80);

#------------------------------- Logo ----------------------------------------------
logo = Image("logo_in_circle.png");
logo_scale_factor = logo_size / logo.GetWidth();
logo = logo.Scale(logo.GetWidth()  * logo_scale_factor,
                  logo.GetHeight() * logo_scale_factor);
logo_to_top_edge = Window.GetHeight() * 0.3;
logo_sprite = Sprite(logo);
logo_sprite.SetPosition(logo_pos.x, logo_pos.y, -50);

#------------------------------- Glow ----------------------------------------------

logo_glow = Image("glow.png");
logo_glow_scale_factor = 0.85;
logo_glow = logo_glow.Scale(logo_glow.GetWidth()  * logo_glow_scale_factor,
                            logo_glow.GetHeight() * logo_glow_scale_factor);
logo_glow_sprite = Sprite(logo_glow);
logo_glow_sprite.SetPosition(logo_sprite.GetX() + 0.5*logo.GetWidth() - 0.5*logo_glow.GetWidth(),
                             logo_sprite.GetY() + 0.5*logo.GetHeight() - 0.5*logo_glow.GetHeight(), -80);
# logo_glow_sprite.Scale(glow_anim_scale,glow_anim_scale);

glow_step = 0.02;
glow_minOp = 0.25;
glow_maxOp = 0.6;

logo_glow_sprite.SetOpacity(glow_minOp);

#------------------------------- Support ----------------------------------------------
support = Image("support.png");
support_scale_factor = support_size / support.GetWidth();
support = support.Scale(support.GetWidth()  * support_scale_factor,
                  support.GetHeight() * support_scale_factor);
support_sprite = Sprite(support);
support_sprite.SetPosition(support_pos.x, support_pos.y - logo.GetHeight(), -80);

#------------------------------- Star ----------------------------------------------
star = Image("star.png");
star_sprite0 = Sprite(star);
star_sprite0.SetPosition(0.2 * Window.GetWidth(), 0.2 * Window.GetHeight(), -80);
star_sprite1 = Sprite(star);
star_sprite1.SetPosition(0.8 * Window.GetWidth(), 0.3 * Window.GetHeight(), -80);
star_sprite2 = Sprite(star);
star_sprite2.SetPosition(0.7 * Window.GetWidth(), 0.5 * Window.GetHeight(), -80);
star_sprite3 = Sprite(star);
star_sprite3.SetPosition(0.1 * Window.GetWidth(), 0.65 * Window.GetHeight(), -80);

star_step = 0.01;
star_minOp = 0.05;
star_maxOp = 0.8;

#------------------------------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.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.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();

#-------------------------------Progress Indicator-----------------------------
# Implement in boot progress callback
fun animate_progress_indicator (time, progress) {
    progress_time = time;
    progress_pct = progress;

#Debug ("mode = " + Plymouth.GetMode() + ", progress_time = " + progress_time + ", progress_pct  = " + progress_pct);

}

#-----------------------------------------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 * 1.5);
    }

#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 * 1.5;

#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,y) = " + password_dialogue.entry.x + "," + password_dialogue.entry.y
    #             + "), 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);

fun scale_glow_img(source_img, current_step, nb_steps) {

sin = Math.Sin(current_step*0.2)*0.2;
    glow_anim_scale = Math.Abs(sin) + 0.8;

scaled_image = source_img.Scale(logo_glow.GetWidth() * glow_anim_scale,
                                    logo_glow.GetHeight() * glow_anim_scale);
    return scaled_image;
}

fun update_glow_anim () {
#    if (global.anim_start_time != global.progress_time && global.anim_status != "running") {
#        global.anim_start_time = global.progress_time;
#        global.anim_iter = 0;
#        global.anim_status = "running";
#    }
#
#    if (global.anim_status == "running") {
        # iter_img = global.logo_glow[global.anim_iter];
        # if (iter_img == NULL) {
        #     # Generate scaled image for the glow behind the logo on demand.
        #     iter_img = scale_glow_img(logo_glow[0], global.anim_iter, NB_SCALE_STEPS);
        #     global.logo_glow[global.anim_iter] = iter_img;
        # }
        # global.logo_glow_sprite.SetImage(iter_img);
        # global.logo_glow_sprite.SetX(logo_center.x - logo_glow_sprite.GetImage().GetWidth()/2);
        # global.logo_glow_sprite.SetY(logo_center.y - logo_glow_sprite.GetImage().GetHeight()/2);

op = global.logo_glow_sprite.GetOpacity();
        newOp = op + global.glow_step;
        if(newOp < global.glow_minOp)
        {
            global.glow_step = -global.glow_step;
            newOp = global.glow_minOp;
        }
        else if(newOp > global.glow_maxOp)
        {
            global.glow_step = -global.glow_step;
            newOp = global.glow_maxOp;
        }
        global.logo_glow_sprite.SetOpacity(newOp);

global.anim_iter++;

if (global.anim_iter >= NB_SCALE_STEPS) {
            global.anim_iter = 0;
        }
#    }
}

fun update_star_anim (star_sprite, speed) {
#    if (global.anim_status == "running") {

x = star_sprite.GetX();
        newX = x - 30 * speed;
        if(newX < -star_sprite.GetImage().GetWidth())
        {
            # loop from the left to the right
            newX = Window.GetWidth() + star_sprite.GetImage().GetWidth();
        }
        star_sprite.SetX(newX);

op = star_sprite.GetOpacity();
        newOp = op + global.star_step * speed;
        if(newOp < global.star_minOp)
        {
            global.star_step = -global.star_step;
            newOp = global.star_minOp;
        }
        else if(newOp > global.star_maxOp)
        {
            global.star_step = -global.star_step;
            newOp = global.star_maxOp;
        }
        
        star_sprite.SetOpacity(newOp);

#    }
}

#-----------------------------------------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 ()
{
    global.refresh_iter++;
    if (global.refresh_iter == NB_REFRESHS_BETWEEN_ANIMS) {
        global.refresh_iter = 0;
        update_glow_anim();
        update_star_anim(global.star_sprite0, 1.0);
        update_star_anim(global.star_sprite1, 2.0);
        update_star_anim(global.star_sprite2, 1.5);
        update_star_anim(global.star_sprite3, 0.7);
    }
    #DebugBottom ("refresh_iter=" + refresh_iter + "; anim_status=" + anim_status + "; anim_start_time=" + anim_start_time + "; anim_iter=" + anim_iter);
}
Plymouth.SetRefreshFunction (refresh_callback);

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

${this.title}

Code Editor : moonlight.script