~ubuntu-branches/ubuntu/vivid/ubuntukylin-theme/vivid-proposed

#DebugBottom ("pwd_entry x = " + password_dialogue.entry.x + ", bullets_area.x = " + bullets_area.x + ", bullets_area.width = " + bullets_area.width);

567

if (bullets > spaces)

568

bullets = spaces;

569

for (index = 0; password_dialogue.bullets[index] || index < bullets; index++){

570

if (!password_dialogue.bullets[index]) {

571

password_dialogue.bullets[index].sprite = Sprite ();

572

password_dialogue.bullets[index].sprite.SetImage (password_dialogue.bullet_image);

573

password_dialogue.bullets[index].x = bullets_area.x + # password_dialogue.entry.x + margin +

574

index * bullet_width / 2;

575

password_dialogue.bullets[index].sprite.SetX (password_dialogue.bullets[index].x);

576

password_dialogue.bullets[index].y = bullet_y;

577

password_dialogue.bullets[index].sprite.SetY (password_dialogue.bullets[index].y);

578

password_dialogue.bullets[index].z = password_dialogue.entry.z + 1;

579

password_dialogue.bullets[index].sprite.SetZ (password_dialogue.bullets[index].z);

580

}

581

582

password_dialogue.bullets[index].sprite.SetOpacity (0);

583

584

if (index < bullets) {

585

password_dialogue.bullets[index].sprite.SetOpacity (1);

586

}

587

}

588

}

589

590

Plymouth.SetDisplayPasswordFunction (display_password_callback);

591

592

Plymouth.SetMessageFunction (message_callback);

593

594

Plymouth.SetBootProgressFunction (animate_progress_indicator);

595

596

# Plymouth.SetBootProgressFunction: the callback function is called with two numbers, the progress (between 0 and 1) and the time spent booting so far

597

# Plymouth.SetRootMountedFunction: the callback function is called when a new root is mounted

598

# Plymouth.SetKeyboardInputFunction: the callback function is called with a string containing a new character entered on the keyboard

599

600

#----------------------------------------- FSCK Counter --------------------------------

601

602

# Initialise the counter

603

fun init_fsck_count () {

604

# The number of fsck checks in this cycle

605

global.counter.total = 0;

606

# The number of fsck checks already performed + the current one

607

global.counter.current = 1;

608

# The previous fsck

609

global.counter.last = 0;

610

}

611

612

# Increase the total counter

613

fun increase_fsck_count () {

614

global.counter.total++;

615

}

616

617

fun increase_current_fsck_count () {

618

global.counter.last = global.counter.current++;

619

}

620

621

# Clear the counter

622

fun clear_fsck_count () {

623

global.counter = NULL;

624

init_fsck_count ();

625

}

626

627

#----------------------------------------- Progress Label ------------------------------

628

629

630

# Change the opacity level of a progress label

631

632

# opacity = 1 -> show

633

# opacity = 0 -> hide

634

# opacity = 0.3 (or any other float) -> translucent

635

636

fun set_progress_label_opacity (opacity) {

637

# the label

638

progress_label.sprite.SetOpacity (opacity);

639

640

# Make the slot available again when hiding the bar

641

# So that another bar can take its place

642

if (opacity == 0) {

643

progress_label.is_available = 1;

644

progress_label.device = "";

645

}

646

}

647

648

# Set up a new Progress Bar

649

650

# TODO: Make it possible to reuse (rather than recreate) a bar

651

# if .is_available = 1. Ideally this would just reset the

652

# label, the associated

653

# device and the image size of the sprite.

654

655

fun init_progress_label (device, status_string) {

656

# Make the slot unavailable

657

global.progress_label.is_available = 0;

658

progress_label.progress = 0;

659

progress_label.device = device;

660

progress_label.status_string = status_string;

661

}

662

663

# See if the progress label is keeping track of the fsck

664

# of "device"

665

666

fun device_has_progress_label (device) {

667

#DebugBottom ("label device = " + progress_label.device + " checking device " + device);

668

return (progress_label.device == device);

669

}

670

671

# Update the Progress bar which corresponds to index

672

673

fun update_progress_label (progress) {

674

# If progress is NULL then we just refresh the label.

675

# This happens when only counter.total has changed.

676

if (progress != NULL) {

677

progress_label.progress = progress;

678

679

#Debug("device " + progress_label.device + " progress " + progress);

680

681

# If progress >= 100% hide the label and make it available again

682

if (progress >= 100) {

683

set_progress_label_opacity (0);

684

685

# See if we any other fsck check is complete

686

# and, if so, hide the progress bars and the labels

687

on_fsck_completed ();

688

689

return 0;

690

}

691

}

692

# Update progress label here

693

694

# FIXME: the queue logic from this theme should really be moved into mountall

695

# instead of using string replacement to deal with localised strings.

696

label = StringReplace (progress_label.status_string[0], "%1$d", global.counter.current);

697

label = StringReplace (label, "%2$d", global.counter.total);

698

label = StringReplace (label, "%3$d", progress_label.progress);

699

label = StringReplace (label, "%%", "%");

700

701

progress_label = get_fsck_label (label, 0);

702

#progress_label.progress = progress;

703

704

progress_label.sprite = Sprite (progress_label.image);

705

706

# Set up the bar

707

progress_label.sprite.SetPosition(progress_label.x, progress_label.y, 1);

708

709

set_progress_label_opacity (1);

710

711

}

712

713

# Refresh the label so as to update counters

714

fun refresh_progress_label () {

715

update_progress_label (NULL);

716

}

717

718

#----------------------------------------- FSCK Queue ----------------------------------

719

720

# Initialise the fsck queue

721

fun init_queue () {

722

global.fsck_queue[0].device;

723

global.fsck_queue[0].progress;

724

global.fsck_queue.counter = 0;

725

global.fsck_queue.biggest_item = 0;

726

}

727

728

fun clear_queue () {

729

global.fsck_queue = NULL;

730

init_queue ();

731

}

732

733

# Return either the device index in the queue or -1

734

fun queue_look_up_by_device (device) {

735

for (i=0; i <= fsck_queue.biggest_item; i++) {

736

if ((fsck_queue[i]) && (fsck_queue[i].device == device))

737

return i;

738

}

739

return -1;

740

}

741

742

# Keep track of an fsck process in the queue

743

fun add_fsck_to_queue (device, progress) {

744

# Look for an empty slot in the queue

745

for (i=0; global.fsck_queue[i].device; i++) {

746

continue;

747

}

748

local.index = i;

749

750

# Set device and progress

751

global.fsck_queue[local.index].device = device;

752

global.fsck_queue[local.index].progress = progress;

753

754

# Increase the queue counter

755

global.fsck_queue.counter++;

756

757

# Update the max index of the array for iterations

758

if (local.index > global.fsck_queue.biggest_item)

759

global.fsck_queue.biggest_item = local.index;

760

761

#DebugMedium ("Adding " + device + " at " + local.index);

762

}

763

764

fun is_queue_empty () {

765

return (fsck_queue.counter == 0);

766

}

767

768

fun is_progress_label_available () {

769

return (progress_label.is_available == 1);

770

}

771

772

773

# This should cover the case in which the fsck checks in

774

# the queue are completed before the ones showed in the

775

# progress label

776

fun on_queued_fsck_completed () {

777

if (!is_queue_empty ())

778

return;

779

780

# Hide the extra label, if any

781

#if (progress_bar.extra_label.sprite)

782

# progress_bar.extra_label.sprite.SetOpacity(0);

783

}

784

785

fun remove_fsck_from_queue (index) {

786

# Free memory which was previously allocated for

787

# device and progress

788

global.fsck_queue[index].device = NULL;

789

global.fsck_queue[index].progress = NULL;

790

791

# Decrease the queue counter

792

global.fsck_queue.counter--;

793

794

# See if there are other processes in the queue

795

# if not, clear the extra_label

796

on_queued_fsck_completed ();

797

}

798

799

fun on_fsck_completed () {

800

# We have moved on to tracking the next fsck

801

increase_current_fsck_count ();

802

803

if (!is_progress_label_available ())

804

return;

805

806

if (!is_queue_empty ())

807

return;

808

809

# Hide the progress label

810

if (progress_label.sprite)

811

progress_label.sprite.SetOpacity (0);

812

813

# Clear the queue

814

clear_queue ();

815

816

# Clear the fsck counter

817

clear_fsck_count ();

818

}

819

820

# Update an fsck process that we keep track of in the queue

821

fun update_progress_in_queue (index, device, progress) {

822

# If the fsck is complete, remove it from the queue

823

if (progress >= 100) {

824

remove_fsck_from_queue (index);

825

on_queued_fsck_completed ();

826

return;

827

}

828

829

global.fsck_queue[index].device = device;

830

global.fsck_queue[index].progress = progress;

831

832

}

833

834

# TODO: Move it to some function

835

# Create an empty queue

836

#init_queue ();

837

838

839

#----------------------------------------- FSCK Functions ------------------------------

840

841

842

# Either add a new bar for fsck checks or update an existing bar

843

844

# NOTE: no more than "progress_bar.max_number" bars are allowed

845

846

fun fsck_check (device, progress, status_string) {

847

848

# The 1st time this will take place

849

if (!global.progress_label) {

850

# Increase the fsck counter

851

increase_fsck_count ();

852

853

# Set up a new label for the check

854

init_progress_label (device, status_string);

855

update_progress_label (progress);

856

857

return;

858

}

859

860

861

if (device_has_progress_label (device)) {

862

# Update the progress of the existing label

863

update_progress_label (progress);

864

}

865

else {

866

# See if there's already a slot in the queue for the device

867

local.queue_device_index = queue_look_up_by_device(device);

868

869

# See if the progress_label is available

870

if (progress_label.is_available) {

871

872

# local.my_string = "available index " + local.available_index + " progress_bar counter is " + progress_bar.counter;

873

# Debug(local.my_string);

874

875

876

# If the fsck check for the device was in the queue, then

877

# remove it from the queue

878

if (local.queue_device_index >= 0) {

879

remove_fsck_from_queue (index);

880

}

881

else {

882

# Increase the fsck counter

883

increase_fsck_count ();

884

}

885

886

# local.my_string += local.message;

887

#Debug("setting new label for device " + device + " progress " + progress);

888

889

# Set up a new label for the check

890

init_progress_label (device, status_string);

891

update_progress_label (progress);

892

893

}

894

# If the progress_label is not available

895

else {

896

897

# If the fsck check for the device is already in the queue

898

# just update its progress in the queue

899

if (local.queue_device_index >= 0) {

900

#DebugMedium("Updating queue at " + local.queue_device_index + " for device " + device);

901

update_progress_in_queue (local.queue_device_index, device, progress);

902

}

903

# Otherwise add the check to the queue

904

else {

905

#DebugMedium("Adding device " + device + " to queue at " + local.queue_device_index);

906

add_fsck_to_queue (device, progress);

907

908

# Increase the fsck counter

909

increase_fsck_count ();

910

911

refresh_progress_label ();

912

}

913

914

}

915

}

916

917

# if (!is_queue_empty ()) {

918

# DebugBottom("Extra label for "+ device);

919

920

# else {

921

# DebugBottom("No extra label for " + device + ". 1st Device in the queue "+ fsck_queue[0].device + " counter = " + global.fsck_queue.counter);

922

# }

923

}

924

925

926

#-----------------------------------------Update Status stuff --------------------------

927

928

# The update_status_callback is what we can use to pass plymouth whatever we want so

929

# as to make use of features which are available only in this program (as opposed to

930

# being available for any theme for the script plugin).

931

932

# Example:

933

934

# Thanks to the current implementation, some scripts can call "plymouth --update=fsck:sda1:40"

935

# and this program will know that 1) we're performing and fsck check, 2) we're checking sda1,

936

# 3) the program should set the label progress to 40%

937

938

# Other features can be easily added by parsing the string that we pass plymouth with "--update"

939

940

fun update_status_callback (status) {

941

# Debug(status);

942

if (!status) return;

943

944

string_it = 0;

945

update_strings[string_it] = "";

946

947

for (i=0; (String(status).CharAt(i) != ""); i++) {

948

local.temp_char = String(status).CharAt(i);

949

if (temp_char != ":")

950

update_strings[string_it] += temp_char;

951

else

952

update_strings[++string_it] = "";

953

}

954

955

# my_string = update_strings[0] + " " + update_strings[1] + " " + update_strings[2];

956

# Debug(my_string);

957

# Let's assume that we're dealing with these strings fsck:sda1:40

958

if ((string_it >= 2) && (update_strings[0] == "fsck")) {

959

960

device = update_strings[1];

961

progress = update_strings[2];

962

status_string[0] = update_strings[3]; # "Checking disk %1$d of %2$d (%3$d %% complete)"

963

if (!status_string[0])

964

status_string[0] = "Checking disk %1$d of %2$d (%3$d %% complete)";

965

966

if ((device != "") && (progress != "")) {

967

progress = StringToInteger (progress);

968

969

# Make sure that the fsck_queue is initialised

970

if (!global.fsck_queue)

971

init_queue ();

972

973

# Make sure that the fsck counter is initialised

974

if (!global.counter)

975

init_fsck_count ();

976

977

# if (!global.progress_bar.extra_label.sprite)

978

# create_extra_fsck_label ();

979

980

# Keep track of the fsck check

981

fsck_check (device, progress, status_string);

982

}

983

984

}

985

986

}

987

Plymouth.SetUpdateStatusFunction (update_status_callback);

988

989

#-----------------------------------------Display Question stuff -----------------------

990

991

# TODO: Implement this if needed

992

993

# The callback function is called when the display should display a question dialogue.

994

# First arg is prompt string, the second is the entry contents.

995

#fun display_question_callback (prompt_string, entry_contents)

996

997

# time++;

998

999

1000

#Plymouth.SetDisplayQuestionFunction (display_question_callback);

1001

1002

#-----------------------------------------Refresh stuff --------------------------------

1003

1004

# Calling Plymouth.SetRefreshFunction with a function will set that function to be

1005

# called up to 50 times every second, e.g.

1006

1007

# NOTE: if a refresh function is not set, Plymouth doesn't seem to be able to update

1008

# the screen correctly

1009

1010

fun refresh_callback ()

1011

{

1012

draw_logo ();

1013

}

1014

Plymouth.SetRefreshFunction (refresh_callback);

1015

1016

1017

#-----------------------------------------Display Normal stuff -----------------------

1018

1019

# The callback function is called when the display should return to normal

1020

fun display_normal_callback ()

1021

{

1022

global.status = "normal";

1023

if (global.password_dialogue) {

1024

password_dialogue_opacity (0);

1025

global.password_dialogue = NULL;

1026

if (message_notification[2].sprite) hide_message(2);

1027

prompt_active = 0;

1028

}

1029

1030

if (message_notification[1].sprite) show_message (1);

1031

1032

1033

}

1034

1035

Plymouth.SetDisplayNormalFunction (display_normal_callback);

1036

1037

1038

#----------------------------------------- Quit --------------------------------

1039

1040

# TODO: Maybe we should also hide any other dialog

1041

# Show the logo and make the progress indicator look full when on exit

1042

fun quit_callback ()

1043

{

1044

logo.sprite.SetOpacity (1);

1045

switch_on_bullets ();

1046

}

1047

1048

Plymouth.SetQuitFunction(quit_callback);

Older »