ACC SHELL
/**
* Module: SlideShowCallbacks.ycp
*
* Authors: Gabriele Strattner <gs@suse.de>
* Klaus Kaempf <kkaempf@suse.de>
*
* Purpose: provides the Callbacks for SlideShow
*
* $Id: SlideShowCallbacks.ycp 56888 2009-04-21 13:37:14Z lslezak $
*
*/
{
module "SlideShowCallbacks";
textdomain "packager";
import "Installation";
import "Label";
import "Mode";
import "Stage";
import "PackageCallbacks";
import "Popup";
import "SlideShow";
import "PackageSlideShow";
import "Message";
import "Directory";
import "URL";
boolean _remote_provide = false;
string pkg_inprogress = "";
/**
* Check for user button presses and handle them.
*
* @return true if user wishes to abort
**/
void HandleInput()
{
// any button = SlideShow::debug ? UI::PollInput() : UI::TimeoutUserInput( 10 );
any button = UI::PollInput();
// in case of cancel ask user if he really wants to quit installation
if ( button == `abort || button == `cancel )
{
if ( Mode::normal () )
{
SlideShow::SetUserAbort(Popup::AnyQuestion( Popup::NoHeadline(),
// popup yes-no
_("Do you really want\nto quit the installation?"),
Label::YesButton(),
Label::NoButton(),
`focus_no ));
}
else if ( Stage::initial () )
{
SlideShow::SetUserAbort(Popup::ConfirmAbort( `unusable ));
}
else // Mode::update (), Stage::cont ()
{
SlideShow::SetUserAbort(Popup::ConfirmAbort( `incomplete ));
}
if (SlideShow::GetUserAbort())
{
SlideShow::AppendMessageToInstLog (_("Aborted"));
}
}
else
{
SlideShow::HandleInput( button );
}
}
/**
* at start of file providal
*/
global void StartProvide( string name, integer archivesize, boolean remote )
{
pkg_inprogress = name;
_remote_provide = remote;
PackageSlideShow::SlideProvideStart (name , archivesize, remote);
}
/**
* during file providal
*/
global boolean ProgressProvide(integer percent)
{
if (_remote_provide)
{
PackageSlideShow::UpdateCurrentPackageProgress( percent );
}
HandleInput();
return ! SlideShow::GetUserAbort();
}
global boolean ProgressDownload(integer percent, integer bps_avg, integer bps_current)
{
PackageSlideShow::UpdateCurrentPackageRateProgress(percent, bps_avg, bps_current);
HandleInput();
return ! SlideShow::GetUserAbort();
}
/**
* during file providal
*/
global string DoneProvide( integer error, string reason, string name )
{
if ( _remote_provide )
{
PackageSlideShow::UpdateCurrentPackageProgress( 100 );
PackageSlideShow::DoneProvide( error, reason, name );
_remote_provide = false;
}
if (SlideShow::GetUserAbort())
{
return "CANCEL";
}
if (error != 0)
{
return PackageCallbacks::DoneProvide( error, reason, name );
}
return "";
}
global void ScriptStart(string patch_name, string patch_version, string patch_arch, string script_path)
{
string patch_full_name = PackageCallbacks::FormatPatchName(patch_name, patch_version, patch_arch);
y2milestone("ScriptStart: patch:%1, script:%2", patch_full_name, script_path);
// reset the progressbar
if (UI::WidgetExists(`progressCurrentPackage))
{
UI::ChangeWidget(`progressCurrentPackage, `Label, patch_full_name);
UI::ChangeWidget(`progressCurrentPackage, `Value, 0);
}
// message in the installation log widget, %1 is a patch name which contains the script
string log_line = sformat(_("Starting script %1"), patch_full_name);
SlideShow::AppendMessageToInstLog(log_line);
}
global boolean ScriptProgress (boolean ping, string output)
{
y2milestone("ScriptProgress: ping:%1, output: %2", ping, output);
if (output != nil && output != "")
{
string log_line = output;
// remove the trailing new line character
if (substring(output, size(output) - 1, 1) == "\n")
{
output = substring(output, 0, size(output) - 1);
}
// add the output to the log widget
SlideShow::AppendMessageToInstLog(output);
}
any input = UI::PollInput ();
y2milestone("input: %1", input);
if (input == `abort || input == `close)
return false;
return true;
}
global string ScriptProblem(string description)
{
y2milestone("ScriptProblem: %1", description);
Popup::Error(description);
// Abort
// TODO: support also Ignore and Retry
return "A";
}
global void ScriptFinish()
{
y2milestone("ScriptFinish");
}
global void Message(string patch_name, string patch_version, string patch_arch, string message)
{
string patch_full_name = PackageCallbacks::FormatPatchName(patch_name, patch_version, patch_arch);
y2milestone("Message (%1): %2", patch_full_name, message);
if (patch_full_name != "")
{
// label, %1 is patch name with version and architecture
patch_full_name = sformat(_("Patch %1\n\n"), patch_full_name);
}
Popup::LongMessage(patch_full_name + message);
}
//--------------------------------------------------------------------------
// slide show
term YesNoButtonBox()
{
term yes_button = `PushButton(`id(`yes), `opt(`key_F10), Label::YesButton());
term no_button = `PushButton(`id(`no_button), `opt(`default, `key_F9), Label::NoButton());
return `HBox(
`HStretch(),
`HWeight( 1, yes_button),
`HSpacing(2),
`HWeight( 1, no_button ),
`HStretch()
);
}
// never show the disk space warning popup during autoinstallation
boolean ask_again = Mode::autoinst() ? false : true;
// true == continue with the installtion
boolean user_input = true;
boolean YesNoAgainWarning(string message)
{
if (!ask_again)
{
return user_input;
}
term icon = `Empty();
// show the warning icon if possible
map ui_capabilities = UI::GetDisplayInfo();
if ( ui_capabilities[ "HasLocalImageSupport" ]:false )
{
icon = `Image( Directory::icondir + "32x32/apps/msg_warning.png", "" );
}
term content = `MarginBox(1.5, 0.5,
`VBox(
`HBox(
`VCenter(icon),
`HSpacing(1),
`VCenter(`Heading(Label::WarningMsg())),
`HStretch()
),
`VSpacing(0.2),
`Left( `Label( message ) ),
`VSpacing(0.2),
`Left(`CheckBox(`id(`dont_ask), Message::DoNotShowMessageAgain())),
`VSpacing(0.5),
YesNoButtonBox()
)
);
UI::OpenDialog(`opt(`decorated), content);
any ret = UI::UserInput();
ask_again = !(boolean) UI::QueryWidget(`id(`dont_ask), `Value);
if (!ask_again)
{
// remember the user input
user_input = (ret == `yes);
}
UI::CloseDialog();
return ret == `yes;
}
/**
* Callback that will be called by the packager for each RPM as it is being installed or deleted.
* Note: The packager doesn't call this directly - the corresponding wrapper callbacks do
* and pass the "deleting" flag as appropriate.
**/
global void DisplayStartInstall(string pkg_name, string pkg_description, integer pkg_size, boolean deleting )
{
PackageSlideShow::SlideDisplayStart( pkg_name, pkg_description, pkg_size, deleting );
HandleInput();
// warn user about exhausted diskspace during installation (not if deleting packages)
if (!deleting && ask_again)
{
map<string, list<integer> > pkgdu = Pkg::PkgDU(pkg_inprogress);
y2debug("PkgDU(%1): %2", pkg_inprogress, pkgdu);
if (pkgdu != nil)
{
// check each mount point
foreach(string part, list<integer> data, pkgdu,
{
// skip read-only partitions, the package cannot be installed anyway
if (data[3]:0 == 1)
{
y2debug("Skipping read-only partition %1", part);
continue;
}
// add slash if missing (needed for target_dir)
if (part != "/" && size(part) >= 1 && substring(part, 0, 1) != "/")
{
part = "/" + part;
}
string target_dir = Installation::destdir + part;
integer disk_available = Pkg::TargetAvailable(target_dir);
y2debug("partition: %1 (%2), available: %3", part, target_dir, disk_available);
if (disk_available < data[2]:0)
{
y2warning("Not enought free space in %1 (%2): available: %3, required: %4", part, target_dir, disk_available, data[2]:0);
boolean cont = YesNoAgainWarning(
// warning popup - %1 is directory name (e.g. /boot)
sformat(_("The disk space in partition %1 is nearly exhausted.\nContinue with the installation?"), part));
if (!cont)
{
SlideShow::SetUserAbort(true);
}
// don't check the other partitions
break;
}
}
);
}
else
{
// disk usage for each partition is not known
// assume that all files will be installed into the root directory
integer disk_available = Pkg::TargetAvailable(Installation::destdir);
y2milestone("Available space (%1): %2", Installation::destdir, disk_available);
if (disk_available < pkg_size)
{
y2warning("Not enough free space in %1: available: %2, required: %3", Installation::destdir, disk_available, pkg_size);
boolean cont = YesNoAgainWarning(
// yes-no popup
_("The disk space is nearly exhausted.\nContinue with the installation?")
);
if (!cont)
{
SlideShow::SetUserAbort(true);
}
}
}
}
}
/**
* at start of package install
*/
global void StartPackage( string name, string summary, integer install_size, boolean is_delete )
{
PackageCallbacks::_package_name = name;
PackageCallbacks::_package_size = install_size;
PackageCallbacks::_deleting_package = is_delete;
DisplayStartInstall( name,
summary,
install_size,
is_delete);
}
/**
* ProgressPackage percent
**/
global boolean ProgressPackage ( integer pkg_percent )
{
HandleInput();
if (!SlideShow::GetUserAbort())
{
PackageSlideShow::UpdateCurrentPackageProgress ( pkg_percent );
}
if (SlideShow::GetUserAbort())
{
y2milestone("Aborted at %1%%", pkg_percent);
}
return ! SlideShow::GetUserAbort();
};
/**
* at end of install
* just to override the PackageCallbacks default (which does a 'CloseDialog' :-})
*/
global string DonePackage( integer error, string reason )
{
if (SlideShow::GetUserAbort())
return "I";
PackageSlideShow::UpdateCurrentPackageProgress (100);
string ret = "";
if (error != 0)
{
ret = PackageCallbacks::DonePackage( error, reason );
}
else
{
// put additional rpm output to the installation log
if (reason != nil && size(reason) > 0)
{
y2milestone("Additional RPM output: %1", reason);
SlideShow::AppendMessageToInstLog(reason);
}
}
if (size (ret) == 0 || tolower (substring (ret, 0, 1)) != "r")
{
PackageSlideShow::SlideDisplayDone(
PackageCallbacks::_package_name,
PackageCallbacks::_package_size,
PackageCallbacks::_deleting_package);
}
return ret;
}
/**
* at start of file providal
*/
global void StartDeltaProvide( string name, integer archivesize )
{
PackageSlideShow::SlideGenericProvideStart (name , archivesize, _("Downloading delta RPM %1 (download size %2)"), true /*remote*/);
_remote_provide = true;
}
/**
* at start of file providal
*/
global void StartDeltaApply( string name )
{
PackageSlideShow::SlideDeltaApplyStart (name);
_remote_provide = true;
}
/**
* at start of file providal
*/
global void StartPatchProvide( string name, integer archivesize )
{
PackageSlideShow::SlideGenericProvideStart (name , archivesize, _("Downloading patch RPM %1 (download size %2)"), true /*remote*/);
_remote_provide = true;
}
/**
* during file providal
*/
global void ProgressDeltaApply( integer percent )
{
PackageSlideShow::UpdateCurrentPackageProgress ( percent );
}
/**
* at end of file providal
*/
global void FinishPatchDeltaProvide()
{
_remote_provide = false;
}
global void ProblemDeltaDownload (string descr) {
_remote_provide = false;
// error in installation log, %1 is detail error description
SlideShow::AppendMessageToInstLog (sformat (_("Failed to download delta RPM: %1"), descr));
}
global void ProblemDeltaApply (string descr) {
_remote_provide = false;
// error in installation log, %1 is detail error description
SlideShow::AppendMessageToInstLog (sformat (_("Failed to apply delta RPM: %1"), descr));
}
global void ProblemPatchDownload (string descr) {
_remote_provide = false;
// error in installation log, %1 is detail error description
SlideShow::AppendMessageToInstLog (sformat (_("Failed to download patch RPM: %1"), descr));
}
/**
* change of repository
* source: 0 .. n-1
* media: 1 .. n
**/
global void CallbackSourceChange( integer source, integer media)
{
PackageCallbacks::SourceChange( source, media ); // inform PackageCallbacks about the change
PackageSlideShow::SetCurrentCdNo( source, media );
PackageSlideShow::UpdateCurrentPackageProgress(0);
PackageSlideShow::UpdateAllCdProgress(false);
};
global string MediaChange (string error_code, string error, string url, string product,
integer current, string current_label,
integer wanted, string wanted_label,
boolean double_sided, list<string> devices, integer current_device)
{
if (!Mode::normal ())
{
SlideShow::StopTimer();
}
string ret = PackageCallbacks::MediaChange(error_code, error, url, product, current, current_label, wanted,
wanted_label, double_sided, devices, current_device);
if (!Mode::normal ())
{
SlideShow::StartTimer();
// moved from PackageCallbacks
if (ret == "" || URL::Check(ret))
{
PackageSlideShow::SetCurrentCdNo (PackageCallbacks::_current_source, wanted);
}
}
return ret;
}
/**
* Install callbacks for slideshow.
*/
global void InstallSlideShowCallbacks()
{
y2milestone( "InstallSlideShowCallbacks");
Pkg::CallbackStartPackage (SlideShowCallbacks::StartPackage);
Pkg::CallbackProgressPackage (SlideShowCallbacks::ProgressPackage);
Pkg::CallbackDonePackage (SlideShowCallbacks::DonePackage);
Pkg::CallbackStartProvide (SlideShowCallbacks::StartProvide);
Pkg::CallbackProgressProvide (SlideShowCallbacks::ProgressProvide);
Pkg::CallbackDoneProvide (SlideShowCallbacks::DoneProvide);
Pkg::CallbackProgressDownload(SlideShowCallbacks::ProgressDownload);
Pkg::CallbackSourceChange (SlideShowCallbacks::CallbackSourceChange);
Pkg::CallbackStartDeltaDownload (SlideShowCallbacks::StartDeltaProvide);
Pkg::CallbackProgressDeltaDownload (SlideShowCallbacks::ProgressProvide);
Pkg::CallbackProblemDeltaDownload (SlideShowCallbacks::ProblemDeltaDownload);
Pkg::CallbackFinishDeltaDownload (SlideShowCallbacks::FinishPatchDeltaProvide);
Pkg::CallbackStartDeltaApply (SlideShowCallbacks::StartDeltaApply);
Pkg::CallbackProgressDeltaApply (SlideShowCallbacks::ProgressDeltaApply);
Pkg::CallbackProblemDeltaApply (SlideShowCallbacks::ProblemDeltaApply);
Pkg::CallbackFinishDeltaApply (SlideShowCallbacks::FinishPatchDeltaProvide);
Pkg::CallbackStartPatchDownload (SlideShowCallbacks::StartPatchProvide);
Pkg::CallbackProgressPatchDownload (SlideShowCallbacks::ProgressProvide);
Pkg::CallbackProblemPatchDownload (SlideShowCallbacks::ProblemPatchDownload);
Pkg::CallbackFinishPatchDownload (SlideShowCallbacks::FinishPatchDeltaProvide);
Pkg::CallbackScriptStart(SlideShowCallbacks::ScriptStart);
Pkg::CallbackScriptProgress(SlideShowCallbacks::ScriptProgress);
Pkg::CallbackScriptProblem(SlideShowCallbacks::ScriptProblem);
Pkg::CallbackScriptFinish(SlideShowCallbacks::ScriptFinish);
Pkg::CallbackMessage(PackageCallbacks::Message);
Pkg::CallbackMediaChange(SlideShowCallbacks::MediaChange);
}
/**
* Remove callbacks for slideshow. Should be in SlideShowCallbacks but
* that doesn't work at the moment.
*/
global void RemoveSlideShowCallbacks()
{
y2milestone( "RemoveSlideShowCallbacks");
Pkg::CallbackStartPackage (nil);
Pkg::CallbackProgressPackage (nil);
Pkg::CallbackDonePackage (nil);
Pkg::CallbackStartProvide (nil);
Pkg::CallbackProgressProvide (nil);
Pkg::CallbackDoneProvide (nil);
Pkg::CallbackSourceChange (nil);
Pkg::CallbackStartDeltaDownload (nil);
Pkg::CallbackProgressDeltaDownload (nil);
Pkg::CallbackProblemDeltaDownload (nil);
Pkg::CallbackFinishDeltaDownload (nil);
Pkg::CallbackStartDeltaApply (nil);
Pkg::CallbackProgressDeltaApply (nil);
Pkg::CallbackProblemDeltaApply (nil);
Pkg::CallbackFinishDeltaApply (nil);
Pkg::CallbackStartPatchDownload (nil);
Pkg::CallbackProgressPatchDownload (nil);
Pkg::CallbackProblemPatchDownload (nil);
Pkg::CallbackFinishPatchDownload (nil);
Pkg::CallbackScriptStart(nil);
Pkg::CallbackScriptProgress(nil);
Pkg::CallbackScriptProblem(nil);
Pkg::CallbackScriptFinish(nil);
Pkg::CallbackMessage(nil);
}
}
ACC SHELL 2018