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 / Progress.ycp < prev    next >
Text File  |  2006-11-29  |  13KB  |  503 lines
  1. /**
  2.  * File:    modules/Progress.ycp
  3.  * Module:    Progress
  4.  * Summary:    Progress bar
  5.  * Authors:    Petr Blahos <pblahos@suse.cz>
  6.  *
  7.  * $Id: Progress.ycp 33164 2006-09-27 08:42:24Z jsrain $
  8.  *
  9.  * Functions for progress bar.<br>
  10.  * <pre>
  11.  * Dialog Title
  12.  *
  13.  * [x] Stage 1
  14.  * [x] Stage 2
  15.  *  => Stage 3
  16.  *  -  Stage 4
  17.  *  -  Stage 5
  18.  *
  19.  * Progress Title
  20.  * [============================90%=======================------]
  21.  *
  22.  * </pre>
  23.  * Example of progress bar usage (don't forget the translation marks in your code):
  24.  * Progress bar supposes main wizard dialog is created.<pre>
  25.  * Progress::Simple ("Some progress bar", "Progress runs here...", 3, "");
  26.  * Progress::NextStep (); // the 1st one does nothing!
  27.  * Progress::NextStep ();
  28.  * Progress::NextStep ();
  29.  * Progress::NextStep ();</pre>
  30.  *
  31.  * Another example:<pre>
  32.  * Progress::New ("Complex progress bar", " ", 100, [
  33.  *      "Stage1", "Stage2", "Stage3",
  34.  *      ], [
  35.  *      "Stage 1 ...", "Stage 2 ...", "Stage 3 ...", "Finished",
  36.  *      ], "Help text");
  37.  * Progress::NextStage ();
  38.  * Progress::NextStageStep (20);
  39.  * Progress::Stage (0, "I am back", 2);
  40.  * Progress::Title ("Still in stage 0");
  41.  * Progress::NextStageStep (90);
  42.  * Progress::Finish ();</pre>
  43.  *
  44.  * See also hand made documentation.
  45.  * <a href="../Progress.html">Progress.html</a>
  46.  */
  47.  
  48. {
  49.     module "Progress";
  50.  
  51.     textdomain "base";
  52.  
  53.     import "CommandLine";
  54.     import "Wizard";
  55.     import "Mode";
  56.  
  57.     // Number of stages.
  58.     integer stages = 0;
  59.     // Number of steps
  60.     integer steps = 0;
  61.     // Current stage
  62.     integer current_stage = 0;
  63.     // Current step
  64.     integer current_step = 0;
  65.     // list of stage-titles
  66.     list titles = [];
  67.  
  68.     // is progress bar used?
  69.     boolean visible = true;
  70.  
  71.     // superior progress (stages) bar
  72.     integer super_steps = 0;
  73.     integer super_step = 0;
  74.     list super_stages = [];
  75.  
  76.     /**
  77.      * Sets progress bar state:
  78.      * on = normal operation, off = All Progress:: calls return immediatelly.
  79.      * @param state on or off
  80.      * @return previous state
  81.      */
  82.     global define boolean set (boolean state) {
  83.     boolean prev = visible;
  84.     visible = state;
  85.     return prev;
  86.     }
  87.  
  88.     /**
  89.      * Returns currently selected visibility status of all UI-modifying Progress:: functions.
  90.      *
  91.      * @return boolean whether the progress bar is used
  92.      * @see Progress::set
  93.      * @see Progress::off
  94.      * @see Progress::on
  95.      */
  96.     global define boolean status () {
  97.     return visible;
  98.     }
  99.  
  100.     /**
  101.      * Turns progress bar off. All Progress:: calls return immediatelly.
  102.      * @deprecated set
  103.      */
  104.     global define void off () {
  105.     // no "deprecated" warning
  106.     // because it is ok to use this function in testsuites
  107.     visible = false;
  108.     }
  109.  
  110.     /**
  111.      * Turns progress bar on after calling Progress::off.
  112.      * @deprecated set
  113.      */
  114.     global define void on () {
  115.     y2warning (-1, "Deprecated function. Use Progress::set instead");
  116.     visible = true;
  117.     }
  118.  
  119.     /**
  120.      * @param kind `todo, `current or `done
  121.      * @return UI mark for stages
  122.      */
  123.     any Mark (symbol kind) {
  124.     if (kind == `todo)
  125.         return "-   ";
  126.     if (kind == `current)
  127.         return UI::Glyph (`BulletArrowRight);
  128.     if (kind == `done)
  129.         return UI::Glyph (`CheckMark);
  130.     return "?@%!";
  131.     }
  132.  
  133.     /**
  134.      * @param i stage number
  135.      * @return widget `id(...) for the marker
  136.      */
  137.     term MarkId (integer i) {
  138.     return `id (sformat ("mark_stage_%1",i));
  139.     }
  140.  
  141.     /**
  142.      * New complex progress bar with stages.
  143.      * @param window_title title of the window
  144.      * @param progress_title title of the progress bar. Pass at least " "
  145.      *                       (one space) if you want some progress bar title.
  146.      * @param length number of steps. If 0, no progress bar is created,
  147.      *               there are only stages and bottom title. THIS IS NOT
  148.      *               NUMBER OF STAGES!
  149.      * @param stg list of strings - stage names. If it is nil, then there
  150.      *            are no stages.
  151.      * @param tits Titles corresponding to stages. When stage changes,
  152.      *             progress bar title changes to one of these titles. May
  153.      *             be nil/empty.
  154.      * @param help_text help text
  155.      */
  156.     global define void New (string window_title, string progress_title, integer length, list<string> stg, list tits, string help_text) ``{
  157.     if (!visible)
  158.         return ;
  159.     steps = length;
  160.     stages = size (stg);
  161.     titles = tits;
  162.     current_step = -1;
  163.     current_stage = -1;
  164.     
  165.     if (Mode::commandline ())
  166.         return;
  167.  
  168.     if (progress_title == "")
  169.     {
  170.         // Reserve space for future progress bar labels. The ProgressBar
  171.         // widget will suppress the label above the progress bar if the
  172.         // initial label string is empty.
  173.         progress_title = " ";
  174.     }
  175.     term bar = `VBox( // progressbar only
  176.         `ProgressBar(`id(`pb),progress_title,length,0)
  177.         );
  178.     if (0 != stages)
  179.     { // version with stages
  180.         bar = `VBox (`VSpacing (1));
  181.         integer i = 0;
  182.         any label_heading = Mark (`todo);
  183.         foreach (string item, stg, ``{
  184.         bar = add (bar,
  185.               `HBox (
  186.                   `HSpacing (1),
  187.                   // check_ycp wants this text to be translatable. I do not know why.
  188.                   `Heading (MarkId (i), label_heading),
  189.                   `Label (`opt (`hstretch), item)
  190.                   )
  191.             );
  192.         i = i+1;
  193.         });
  194.         if (0 != steps)
  195.         {  // stages and progress
  196.         bar = add (bar, `VBox (
  197.             `VStretch (),
  198.             `ProgressBar (`id (`pb), progress_title, length, 0),
  199.             `VSpacing (2)
  200.             ));
  201.         }
  202.         else
  203.         {  // stages only
  204.         bar = add (bar, `VBox (
  205.             `VStretch (),
  206.             `Label (`id (`pb), `opt (`hstretch), progress_title),
  207.             `VSpacing (2)
  208.             ));
  209.         }
  210.     }
  211.     UI::ReplaceWidget (`id (`contents), bar);
  212.  
  213.         if (! UI::WizardCommand(`SetDialogHeading( window_title ) ) )
  214.         {
  215.             UI::ChangeWidget (`id (`title), `Value, window_title);
  216.         }
  217.     if ("" != help_text && nil != help_text)
  218.     {
  219.         Wizard::SetHelpText (help_text);
  220.     }
  221.     Wizard::DisableBackButton ();
  222.     Wizard::DisableNextButton ();
  223.     }
  224.  
  225.     /**
  226.      * Create simple progress bar with no stages, only with progress bar.
  227.      * @param window_title Title of the window.
  228.      * @param progress_title Title of the progress bar.
  229.      * @param length Number of steps.
  230.      * @param help_text Help text.
  231.      */
  232.     global define void Simple (string window_title, string progress_title, integer length, string help_text) ``{
  233.     New (window_title, progress_title, length, [], [], help_text);
  234.     }
  235.  
  236.     /**
  237.      * Uses current_step
  238.      */
  239.     void UpdateProgressBar () {
  240.     if (current_step > steps)
  241.     {
  242.         y2error (-2, "Progress bar has only %1 steps, not %2.", steps, current_step);
  243.         return ;
  244.     }
  245.     UI::ChangeWidget (`id (`pb), `Value, current_step);
  246.     }
  247.  
  248.     /**
  249.      * the bar is either `ProgressBar or `Label
  250.      * @param s title
  251.      */
  252.     void SetProgressBarTitle (string s) {
  253.     UI::ChangeWidget (`id (`pb), 0 == steps ? `Value : `Label, s);
  254.     }
  255.  
  256.     /**
  257.      * Some people say it is the best operating system ever. But now to the
  258.      * function. Advances progress bar value by 1.
  259.      */
  260.     global define void NextStep () ``{
  261.     if (!visible || Mode::commandline () || 0 == steps)
  262.         return ;
  263.     current_step = current_step + 1;
  264.     UpdateProgressBar ();
  265.     }
  266.  
  267.     /**
  268.      * Advance stage, advance step by 1 and set progress bar caption to
  269.      * that defined in New.
  270.      */
  271.     global define void NextStage () ``{
  272.     if (!visible)
  273.         return ;
  274.     NextStep ();
  275.  
  276.     if (0 == stages || current_stage > stages)
  277.     {
  278.         y2error ("Non-existing stage requested.");
  279.         return ;
  280.     }
  281.  
  282.     current_stage = current_stage + 1;
  283.  
  284.     if ( Mode::commandline ()) 
  285.     {
  286.         if (current_stage < stages && current_stage < size (titles))
  287.         {
  288.         CommandLine::PrintVerbose(titles[current_stage]:"");
  289.         }
  290.         return;
  291.     }
  292.     
  293.     if (current_stage > 0)
  294.     {
  295.         UI::ChangeWidget (MarkId (current_stage-1), `Value, Mark (`done));
  296.     }
  297.     // we may be past the last stage
  298.     if (current_stage < stages )
  299.     {
  300.         if (current_stage < size (titles))
  301.         {
  302.         SetProgressBarTitle (titles[current_stage]:"");
  303.         }
  304.         UI::ChangeWidget (MarkId (current_stage), `Value, Mark (`current));
  305.     }
  306.     }
  307.     /**
  308.      * Changes progress bar value to st.
  309.      * @param st new value
  310.      */
  311.     global define void Step (integer st) ``{
  312.     if (!visible || Mode::commandline () || 0 == steps)
  313.         return ;
  314.     current_step = st;
  315.     UpdateProgressBar ();
  316.     }
  317.  
  318.     /**
  319.      * Go to stage st, change progress bar title to title and set progress
  320.      * bar step to step.
  321.      * @param st New stage.
  322.      * @param title New title for progress bar. If nil, title specified in
  323.      *              New is used.
  324.      * @param step New step or -1 if step should not change.
  325.      */
  326.     global define void Stage (integer st, string title, integer step) ``{
  327.     if (!visible)
  328.         return ;
  329.     if (-1 != step)
  330.     {
  331.         Step (step);
  332.     }
  333.     if (!Mode::commandline () && current_stage >= 0)
  334.     {
  335.         UI::ChangeWidget(MarkId (current_stage), `Value,
  336.                  Mark (st > current_stage ? `done: `todo));
  337.     }
  338.     current_stage = st;
  339.     string s = "";
  340.     if (current_stage < size (titles))
  341.     {
  342.         s = titles[current_stage]:"";
  343.     }
  344.     if (nil != title)
  345.     {
  346.         s = title;
  347.     }
  348.     if (current_stage < size (titles))
  349.     {
  350.         if (Mode::commandline ())
  351.         {
  352.         CommandLine::PrintVerbose (s);
  353.         return;
  354.         }
  355.         else
  356.         {
  357.         SetProgressBarTitle (s);
  358.         }
  359.     }
  360.     if (current_stage < stages)
  361.     {
  362.         UI::ChangeWidget(MarkId (current_stage), `Value, Mark (`current));
  363.     }
  364.     }
  365.  
  366.  
  367.     /**
  368.      * Jumps to the next stage and sets step to st.
  369.      * @param st new progress bar value
  370.      */
  371.     global define void NextStageStep (integer st) ``{
  372.     if (!visible || Mode::commandline ())
  373.         return ;
  374.     NextStage ();
  375.     Step (st);
  376.     }
  377.  
  378.     /**
  379.      * Change progress bar title.
  380.      * @param t new title. Use ""(empty string) if you want an empty progress bar.
  381.      */
  382.     global define void Title (string t) ``{
  383.     if (visible && ! Mode::commandline ())
  384.         SetProgressBarTitle (t);
  385.     }
  386.     /**
  387.      * Moves progress bar to the end and marks all stages as completed.
  388.      */
  389.     global define void Finish () ``{
  390.     if (!visible || Mode::commandline ())
  391.         return ;
  392.     if (0 != stages)
  393.     {
  394.         while (current_stage < stages)
  395.         NextStage ();
  396.     }
  397.     if (0 != steps)
  398.     {
  399.         current_step = steps;
  400.         UpdateProgressBar ();
  401.     }
  402.     SetProgressBarTitle (" ");
  403.     }
  404.  
  405.     /**
  406.      * Creates a higher-level progress bar made of stages. Currently it is
  407.      * placed instead of help text.
  408.      * @param title title of the progress...
  409.      * @param stages list of stage descriptions
  410.      */
  411.     global define void OpenSuperior (string title, list<string> stages)
  412.     {
  413.     if (UI::HasSpecialWidget(`Wizard))
  414.     {
  415.         Wizard::OpenAcceptAbortStepsDialog();
  416.         UI::WizardCommand(`AddStepHeading(title));
  417.  
  418.         integer idx = 0;
  419.         super_steps = size (stages);
  420.         super_step = -1;
  421.         foreach (string s, stages,
  422.         {
  423.         string id = sformat ("super_progress_%1", idx);
  424.         UI::WizardCommand (`AddStep (s, id));
  425.  
  426.         });
  427.         UI::WizardCommand(`UpdateSteps() );
  428.     }
  429.     else                        // old behaviour
  430.     {
  431.         term left = `VBox (`VStretch ());
  432.         term right = `VBox (`VStretch ());
  433.         integer idx = 0;
  434.         super_steps = size (stages);
  435.         super_step = -1;
  436.         foreach (string i, stages,
  437.         {
  438.         string id = sformat ("super_progress_%1", idx);
  439.         left = add (left, `Heading (`id (id), "-  "));
  440.         right = add (right, `Label (`opt (`hstretch), i));
  441.         left = add (left, `VStretch ());
  442.         right = add (right, `VStretch ());
  443.         idx = idx + 1;
  444.         });
  445.         left = add (left, `HSpacing (4));
  446.         right = add (right, `HStretch ());
  447.         Wizard::ReplaceHelp (`VBox (
  448.             `HBox (
  449.             `HSpacing (1),
  450.             `Frame (
  451.                 title,
  452.                 `HBox (`HSpacing (1), left, right)
  453.                 )
  454.             ),
  455.             `VSpacing (0.5)
  456.             )
  457.         );
  458.     }
  459.     }
  460.     /**
  461.      * Replaces stages of superior progress by an empty help text.
  462.      */
  463.     global define void CloseSuperior () ``{
  464.     if (UI::HasSpecialWidget(`Wizard))
  465.     {
  466.         UI::CloseDialog();
  467.     }
  468.     else
  469.     {
  470.         Wizard::RestoreHelp ("");
  471.     }
  472.     super_steps = 0;
  473.     super_step = 0;
  474.     }
  475.     /**
  476.      * Make one step in a superior progress bar.
  477.      */
  478.     global define void StepSuperior () ``{
  479.     if (super_step >= 0 && super_step < super_steps)
  480.     {
  481.         if (!UI::HasSpecialWidget(`Wizard))
  482.         {
  483.         UI::ChangeWidget (`id (sformat ("super_progress_%1", super_step)), `Value, UI::Glyph (`CheckMark));
  484.         }
  485.     }
  486.     super_step = super_step + 1;
  487.     if (super_step >= super_steps)
  488.     {
  489.         return;
  490.     }
  491.     if (UI::HasSpecialWidget(`Wizard))
  492.     {
  493.         UI::WizardCommand (`SetCurrentStep (sformat ("super_progress_%1", super_step)));
  494.     }
  495.     else
  496.     {
  497.         UI::ChangeWidget (`id (sformat ("super_progress_%1", super_step)), `Value, UI::Glyph (`BulletArrowRight));
  498.     }
  499.     }
  500.  
  501. /* EOF */
  502. }
  503.