home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / boot / i386 / root / usr / share / YaST2 / modules / OSRPkgUI.ycp < prev    next >
Text File  |  2006-11-29  |  19KB  |  741 lines
  1. /**
  2.  * File:    OSRPkgUI.ycp
  3.  * Module:    repair
  4.  * Summary:    Packages check UI
  5.  * Authors:    Johannes Buchhold <jbuch@suse.de>
  6.  *
  7.  * $Id: OSRPkgUI.ycp 23769 2005-06-21 12:18:10Z jsuchome $
  8.  *
  9.  * Provide osr mode information.
  10.  */
  11. {
  12.     module "OSRPkgUI";
  13.  
  14.     import "HTML";
  15.     import "Report";
  16.     import "Label";
  17.     import "Popup";
  18.  
  19.     import "OSRSystem";
  20.     import "OSRExecute";
  21.     import "OSRLogFile";
  22.     import "OSRProgress";
  23.     import "OSRMode";
  24.     import "OSRPkgVerify";
  25.     import "OSRPopup";
  26.  
  27.     textdomain "repair";
  28.  
  29.     ////////////////////////////////////////////////////////
  30.     // Static
  31.     ////////////////////////////////////////////////////////
  32.  
  33.     /**
  34.      * Symbol and key's for the widget comunication
  35.      */
  36.     symbol package_progress_bar  = `package_progress_bar;
  37.     string package_widget     = "package_widget";
  38.     string ok_or_cancel_key     = "ok_or_cancel";
  39.     string pause_key         = "pause";
  40.     string mode_key         = "mode";
  41.     string mode_replace_point_key = "replace_point";
  42.  
  43.     // buttons label
  44.     string pause_label        = _("&Pause");
  45.     // buttons label
  46.     string continue_label    = _("&Continue");
  47.  
  48.     /**
  49.      * All allowed rpm test options with description.
  50.      */
  51.     list<list> modes = [
  52.     // 'rpm -V <package>' output flag
  53.     ["S",    _("The File Size")            ],
  54.     ["M",    _("The File Mode")            ],
  55.     ["5",    _("The MD5 Checksum of the File")    ],
  56.     ["D",    _("The File Major and Minor Number")    ],
  57.     ["L",    _("The File Symbolic Link Content")    ],
  58.     ["U",    _("The Owner of the File")        ],
  59.     ["G",    _("The File Group")            ],
  60.     ["T",    _("The Last Modification Time")        ]
  61.     ];
  62.  
  63.     ////////////////////////////////////////////////////////
  64.     // Not static
  65.     ////////////////////////////////////////////////////////
  66.  
  67.     /**
  68.      * True if the user have paused the verifying process.
  69.      */
  70.     boolean pause         = false;
  71.  
  72.     /**
  73.      * Show successful package checks too.
  74.      */
  75.     boolean show_ok         = false;
  76.  
  77.     /**
  78.      * Summary text of all passed and not passed packages.
  79.      */
  80.     string verified_text_ok     = "";
  81.  
  82.     /**
  83.      * Summary text of the not passed packages only.
  84.      */
  85.     string verified_text     = "";
  86.  
  87.     /**
  88.      * Count of packages which should be checked.
  89.      */
  90.     integer package_count        = 0;
  91.  
  92.     /**
  93.      * Dialogs for expert and normal mode.
  94.      */
  95.     list dialogs         =  [];
  96.  
  97.     /**
  98.      * If expert is activated.
  99.      */
  100.     global boolean expert_mode     = false;
  101.  
  102.     /**
  103.      * if current UI can use `DownloadProgress
  104.      */
  105.     boolean has_progress_widget    = false;
  106.  
  107.     /**
  108.      * packages that should be reinstalled after verification
  109.      * (only helper structure, for showing list in dialogs)
  110.      */
  111.     list packages_to_reinstall    = [];
  112.  
  113.  
  114.     //-----------------------------------------------------------------
  115.  
  116.     /**
  117.      *
  118.      */
  119.     boolean protocol_mode    = false;
  120.  
  121.     // crate header for verification output richtext
  122.     define void set_verify_text_header() {
  123.  
  124.     string header        = "";
  125.     string hr            = "";
  126.     list<string> special = [];
  127.  
  128.     // Build headers for the tables in qt-mode
  129.     has_progress_widget = UI::HasSpecialWidget (`DownloadProgress);
  130.     if (has_progress_widget)
  131.     {
  132.         special = [ "width=400", "align=right"];
  133.  
  134.         header = "<table %5><tr> <th>%1</th>
  135.                                  <th>%2</th>
  136.                                  <th>%3</th>
  137.                                  <th %6> %4</th>
  138.                             </tr>";
  139.  
  140.         hr     = sformat("<tr> <th><hr></th>
  141.                                <td><hr></td>
  142.                                <td><hr></td>
  143.                                <td %1><hr></td>
  144.                                </tr>", special[1]:"");
  145.  
  146.         verified_text_ok = sformat( header,
  147.                     HTML::Bold(_("Package Name")),
  148.                     HTML::Bold(_("Files")),
  149.                     HTML::Bold(_("Configuration File")),
  150.                     HTML::Bold(_("Status")),
  151.                     special[0]:"",
  152.                     special[1]:"" );
  153.  
  154.         verified_text_ok = verified_text_ok + hr;
  155.         verified_text    = verified_text_ok;
  156.     }
  157.     else {
  158.         y2debug("no headline");
  159.     }
  160.     }
  161.  
  162.      /**
  163.      * Reset all (not static)  module settings.
  164.      */
  165.     global define void Reset()``{
  166.  
  167.     // Reset values
  168.     show_ok            = false;
  169.     pause            = false;
  170.     package_count        = 0;
  171.     expert_mode        = false;
  172.     dialogs            = [];
  173.     protocol_mode        = false;
  174.     verified_text        = "";
  175.     verified_text_ok    = "";
  176.     packages_to_reinstall    = [];
  177.  
  178.     OSRProgress::Reset();
  179.  
  180.     }
  181.  
  182.     /**
  183.      * Constructor- reset module settings.
  184.      */
  185.     global define void OSRPkgUI()``{
  186.     Reset();
  187.     }
  188.  
  189.     /**
  190.      * Fill a string with the specified character.
  191.      * Used in ncurses mode for formatting.
  192.      */
  193.     define string fill(string str, integer length, string c)``{
  194.     if (size(str) > length ) return substring(str, 0, length);
  195.     while( size(str) < length ) { str = str +c ;}
  196.     return str;
  197.     }
  198.  
  199.     /**
  200.      * Return the current dialog ( expert or normal dialog).
  201.      */
  202.     define term get_verify_dialog()``{
  203.  
  204.     integer pos =  0;
  205.     if (protocol_mode ) pos = 3;
  206.     else {
  207.         pos = ( expert_mode ) ? 0 : 1 ;
  208.     }
  209.     return dialogs[ pos ]:`Empty();
  210.     }
  211.  
  212.     /**
  213.      * Repaint the displayed text depending on the show_ok value (CheckBox Show all).
  214.      */
  215.     define boolean repaint()``{
  216.  
  217.     if (UI::WidgetExists(`id(package_widget )))
  218.     {
  219.         string table = "</table>";
  220.  
  221.         if (!has_progress_widget)
  222.         {
  223.         table = "";
  224.         }
  225.  
  226.         if (show_ok && UI::WidgetExists(`id(package_widget )))
  227.         {
  228.         return UI::ChangeWidget(`id( package_widget), `Value,  verified_text_ok + table );
  229.         }
  230.         else {
  231.         return UI::ChangeWidget(`id( package_widget), `Value,  verified_text + table );
  232.         }
  233.     }
  234.     return false;
  235.     }
  236.  
  237.     /**
  238.      * Switch between expert and normal mode.
  239.      */
  240.     define void set_expert_mode(boolean t_expert_mode )``{
  241.     //boolean changed  = t_expert_mode != expert_mode;
  242.  
  243.     expert_mode = t_expert_mode;
  244.     show_ok     = true;
  245.  
  246.     if (UI::WidgetExists(`id(mode_replace_point_key)))
  247.     {
  248.         UI::ReplaceWidget(`id(mode_replace_point_key), get_verify_dialog());
  249.         UI::ChangeWidget( `id(mode_key ), `Value, expert_mode);
  250.         UI::RecalcLayout();
  251.         repaint();
  252.     }
  253.  
  254.     if (UI::WidgetExists(`id( package_progress_bar )))
  255.     {
  256.         UI::ChangeWidget(`id( package_progress_bar), `Value, OSRPkgVerify::VerifiedSize ());
  257.     }
  258.     }
  259.  
  260.  
  261.     /**
  262.      * Build string: Checking package: (43/234)
  263.      */
  264.     define string check_string()``{
  265.     // current action label; %1 is current package number, %2 all packages
  266.     return sformat(_("Package %1 of %2"), OSRPkgVerify::VerifiedSize (), package_count);
  267.     }
  268.  
  269.     /**
  270.      * Create to dialogs. One for the expert user mode and one for the
  271.      * normal user mode. Save both dialogs in the list dialogs for
  272.      * later use.
  273.      */
  274.     define void build_verify_dialog_contents(string headline)``{
  275.     dialogs = [];
  276.  
  277.     //components for both
  278.     term ok_cancel_button =  `PushButton( `id(ok_or_cancel_key),  Label::CancelButton());
  279.     term switch_button    = `CheckBox(`id(mode_key ),    `opt(`notify),  _("Show &Details"), expert_mode );
  280.     term progress_bar     =  OSRProgress::CreateProgressBar(package_progress_bar,  check_string(),  package_count  );
  281.     term show_ok_term     = `Left(`CheckBox(`id("show_ok"), `opt(`notify), _("Also Show Successfully Verified &Packages"),  show_ok));
  282.     term protocol          =  `RichText(`id(package_widget), `opt(`vstretch, `autoScrollDown )  , (show_ok ) ? verified_text_ok : verified_text );
  283.  
  284.     dialogs = add( dialogs,
  285.                `HBox(`VSpacing(20),
  286.                  `VBox(
  287.                    `HSpacing(80),
  288.                    show_ok_term,
  289.                    protocol,
  290.                    `Left(`PushButton(`id(pause_key),  pause_label )))
  291.                  ));
  292.  
  293.     dialogs = add( dialogs, `Empty());
  294.  
  295.     // normal dialog
  296.     dialogs = add( dialogs,
  297.                `HBox(`HSpacing(3),
  298.                  `VBox(
  299.                    `HSpacing(80),
  300.                    `VBox(
  301.                      `HSpacing(80),
  302.                      `Left(`Heading(headline)),
  303.                      `VSpacing(1),
  304.                      progress_bar,
  305.                      `Left(switch_button) ),
  306.                    `ReplacePoint(`id(mode_replace_point_key ),  dialogs[1]:`Empty() ),
  307.                    ok_cancel_button
  308.                    ),
  309.                  `HSpacing(3)
  310.                  ));
  311.  
  312.     dialogs = add( dialogs, `HBox(`HWeight(1, `HSpacing(3)),
  313.                       `HWeight(30,`VBox(`VWeight(10, show_ok_term ),
  314.                              `VWeight(80, protocol ),
  315.                              `VWeight(10, `PushButton( `id(ok_or_cancel_key), Label::OKButton())  ))),
  316.                       `HWeight(1, `HSpacing(1))));
  317.     }
  318.  
  319.     /**
  320.      * Open the main dialog depending on the values t_expert_mode (expert_mode).
  321.      */
  322.     global define boolean OpenVerifyDialog(integer size_progress , string headline , boolean t_expert_mode )``{
  323.  
  324.     if (verified_text == "")
  325.     {
  326.         set_verify_text_header();
  327.     }
  328.     // count of package which should be verified.
  329.     package_count   = size_progress;
  330.  
  331.  
  332.     // build the dialog depending on the mode.
  333.     build_verify_dialog_contents(headline);
  334.  
  335.     // open the dialog.
  336.     boolean ret = UI::OpenDialog( dialogs[2]:`Empty() );
  337.  
  338.     // set mode - expert mode or normal mode.
  339.     // set_expert_mode( t_expert_mode );
  340.  
  341.     return ret;
  342.     }
  343.  
  344.     /**
  345.      * Generate a key for a package without error.
  346.      */
  347.     define string pkg_name2ok_key(string pkg_name)``{
  348.     return "status" + pkg_name ;
  349.     }
  350.  
  351.     /**
  352.      * Decode the package name from a key for a package without error.
  353.      */
  354.     define string ok_key2pkg_name(string input ) ``{
  355.     if (substring(input, 0, size("status")) == "status" )
  356.     {
  357.         string pkg_name = substring(input, size("status") );
  358.         if (OSRPkgVerify::PackageVerified (pkg_name))
  359.         return pkg_name;
  360.     }
  361.     return "";
  362.     }
  363.  
  364.     /**
  365.      * 'translate' booleqan to string which can be shown in dialogs
  366.      */
  367.     define string boolean2string (boolean val) ``{
  368.  
  369.     // table entry (value in the column "Configuration file")
  370.     // translate it either as True/False or Yes/No
  371.     return val ? _("Yes") : _("No");
  372.     }
  373.  
  374.     /**
  375.      * Update the list of files, which failed during package verification
  376.      * returns contents of the richtext
  377.      */
  378.     define string update_files (string pkg_name, list<map> pkg_data) {
  379.  
  380.     string ret            = "";
  381.     string tab_pkg_name_color    = contains (
  382.         OSRPkgVerify::not_successful_verified, pkg_name) ? "red" : "blue" ;
  383.     string line_sf            = "<li>%1 %2 %3</li>%4";
  384.     string align            = "";
  385.     if (has_progress_widget)
  386.     {
  387.         align    = "align=right";
  388.         line_sf    = "<tr><td  colspan=2 align=right> %1</td>
  389.                 <td>%2</td>
  390.                                 <td %4>%3</td>
  391.                </tr>";
  392.     }
  393.  
  394.     foreach (map line, pkg_data, {
  395.  
  396.         string color    = line["green_status"]:"" == ""? "red": "green";
  397.         string file_status    =
  398.             HTML::Bold (HTML::Colorize (line["status"]:"", color));
  399.         string file        = line["file"]:"";
  400.         string config_file    = boolean2string (line["config_file"]:false);
  401.  
  402.         if (!has_progress_widget)
  403.         {
  404.         file        = fill (file, 50, ".") + "..";
  405.         config_file    = fill (config_file, 7, ".");
  406.         }
  407.  
  408.         if (line["more"]:false)
  409.         {
  410.         file        = HTML::Link (
  411.             // last entry of file list (cut because of length)
  412.             HTML::Colorize (_("more..."), tab_pkg_name_color),
  413.             pkg_name + "_more_packages"
  414.         );
  415.         config_file    = "";
  416.         file_status    = "";
  417.         }
  418.  
  419.         ret = ret + sformat(line_sf, file, config_file, file_status, align);
  420.     });
  421.     return ret;
  422.     }
  423.  
  424.     /**
  425.      * Add a new package entry to the internal list and the displayed text.
  426.      * Update the process bar too.
  427.      * Afterwards call repaint define.
  428.      */
  429.     define boolean update (string pkg_name) {
  430.  
  431.     if (UI::WidgetExists(`id("show_ok")))
  432.         show_ok = (boolean) UI::QueryWidget(`id("show_ok"), `Value );
  433.  
  434.     string tab_body            = "";
  435.     string tab_pkg_status        = "";
  436.     string tab_pkg_name_color    = contains (
  437.         OSRPkgVerify::not_successful_verified, pkg_name) ? "red" : "blue" ;
  438.     string tab_pkg_name        = HTML::Link (HTML::Bold (
  439.         HTML::Colorize (pkg_name, tab_pkg_name_color)), pkg_name);
  440.  
  441.     boolean ok    = size (OSRPkgVerify::verify_data) == 0;
  442.     if (ok)
  443.     {
  444.         tab_pkg_status = HTML::Link (
  445.         HTML::Bold (HTML::Colorize ("ok", "blue")),
  446.         pkg_name2ok_key (pkg_name)
  447.         );
  448.     }
  449.     else
  450.     {
  451.         if (tab_pkg_status == "" ) tab_pkg_status = HTML::Bold("...");
  452.         tab_body    = update_files (pkg_name, OSRPkgVerify::verify_data);
  453.     }
  454.  
  455.     string line_sf = "<tr><th>%1</th>
  456.                                     <th></th>
  457.                                     <th></th>
  458.                                     <th %4> %2</th> %3
  459.                                 </tr>";
  460.     string align    = "align=right";
  461.  
  462.     if (!has_progress_widget)
  463.     {
  464.         string n1    = HTML::Bold (_("Package:"));
  465.         string n2   = HTML::Bold (ok ? "": _("Files:")) + "<br>";
  466.         line_sf    =
  467.         "<br><br>" + n1 +"<li><b>%1</b> <b>%2</b></li>" + n2 + "%3%4";
  468.         tab_pkg_name = tab_pkg_name + fill ("", 60 - size(pkg_name), ".");
  469.         align    = "";
  470.     }
  471.  
  472.     string table    =
  473.         sformat (line_sf, tab_pkg_name, tab_pkg_status, tab_body, align);
  474.  
  475.     verified_text_ok = verified_text_ok + table;
  476.  
  477.     if (!ok)
  478.     {
  479.         verified_text = verified_text + table;
  480.     }
  481.     return repaint();
  482.     }
  483.  
  484.     /**
  485.      * Show the complete ouptput of package verification
  486.      * (in the summary, it is limited to OSRPkgVerify::max_files entries)
  487.      */
  488.     define symbol show_complete_verify_list (string pkg_name) {
  489.  
  490.     UI::OpenDialog (`HBox (
  491.         `HSpacing (3),
  492.         `VSpacing (OSRPkgVerify::max_files + 10),
  493.         `VBox (
  494.         `HSpacing(80),
  495.         `VSpacing (1),
  496.         // label - %1 is package name; file list (=result) will follow
  497.         `Label (sformat (_("Result of Package '%1' Verification"),
  498.             pkg_name)),
  499.         `VSpacing (1),
  500.         `RichText (`id (`files), `opt(`vstretch, `autoScrollDown), ""),
  501.         `PushButton (`id(`ok), Label::OKButton())
  502.         ),
  503.         `HSpacing(3)
  504.     ));
  505.  
  506.     UI::BusyCursor ();
  507.  
  508.     OSRExecute::CommandOutput (.local.bash,
  509.         sformat("LANG=ENG /bin/rpm --root %2 -V %1", pkg_name,
  510.         OSRPkgVerify::root_for_verification));
  511.  
  512.     map out = OSRPkgVerify::convert_verify_output (
  513.         pkg_name, OSRExecute::stdout, true);
  514.  
  515.     string start    = "";
  516.     string end    = "";
  517.         if (has_progress_widget)
  518.     {
  519.         start    = sformat (
  520.         "<table><tr>
  521.             <th colspan=2 align=right>%1</th>
  522.             <th>%2</th>
  523.             <th align=right>%3</th>
  524.         </tr>",
  525.         _("Files "), _("Configuration File"), _("Status"));
  526.         end        = "</table>";
  527.     }
  528.     UI::ChangeWidget (`id(`files), `Value,
  529.         start + update_files (pkg_name, out["verify_data"]:[]) + end);
  530.  
  531.     UI::NormalCursor ();
  532.     UI::UserInput ();
  533.     UI::CloseDialog ();
  534.     return `again;
  535.     }
  536.  
  537.     /**
  538.      * popup with the summary of the package
  539.      */
  540.     define symbol show_package_details (string pkg_name) {
  541.     // popup headline
  542.     map ret = OSRPopup::CheckBoxDialog (_("Package Details"),
  543.         Pkg::PkgSummary (pkg_name),
  544.         [ [ pkg_name,
  545.         // checkbox label
  546.         _("Reinstall the Package"),
  547.         contains (packages_to_reinstall, pkg_name)
  548.         ] ]
  549.     );
  550.     foreach (string pkg, boolean reinstall, (map<string,boolean>) ret , ``{
  551.  
  552.         if (reinstall)
  553.         {
  554.         packages_to_reinstall = union (packages_to_reinstall, [ pkg ]);
  555.         }
  556.         else
  557.         {
  558.         packages_to_reinstall = filter (string name,
  559.             (list<string>) packages_to_reinstall, ``( name != pkg ));
  560.         }
  561.     });
  562.  
  563.     return `next;
  564.     }
  565.  
  566.  
  567.     /**
  568.      * Toggle the pause button between pause and continue.
  569.      */
  570.     define symbol toggle_pause_button() ``{
  571.     pause = ! pause;
  572.  
  573.     if (UI::WidgetExists(`id(pause_key)))
  574.     {
  575.         if (!pause)
  576.         {
  577.         UI::ChangeWidget(`id(pause_key), `Label,  pause_label  );
  578.         return `continue;
  579.         }
  580.         else
  581.         {
  582.         UI::ChangeWidget(`id(pause_key), `Label,  continue_label  );
  583.         return `pause;
  584.         }
  585.     }
  586.     }
  587.  
  588.     /**
  589.      * Eval the user input.
  590.      */
  591.     global define symbol EvalUserInput (string input) ``{
  592.  
  593.     // if the user pressed the or or cancel button ask or abort
  594.     if (input == ok_or_cancel_key )
  595.     {
  596.         // if not all packages are verified ask the user if he
  597.         // want really cancel.
  598.         if (package_count > OSRPkgVerify::VerifiedSize () && !protocol_mode)
  599.         {
  600.         // popup question
  601.         if (!Popup::YesNo(_("Really cancel package verification?")))
  602.         {
  603.             return `again;
  604.         }
  605.  
  606.         }
  607.         return `abort;
  608.     }
  609.     else if (input == pause_key )
  610.     {
  611.         // if the user pressed the pause or continue button
  612.         // change the label of the button.
  613.         return toggle_pause_button();
  614.     }
  615.     else if (input == "show_ok")
  616.     {
  617.         // if the dialog in the expert mode and the user
  618.         // clicked the checkbox "show_ok" change the
  619.         // shown verify text
  620.         show_ok = (boolean) UI::QueryWidget(`id("show_ok"), `Value );
  621.         repaint();
  622.     }
  623.     else if (OSRPkgVerify::PackageVerified (input))
  624.     {
  625.         // if the dialog in the expert mode and the
  626.         // user clicked a package name open a dialog
  627.         // with the summary of the package
  628.         show_package_details (input);
  629.     }
  630.     else if (ok_key2pkg_name (input) != "" )
  631.     {
  632.         // if the dialog in the expert mode and the
  633.         // user clicked a package status open a
  634.         // dialog with the following message.
  635.         Report::Message(sformat(_("
  636. Verifying the package %1 was successful.
  637. "), ok_key2pkg_name(input)));
  638.     }
  639.     else if (input == mode_key )
  640.     {
  641.         // change the dialog mode between the expert
  642.         // and the normal mode.
  643.         set_expert_mode ((boolean)UI::QueryWidget(`id(mode_key ), `Value));
  644.         if (pause)
  645.         {
  646.         toggle_pause_button();
  647.         return `continue;
  648.         }
  649.     }
  650.     else if (issubstring (input, "_more_packages"))
  651.     {
  652.         string pkg_name = substring (input,0,find (input,"_more_packages"));
  653.         if (!OSRPkgVerify::PackageVerified (pkg_name))
  654.         {
  655.         y2warning ("strange, package %1 not verified", pkg_name);
  656.         return `again;
  657.         }
  658.         show_complete_verify_list (pkg_name);
  659.     }
  660.     else
  661.     {
  662.         // open a extended dialog which describe the packages status
  663.         //S.5....T c  <- Config file
  664.         string pkg_name = regexpsub (input,
  665.         sformat("(.*%1).*", OSRPkgVerify::separator),  "\\1");
  666.         pkg_name        = substring (pkg_name, 0,
  667.         size(pkg_name) - size (OSRPkgVerify::separator));
  668.  
  669.     }
  670.     return `again;
  671.     }
  672.  
  673.     /**
  674.      * update the item list of 'missing_packages' with the ones
  675.      * selected to reinstall by user during verification
  676.      */
  677.     global define list<list> update_missing_packages (
  678.     list<list> item_list, boolean check) {
  679.  
  680.     foreach (string item, (list<string>) packages_to_reinstall, {
  681.         if (!contains (OSRPkgVerify::not_successful_verified, item))
  682.         item_list = add (item_list, [item, check]);
  683.     });
  684.     return item_list;
  685.     }
  686.  
  687.     global define list ProtocolDialog()``{
  688.  
  689.     protocol_mode = true;
  690.  
  691.     UI::OpenDialog( get_verify_dialog()  );
  692.  
  693.     symbol ret  = `next;
  694.     string rret = "";
  695.  
  696.     repaint();
  697.     repeat
  698.     {
  699.         rret = (string) UI::UserInput();
  700.         y2milestone(" user input in protocol dialogs : %1", rret);
  701.         ret  = EvalUserInput (rret);
  702.     } until (ret == `abort || ret == `cancel);
  703.  
  704.     UI::CloseDialog();
  705.     protocol_mode = false;
  706.  
  707.     list<list> item_list = [];
  708.     foreach (string item, OSRPkgVerify::not_successful_verified , {
  709.         boolean checked = contains (packages_to_reinstall, item);
  710.         item_list = add (item_list, [item, checked]);
  711.     });
  712.     return update_missing_packages (item_list, true);
  713.     }
  714.  
  715.     global define boolean AddPackageSummary (string pkg_name) {
  716.  
  717.     boolean ret = update (pkg_name);
  718.  
  719.     if (UI::WidgetExists(`id( package_progress_bar )))
  720.     {
  721.         OSRProgress::SetLabel (package_progress_bar, check_string());
  722.     }
  723.     return ret;
  724.     }
  725.  
  726.     /**
  727.      * Finish the dialog.
  728.      */
  729.     global define void Finish()``{
  730.     UI::ChangeWidget(`id(ok_or_cancel_key), `Label, Label::OKButton());
  731.  
  732.     if (UI::WidgetExists(`id(pause_key ) ))
  733.     {
  734.         UI::ChangeWidget(`id(pause_key),    `Enabled, false);
  735.     }
  736.     }
  737.  
  738.  
  739. }//EOF
  740.  
  741.