home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / HTML / Progress.php < prev    next >
Encoding:
PHP Script  |  2004-03-24  |  46.4 KB  |  1,340 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PHP Version 4                                                        |
  4. // +----------------------------------------------------------------------+
  5. // | Copyright (c) 1997-2003 The PHP Group                                |
  6. // +----------------------------------------------------------------------+
  7. // | This source file is subject to version 3.0 of the PHP license,       |
  8. // | that is bundled with this package in the file LICENSE, and is        |
  9. // | available at through the world-wide-web at                           |
  10. // | http://www.php.net/license/3_0.txt.                                  |
  11. // | If you did not receive a copy of the PHP license and are unable to   |
  12. // | obtain it through the world-wide-web, please send a note to          |
  13. // | license@php.net so we can mail you a copy immediately.               |
  14. // +----------------------------------------------------------------------+
  15. // | Author: Laurent Laville <pear@laurent-laville.org>                   |
  16. // +----------------------------------------------------------------------+
  17. //
  18. // $Id: Progress.php,v 1.4 2004/02/13 15:34:45 farell Exp $
  19.  
  20. /**
  21.  * The HTML_Progress class allow you to add a loading bar
  22.  * to any of your xhtml document.
  23.  * You should have a browser that accept DHTML feature.
  24.  *
  25.  * @version    1.1
  26.  * @author     Laurent Laville <pear@laurent-laville.org>
  27.  * @access     public
  28.  * @category   HTML
  29.  * @package    HTML_Progress
  30.  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
  31.  * @tutorial   HTML_Progress.pkg
  32.  * @todo       add new progress shapes such as square, rectangle, circle.
  33.  */
  34.  
  35. require_once ('HTML/Progress/Error/Raise.php');
  36. require_once ('HTML/Progress/DM.php');
  37. require_once ('HTML/Progress/UI.php');
  38.  
  39. /**#@+
  40.  * Progress Bar shape types
  41.  *
  42.  * @var        integer
  43.  * @since      0.6
  44.  */
  45. define ('HTML_PROGRESS_BAR_HORIZONTAL', 1);
  46. define ('HTML_PROGRESS_BAR_VERTICAL',   2);
  47. /**#@-*/
  48.  
  49. /**
  50.  * Basic error code that indicate a wrong input
  51.  *
  52.  * @var        integer
  53.  * @since      1.0
  54.  */
  55. define ('HTML_PROGRESS_ERROR_INVALID_INPUT',   -100);
  56.  
  57. /**
  58.  * Basic error code that indicate a wrong callback definition.
  59.  * Allows only function or class-method structure. 
  60.  *
  61.  * @var        integer
  62.  * @since      1.1
  63.  */
  64. define ('HTML_PROGRESS_ERROR_INVALID_CALLBACK',-101);
  65.  
  66.  
  67. class HTML_Progress
  68. {
  69.     /**
  70.      * Whether the progress bar is in determinate or indeterminate mode.
  71.      * The default is false.
  72.      * An indeterminate progress bar continuously displays animation indicating
  73.      * that an operation of unknown length is occuring.
  74.      *
  75.      * @var        boolean
  76.      * @since      1.0
  77.      * @access     private
  78.      * @see        setIndeterminate(), isIndeterminate()
  79.      */
  80.     var $_indeterminate;
  81.  
  82.     /**
  83.      * Whether to display a border around the progress bar.
  84.      * The default is false.
  85.      *
  86.      * @var        boolean
  87.      * @since      1.0
  88.      * @access     private
  89.      * @see        setBorderPainted(), isBorderPainted()
  90.      */
  91.     var $_paintBorder;
  92.  
  93.     /**
  94.      * Whether to textually display a string on the progress bar.
  95.      * The default is false.
  96.      * Setting this to true causes a textual display of the progress to be rendered 
  97.      * on the progress bar. If the $_progressString is null, the percentage of completion
  98.      * is displayed on the progress bar. Otherwise, the $_progressString is rendered
  99.      * on the progress bar.
  100.      *
  101.      * @var        boolean
  102.      * @since      1.0
  103.      * @access     private
  104.      * @see        setStringPainted(), isStringPainted()
  105.      */
  106.     var $_paintString;
  107.  
  108.     /**
  109.      * An optional string that can be displayed on the progress bar.
  110.      * The default is null.
  111.      * Setting this to a non-null value does not imply that the string 
  112.      * will be displayed.
  113.      *
  114.      * @var        string
  115.      * @since      1.0
  116.      * @access     private
  117.      * @see        getString(), setString()
  118.      */
  119.     var $_progressString;
  120.  
  121.     /**
  122.      * The data model (HTML_Progress_DM instance or extends) 
  123.      * handles any mathematical issues arising from assigning faulty values.
  124.      *
  125.      * @var        object
  126.      * @since      1.0
  127.      * @access     private
  128.      * @see        getDM(), setDM()
  129.      */
  130.     var $_DM;
  131.  
  132.     /**
  133.      * The user interface (HTML_Progress_UI instance or extends)
  134.      * handles look-and-feel of the progress bar.
  135.      *
  136.      * @var        object
  137.      * @since      1.0
  138.      * @access     private
  139.      * @see        getUI(), setUI()
  140.      */
  141.     var $_UI;
  142.  
  143.     /**
  144.      * The label that uniquely identifies this progress object.
  145.      *
  146.      * @var        string
  147.      * @since      1.0
  148.      * @access     private
  149.      * @see        getIdent(), setIdent()
  150.      */
  151.     var $_ident;
  152.  
  153.     /**
  154.      * Holds all HTML_Progress_Observer objects that wish to be notified of new messages.
  155.      *
  156.      * @var        array
  157.      * @since      1.0
  158.      * @access     private
  159.      * @see        getListeners(), addListener(), removeListener()
  160.      */
  161.     var $_listeners;
  162.  
  163.     /**
  164.      * Package name used by Error_Raise functions
  165.      *
  166.      * @var        string
  167.      * @since      1.0
  168.      * @access     private
  169.      */
  170.     var $_package;
  171.  
  172.     /**
  173.      * Delay in milisecond before each progress cells display.
  174.      * 1000 ms === sleep(1)
  175.      * <strong>usleep()</strong> function does not run on Windows platform.
  176.      *
  177.      * @var        integer
  178.      * @since      1.1
  179.      * @access     private
  180.      * @see        setAnimSpeed()
  181.      */
  182.     var $_anim_speed = 0;
  183.  
  184.  
  185.     /**
  186.      * Constructor Summary
  187.      *
  188.      * o Creates a natural horizontal progress bar that displays ten cells/units
  189.      *   with no border and no progress string.
  190.      *   The initial and minimum values are 0, and the maximum is 100.
  191.      *   <code>
  192.      *   $bar = new HTML_Progress();
  193.      *   </code>
  194.      *
  195.      * o Creates a natural progress bar with the specified orientation, which can be
  196.      *   either HTML_PROGRESS_BAR_HORIZONTAL or HTML_PROGRESS_BAR_VERTICAL
  197.      *   By default, no border and no progress string are painted.
  198.      *   The initial and minimum values are 0, and the maximum is 100.
  199.      *   <code>
  200.      *   $bar = new HTML_Progress($orient);
  201.      *   </code>
  202.      *
  203.      * o Creates a natural horizontal progress bar with the specified minimum and
  204.      *   maximum. Sets the initial value of the progress bar to the specified
  205.      *   minimum, and the maximum that the progress bar can reach.
  206.      *   By default, no border and no progress string are painted.
  207.      *   <code>
  208.      *   $bar = new HTML_Progress($min, $max);
  209.      *   </code>
  210.      *
  211.      * o Creates a natural horizontal progress bar with the specified orientation, 
  212.      *   minimum and maximum. Sets the initial value of the progress bar to the 
  213.      *   specified minimum, and the maximum that the progress bar can reach.
  214.      *   By default, no border and no progress string are painted.
  215.      *   <code>
  216.      *   $bar = new HTML_Progress($orient, $min, $max);
  217.      *   </code>
  218.      *
  219.      * o Creates a natural horizontal progress that uses the specified model
  220.      *   to hold the progress bar's data.
  221.      *   By default, no border and no progress string are painted.
  222.      *   <code>
  223.      *   $bar = new HTML_Progress($model);
  224.      *   </code>
  225.      *
  226.      *
  227.      * @param      object    $model         Model that hold the progress bar's data
  228.      * @param      int       $orient        Orientation of progress bar
  229.      * @param      int       $min           Minimum value of progress bar
  230.      * @param      int       $max           Maximum value of progress bar
  231.      *
  232.      * @since      1.0
  233.      * @access     public
  234.      * @throws     HTML_PROGRESS_ERROR_INVALID_INPUT
  235.      * @see        setIndeterminate(), 
  236.      *             setBorderPainted(), setStringPainted(), setString(),
  237.      *             setDM(), setUI(), setIdent()
  238.      */
  239.     function HTML_Progress()
  240.     {
  241.         $this->_package = 'HTML_Progress';
  242.         Error_Raise::initialize($this->_package, array(get_class($this), '_getErrorMessage'));
  243.  
  244.         $this->_listeners = array();          // none listeners by default
  245.  
  246.         $this->_DM = new HTML_Progress_DM();  // new instance of a progress DataModel
  247.         $this->_UI = new HTML_Progress_UI();  // new instance of a progress UserInterface
  248.  
  249.         $args = func_get_args();
  250.  
  251.         switch (count($args)) {
  252.          case 1:
  253.             if (is_object($args[0]) && (is_a($args[0], 'html_progress_dm'))) {
  254.                 /*   object html_progress_dm extends   */
  255.                 $this->_DM = &$args[0];
  256.                 
  257.             } elseif (is_int($args[0])) {
  258.                 /*   int orient   */
  259.                 $this->_UI->setOrientation($args[0]);
  260.  
  261.             } else {
  262.                 return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  263.                     array('var' => '$model | $orient',
  264.                           'was' => (gettype($args[0]) == 'object') ? 
  265.                                     get_class($args[0]).' object' : gettype($args[0]),
  266.                           'expected' => 'html_progress_dm object | integer',
  267.                           'paramnum' => 1), PEAR_ERROR_TRIGGER);
  268.             }
  269.             break;
  270.          case 2:
  271.             /*   int min, int max   */
  272.             if (!is_int($args[0])) {
  273.                 return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  274.                     array('var' => '$min',
  275.                           'was' => $args[0],
  276.                           'expected' => 'integer',
  277.                           'paramnum' => 1), PEAR_ERROR_TRIGGER);
  278.  
  279.             } elseif (!is_int($args[1])) {
  280.                 return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  281.                     array('var' => '$max',
  282.                           'was' => $args[1],
  283.                           'expected' => 'integer',
  284.                           'paramnum' => 2), PEAR_ERROR_TRIGGER);
  285.             } else {
  286.                 $this->_DM->setMinimum($args[0]);
  287.                 $this->_DM->setMaximum($args[1]);
  288.             } 
  289.             break;
  290.          case 3:
  291.             /*   int orient, int min, int max   */
  292.             if (!is_int($args[0])) {
  293.                 return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  294.                     array('var' => '$orient',
  295.                           'was' => $args[0],
  296.                           'expected' => 'integer',
  297.                           'paramnum' => 1), PEAR_ERROR_TRIGGER);
  298.  
  299.             } elseif (!is_int($args[1])) {
  300.                 return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  301.                     array('var' => '$min',
  302.                           'was' => $args[1],
  303.                           'expected' => 'integer',
  304.                           'paramnum' => 2), PEAR_ERROR_TRIGGER);
  305.  
  306.             } elseif (!is_int($args[2])) {
  307.                 return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  308.                     array('var' => '$max',
  309.                           'was' => $args[2],
  310.                           'expected' => 'integer',
  311.                           'paramnum' => 3), PEAR_ERROR_TRIGGER);
  312.             } else {
  313.                 $this->_UI->setOrientation($args[0]);
  314.                 $this->_DM->setMinimum($args[1]);
  315.                 $this->_DM->setMaximum($args[2]);
  316.             }
  317.             break;
  318.          default:
  319.         }
  320.         $this->setString(null);
  321.         $this->setStringPainted(false);
  322.         $this->setBorderPainted(false);
  323.         $this->setIndeterminate(false);
  324.         $this->setIdent();
  325.  
  326.         // to fix a potential php config problem with PHP 4.2.0 : turn 'implicit_flush' ON
  327.         ob_implicit_flush(1);
  328.     }
  329.  
  330.     /**
  331.      * Returns the current API version
  332.      *
  333.      * @return     float
  334.      * @since      0.1
  335.      * @access     public
  336.      */
  337.     function apiVersion()
  338.     {
  339.         return 1.1;
  340.     }
  341.  
  342.     /**
  343.      * Returns mode of the progress bar (determinate or not).
  344.      *
  345.      * @return     boolean
  346.      * @since      1.0
  347.      * @access     public
  348.      * @see        setIndeterminate()
  349.      * @tutorial   indeterminate.pkg
  350.      */
  351.     function isIndeterminate()
  352.     {
  353.         return $this->_indeterminate;
  354.     }
  355.  
  356.     /**
  357.      * Sets the $_indeterminate property of the progress bar, which determines
  358.      * whether the progress bar is in determinate or indeterminate mode.
  359.      * An indeterminate progress bar continuously displays animation indicating
  360.      * that an operation of unknown length is occuring.
  361.      * By default, this property is false.
  362.      *
  363.      * @param      boolean   $continuous    whether countinuously displays animation
  364.      *
  365.      * @return     void
  366.      * @since      1.0
  367.      * @access     public
  368.      * @throws     HTML_PROGRESS_ERROR_INVALID_INPUT
  369.      * @see        isIndeterminate()
  370.      * @tutorial   indeterminate.pkg
  371.      * @example    indeterminate.php        Horizontal ProgressBar in indeterminate mode
  372.      */
  373.     function setIndeterminate($continuous)
  374.     {
  375.         if (!is_bool($continuous)) {
  376.             Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  377.                 array('var' => '$continuous',
  378.                       'was' => gettype($continuous),
  379.                       'expected' => 'boolean',
  380.                       'paramnum' => 1), PEAR_ERROR_TRIGGER);
  381.         }
  382.         $this->_indeterminate = $continuous;
  383.     }
  384.  
  385.     /**
  386.      * Does the progress bar should paint its border. The default is false.
  387.      *
  388.      * @return     boolean
  389.      * @since      1.0
  390.      * @access     public
  391.      * @see        setBorderPainted()
  392.      */
  393.     function isBorderPainted()
  394.     {
  395.         return $this->_paintBorder;
  396.     }
  397.  
  398.     /**
  399.      * Sets the value of $_paintBorder property, which determines whether the
  400.      * progress bar should paint its border. The default is false. 
  401.      *
  402.      * @param      boolean   $paint         whether the progress bar should paint its border
  403.      *
  404.      * @return     void
  405.      * @since      1.0
  406.      * @access     public
  407.      * @throws     HTML_PROGRESS_ERROR_INVALID_INPUT
  408.      * @see        isBorderPainted()
  409.      * @tutorial   beginner.pkg#look-and-feel.border-style
  410.      * @example    bluesand.php             A thin solid border to a horizontal progress bar
  411.      */
  412.     function setBorderPainted($paint)
  413.     {
  414.         if (!is_bool($paint)) {
  415.             Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  416.                 array('var' => '$paint',
  417.                       'was' => gettype($paint),
  418.                       'expected' => 'boolean',
  419.                       'paramnum' => 1), PEAR_ERROR_TRIGGER);
  420.         }
  421.  
  422.         $this->_paintBorder = $paint;
  423.     }
  424.  
  425.     /**
  426.      * Does the progress bar should render a progress string. The default is false.
  427.      * The progress bar displays the value returned by getPercentComplete() method
  428.      * formatted as a percent such as 33%.
  429.      *
  430.      * @return     boolean
  431.      * @since      1.0
  432.      * @access     public
  433.      * @see        setStringPainted(), setString()
  434.      */
  435.     function isStringPainted()
  436.     {
  437.         return $this->_paintString;
  438.     }
  439.  
  440.     /**
  441.      * Sets the value of $_paintString property, which determines whether the
  442.      * progress bar should render a progress string. The default is false.
  443.      *
  444.      * @param      boolean   $paint         whether the progress bar should render a string
  445.      *
  446.      * @return     void
  447.      * @since      1.0
  448.      * @access     public
  449.      * @throws     HTML_PROGRESS_ERROR_INVALID_INPUT
  450.      * @see        isStringPainted(), setString()
  451.      * @tutorial   beginner.pkg#look-and-feel.string-style
  452.      */
  453.     function setStringPainted($paint)
  454.     {
  455.         if (!is_bool($paint)) {
  456.             Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  457.                 array('var' => '$paint',
  458.                       'was' => gettype($paint),
  459.                       'expected' => 'boolean',
  460.                       'paramnum' => 1), PEAR_ERROR_TRIGGER);
  461.         }
  462.         $this->_paintString = $paint;
  463.     }
  464.  
  465.     /**
  466.      * Returns the current value of the progress string.
  467.      * By default, the progress bar displays the value returned by 
  468.      * getPercentComplete() method formatted as a percent such as 33%.
  469.      *
  470.      * @return     string
  471.      * @since      1.0
  472.      * @access     public
  473.      * @see        setString()
  474.      */
  475.     function getString()
  476.     {
  477.         if ($this->isStringPainted() && !is_null($this->_progressString)) {
  478.             return $this->_progressString;
  479.         } else {
  480.             return sprintf("%s", $this->getPercentComplete()*100).' %';
  481.     }
  482.     }
  483.  
  484.     /**
  485.      * Sets the current value of the progress string. By default, this string
  486.      * is null. If you have provided a custom progress string and want to revert
  487.      * to the built-in-behavior, set the string back to null.
  488.      * The progress string is painted only if the isStringPainted() method
  489.      * returns true.
  490.      *
  491.      * @param      string    $str           progress string
  492.      *
  493.      * @return     void
  494.      * @since      1.0
  495.      * @access     public
  496.      * @see        getString(), isStringPainted(), setStringPainted()
  497.      * @tutorial   beginner.pkg#look-and-feel.string-style
  498.      * @example    horizontal_string.php    A custom string with percent progress info
  499.      */
  500.     function setString($str)
  501.     {
  502.         $this->_progressString = $str;
  503.     }
  504.  
  505.     /**
  506.      * Returns the data model used by this progress bar.
  507.      *
  508.      * @return     object
  509.      * @since      1.0
  510.      * @access     public
  511.      * @see        setDM()
  512.      */
  513.     function &getDM()
  514.     {
  515.         return $this->_DM;
  516.     }
  517.  
  518.     /**
  519.      * Sets the data model used by this progress bar.
  520.      *
  521.      * @param      string    $model         class name of a html_progress_dm extends object
  522.      *
  523.      * @return     void
  524.      * @since      1.0
  525.      * @access     public
  526.      * @throws     HTML_PROGRESS_ERROR_INVALID_INPUT
  527.      * @see        getDM()
  528.      */
  529.     function setDM($model)
  530.     {
  531.         if (!class_exists($model)) {
  532.             return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  533.                 array('var' => '$model',
  534.                       'was' => 'class does not exists',
  535.                       'expected' => $model.' class defined',
  536.                       'paramnum' => 1), PEAR_ERROR_TRIGGER);
  537.         }
  538.  
  539.         $_dm = new $model();
  540.  
  541.         if (!is_a($_dm, 'html_progress_dm')) {
  542.             return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'error',
  543.                 array('var' => '$model',
  544.                       'was' => $model,
  545.                       'expected' => 'HTML_Progress_DM extends',
  546.                       'paramnum' => 1), PEAR_ERROR_TRIGGER);
  547.         }
  548.         $this->_DM =& $_dm;
  549.     }
  550.  
  551.     /**
  552.      * Returns the progress bar's minimum value stored in the progress bar's data model.
  553.      * The default value is 0.
  554.      *
  555.      * @return     integer
  556.      * @since      1.0
  557.      * @access     public
  558.      * @see        setMinimum(),
  559.      *             HTML_Progress_DM::getMinimum()
  560.      */
  561.     function getMinimum()
  562.     {
  563.         return $this->_DM->getMinimum();
  564.     }
  565.  
  566.     /**
  567.      * Sets the progress bar's minimum value stored in the progress bar's data model.
  568.      * If the minimum value is different from previous minimum, all change listeners
  569.      * are notified.
  570.      *
  571.      * @param      integer   $min           progress bar's minimal value
  572.      *
  573.      * @return     void
  574.      * @since      1.0
  575.      * @access     public
  576.      * @see        getMinimum(),
  577.      *             HTML_Progress_DM::setMinimum()
  578.      */
  579.     function setMinimum($min)
  580.     {
  581.         $oldVal = $this->getMinimum();
  582.  
  583.         $this->_DM->setMinimum($min);
  584.  
  585.         if ($oldVal != $min) {
  586.             $this->_announce(array('log' => 'setMinimum', 'value' => $min));
  587.         }
  588.     }
  589.  
  590.     /**
  591.      * Returns the progress bar's maximum value stored in the progress bar's data model.
  592.      * The default value is 100.
  593.      *
  594.      * @return     integer
  595.      * @since      1.0
  596.      * @access     public
  597.      * @see        setMaximum(),
  598.      *             HTML_Progress_DM::getMaximum()
  599.      */
  600.     function getMaximum()
  601.     {
  602.         return $this->_DM->getMaximum();
  603.     }
  604.  
  605.     /**
  606.      * Sets the progress bar's maximum value stored in the progress bar's data model.
  607.      * If the maximum value is different from previous maximum, all change listeners
  608.      * are notified.
  609.      *
  610.      * @param      integer   $max           progress bar's maximal value
  611.      *
  612.      * @return     void
  613.      * @since      1.0
  614.      * @access     public
  615.      * @see        getMaximum(),
  616.      *             HTML_Progress_DM::setMaximum()
  617.      */
  618.     function setMaximum($max)
  619.     {
  620.         $oldVal = $this->getMaximum();
  621.  
  622.         $this->_DM->setMaximum($max);
  623.  
  624.         if ($oldVal != $max) {
  625.             $this->_announce(array('log' => 'setMaximum', 'value' => $max));
  626.         }
  627.     }
  628.  
  629.     /**
  630.      * Returns the progress bar's increment value stored in the progress bar's data model.
  631.      * The default value is +1.
  632.      *
  633.      * @return     integer
  634.      * @since      1.0
  635.      * @access     public
  636.      * @see        setIncrement(),
  637.      *             HTML_Progress_DM::getIncrement()
  638.      */
  639.     function getIncrement()
  640.     {
  641.         return $this->_DM->getIncrement();
  642.     }
  643.  
  644.     /**
  645.      * Sets the progress bar's increment value stored in the progress bar's data model.
  646.      *
  647.      * @param      integer   $inc           progress bar's increment value
  648.      *
  649.      * @return     void
  650.      * @since      1.0
  651.      * @access     public
  652.      * @see        getIncrement(),
  653.      *             HTML_Progress_DM::setIncrement()
  654.      */
  655.     function setIncrement($inc)
  656.     {
  657.         $this->_DM->setIncrement($inc);
  658.     }
  659.  
  660.     /**
  661.      * Returns the progress bar's current value, which is stored in the 
  662.      * progress bar's data model. The value is always between the minimum
  663.      * and maximum values, inclusive.
  664.      * By default, the value is initialized to be equal to the minimum value.
  665.      *
  666.      * @return     integer
  667.      * @since      1.0
  668.      * @access     public
  669.      * @see        setValue(), incValue(),
  670.      *             HTML_Progress_DM::getValue()
  671.      */
  672.     function getValue()
  673.     {
  674.         return $this->_DM->getValue();
  675.     }
  676.  
  677.     /**
  678.      * Sets the progress bar's current value stored in the progress bar's data model.
  679.      * If the new value is different from previous value, all change listeners
  680.      * are notified.
  681.      *
  682.      * @param      integer   $val           progress bar's current value
  683.      *
  684.      * @return     void
  685.      * @since      1.0
  686.      * @access     public
  687.      * @see        getValue(), incValue(),
  688.      *             HTML_Progress_DM::setValue()
  689.      */
  690.     function setValue($val)
  691.     {
  692.         $oldVal = $this->getValue();
  693.  
  694.         $this->_DM->setValue($val);
  695.  
  696.         if ($oldVal != $val) {
  697.             $this->_announce(array('log' => 'setValue', 'value' => $val));
  698.         }
  699.     }
  700.  
  701.     /**
  702.      * Updates the progress bar's current value by adding increment value.
  703.      * All change listeners are notified.
  704.      *
  705.      * @return     void
  706.      * @since      1.0
  707.      * @access     public
  708.      * @see        getValue(), setValue(),
  709.      *             HTML_Progress_DM::incValue()
  710.      */
  711.     function incValue()
  712.     {
  713.         $this->_DM->incValue();
  714.         $this->_announce(array('log' => 'incValue', 'value' => $this->_DM->getValue() ));
  715.     }
  716.  
  717.     /**
  718.      * Returns the percent complete for the progress bar. Note that this number is
  719.      * between 0.00 and 1.00.
  720.      *
  721.      * @return     float
  722.      * @since      1.0
  723.      * @access     public
  724.      * @see        getValue(), getMaximum(),
  725.      *             HTML_Progress_DM::getPercentComplete()
  726.      */
  727.     function getPercentComplete()
  728.     {
  729.         return $this->_DM->getPercentComplete();
  730.     }
  731.  
  732.     /**
  733.      * Returns the look-and-feel object that renders the progress bar.
  734.      *
  735.      * @return     object
  736.      * @since      1.0
  737.      * @access     public
  738.      * @see        setUI()
  739.      */
  740.     function &getUI()
  741.     {
  742.         return $this->_UI;
  743.     }
  744.  
  745.     /**
  746.      * Sets the look-and-feel object that renders the progress bar.
  747.      *
  748.      * @param      string    $ui            class name of a html_progress_ui extends object
  749.      *
  750.      * @return     void
  751.      * @since      1.0
  752.      * @access     public
  753.      * @throws     HTML_PROGRESS_ERROR_INVALID_INPUT
  754.      * @see        getUI()
  755.      */
  756.     function setUI($ui)
  757.     {
  758.         if (!class_exists($ui)) {
  759.             return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'error',
  760.                 array('var' => '$ui',
  761.                       'was' => 'class does not exists',
  762.                       'expected' => $ui.' class defined',
  763.                       'paramnum' => 1), PEAR_ERROR_TRIGGER);
  764.         }
  765.         
  766.         $_ui = new $ui();
  767.  
  768.         if (!is_a($_ui, 'html_progress_ui')) {
  769.             return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'error',
  770.                 array('var' => '$ui',
  771.                       'was' => $ui,
  772.                       'expected' => 'HTML_Progress_UI extends',
  773.                       'paramnum' => 1), PEAR_ERROR_TRIGGER);
  774.         }
  775.         $this->_UI =& $_ui;
  776.     }
  777.  
  778.     /**
  779.      * Sets the look-and-feel model that renders the progress bar.
  780.      *
  781.      * @param      string    $file          file name of model properties
  782.      * @param      string    $type          type of external ressource (phpArray, iniFile, XML ...)
  783.      *
  784.      * @return     void
  785.      * @since      1.0
  786.      * @access     public
  787.      * @see        setUI()
  788.      */
  789.     function setModel($file, $type)
  790.     {
  791.         include_once ('HTML/Progress/model.php');
  792.  
  793.         $this->_UI = new HTML_Progress_Model($file, $type);
  794.     }
  795.  
  796.     /**
  797.      * Set the sleep delay in milisecond before each progress cells display.
  798.      *
  799.      * @param      integer   $delay         Delay in milisecond.
  800.      *
  801.      * @return     void
  802.      * @since      1.1
  803.      * @access     public
  804.      * @throws     HTML_PROGRESS_ERROR_INVALID_INPUT
  805.      */
  806.     function setAnimSpeed($delay)
  807.     {
  808.         if (!is_int($delay)) {
  809.             return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'exception',
  810.                 array('var' => '$delay',
  811.                       'was' => gettype($delay),
  812.                       'expected' => 'integer',
  813.                       'paramnum' => 1), PEAR_ERROR_TRIGGER);
  814.  
  815.         } elseif ($delay < 0) {
  816.             return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'error',
  817.                 array('var' => '$delay',
  818.                       'was' => $delay,
  819.                       'expected' => 'greater than zero',
  820.                       'paramnum' => 1), PEAR_ERROR_TRIGGER);
  821.  
  822.         } elseif ($delay > 1000) {
  823.             return Error_Raise::raise($this->_package, HTML_PROGRESS_ERROR_INVALID_INPUT, 'error',
  824.                 array('var' => '$delay',
  825.                       'was' => $delay,
  826.                       'expected' => 'less or equal 1000',
  827.                       'paramnum' => 1), PEAR_ERROR_TRIGGER);
  828.         }
  829.         $this->_anim_speed = $delay;
  830.     }
  831.  
  832.     /**
  833.      * Get the cascading style sheet to put inline on HTML document
  834.      *
  835.      * @return     string
  836.      * @since      1.0
  837.      * @access     public
  838.      * @see        HTML_Progress_UI::getStyle()
  839.      */
  840.     function getStyle()
  841.     {
  842.         $ui = $this->getUI();
  843.         $lnEnd = $ui->_getLineEnd();
  844.         
  845.         $css =& $ui->getStyle();
  846.         $style = $css->toString();
  847.         $style = preg_replace("/".$lnEnd."\./", ".".$this->getIdent()." .", $style);
  848.  
  849.         return $style;
  850.     }
  851.  
  852.     /**
  853.      * Get the javascript code to manage progress bar.
  854.      *
  855.      * @return     string                   JavaScript URL or inline code to manage progress bar
  856.      * @since      1.0
  857.      * @access     public
  858.      * @see        HTML_Progress_UI::getScript()
  859.      */
  860.     function getScript()
  861.     {
  862.         $ui = $this->getUI();
  863.         $js =& $ui->getScript();
  864.         return $js;
  865.     }
  866.  
  867.     /**
  868.      * Returns the progress bar structure in an array.
  869.      *
  870.      * @return     array of progress bar properties
  871.      * @since      1.0
  872.      * @access     public
  873.      */
  874.     function toArray()
  875.     {
  876.         $ui =& $this->getUI();
  877.         $dm =& $this->getDM(); 
  878.  
  879.         $_structure = array();       
  880.         $_structure['id'] = $this->getIdent();
  881.         $_structure['indeterminate'] = $this->isIndeterminate();
  882.         $_structure['borderpainted'] = $this->isBorderPainted();
  883.         $_structure['stringpainted'] = $this->isStringPainted();
  884.         $_structure['string'] = $this->_progressString;
  885.         $_structure['animspeed'] = $this->_anim_speed;
  886.         $_structure['ui']['classID'] = get_class($ui);
  887.         $_structure['ui']['orientation'] = $ui->getOrientation();
  888.         $_structure['ui']['fillway'] = $ui->getFillWay();
  889.         $_structure['ui']['cell'] = $ui->getCellAttributes();
  890.         $_structure['ui']['cell']['count'] = $ui->getCellCount();
  891.         $_structure['ui']['border'] = $ui->getBorderAttributes();
  892.         $_structure['ui']['string'] = $ui->getStringAttributes();
  893.         $_structure['ui']['progress'] = $ui->getProgressAttributes();
  894.         $_structure['ui']['script'] = $ui->getScript();
  895.         $_structure['dm']['classID'] = get_class($dm);
  896.         $_structure['dm']['minimum'] = $dm->getMinimum();
  897.         $_structure['dm']['maximum'] = $dm->getMaximum();
  898.         $_structure['dm']['increment'] = $dm->getIncrement();
  899.         $_structure['dm']['value'] = $dm->getValue();
  900.         $_structure['dm']['percent'] = $dm->getPercentComplete();
  901.  
  902.         return $_structure;
  903.     }
  904.  
  905.     /**
  906.      * Returns the progress structure as HTML.
  907.      *
  908.      * @return     string                   HTML Progress bar
  909.      * @since      0.2
  910.      * @access     public
  911.      */
  912.     function toHtml()
  913.     {
  914.         $strHtml = '';
  915.         $ui =& $this->_UI;
  916.         $tabs = $ui->_getTabs();
  917.         $tab = $ui->_getTab();
  918.         $lnEnd = $ui->_getLineEnd();
  919.         $comment = $ui->getComment();
  920.         $orient = $ui->getOrientation();
  921.         $progressAttr = $ui->getProgressAttributes();
  922.         $borderAttr = $ui->getBorderAttributes();
  923.         $stringAttr = $ui->getStringAttributes();
  924.         $valign = strtolower($stringAttr['valign']);
  925.         
  926.         /**
  927.          *  Adds a progress bar legend in html code is possible.
  928.          *  See HTML_Common::setComment() method.
  929.          */
  930.         if (strlen($comment) > 0) {
  931.             $strHtml .= $tabs . "<!-- $comment -->" . $lnEnd;
  932.         }
  933.  
  934.         $strHtml .= $tabs . "<div class=\"".$this->getIdent()."\">" . $lnEnd;
  935.         $strHtml .= $tabs . "<table border=\"0\" cellspacing=\"0\" cellpadding=\"0\">" . $lnEnd;
  936.         $progressId = $this->getIdent().'_';
  937.  
  938.         /**
  939.          *  Creates all cells of progress bar in order
  940.          *  depending of the FillWay and Orientation. 
  941.          */
  942.         if ($orient == HTML_PROGRESS_BAR_HORIZONTAL) {
  943.             $progressHtml = $this->_getProgressHbar_toHtml();
  944.         }
  945.  
  946.         if ($orient == HTML_PROGRESS_BAR_VERTICAL) {
  947.             $progressHtml = $this->_getProgressVbar_toHtml();
  948.         }
  949.  
  950.         /**
  951.          *  Progress Bar (2) alignment rules:
  952.          *  - percent / messsage area (1)
  953.          *
  954.          *  +---------------------------------------+
  955.          *  |         +t1---+                       |
  956.          *  |         | (1) |                       |
  957.          *  |         +-----+                       |
  958.          *  | +t2---+ +-------------------+ +t3---+ |
  959.          *  | | (1) | | | | | (2) | | | | | | (1) | |
  960.          *  | +-----+ +-------------------+ +-----+ |
  961.          *  |         +t4---+                       |
  962.          *  |         | (1) |                       |
  963.          *  |         +-----+                       |
  964.          *  +---------------------------------------+
  965.          */
  966.         if (($valign == 'left') || ($valign == 'right')) {
  967.             $tRows = 1;
  968.             $tCols = 2;
  969.             $ps = ($valign == 'left') ? 0 : 1;
  970.         } else {
  971.             $tRows = 2;
  972.             $tCols = 1;
  973.             $ps = ($valign == 'top')  ? 0 : 1;
  974.         }
  975.  
  976.         for ($r = 0 ; $r < $tRows ; $r++) {
  977.             $strHtml .= $tabs . "<tr>" . $lnEnd;
  978.             for ($c = 0 ; $c < $tCols ; $c++) {
  979.                 if (($c == $ps) || ($r == $ps)) {
  980.                     $id = $stringAttr['id'];
  981.                     $strHtml .= $tabs . $tab . "<td class=\"$id\" id=\"$progressId$id\">" . $lnEnd;
  982.                     $strHtml .= $tabs . $tab . $tab . $this->getString() . $lnEnd;
  983.                     $ps = -1;
  984.                 } else {
  985.                     $class = $progressAttr['class'];
  986.                     $strHtml .= $tabs . $tab ."<td class=\"$class\">" . $lnEnd;
  987.                     $strHtml .= $tabs . $tab . $tab . "<div class=\"".$borderAttr['class']."\">" . $lnEnd;
  988.                     $strHtml .= $progressHtml;
  989.                     $strHtml .= $tabs . $tab . $tab . "</div>" . $lnEnd;
  990.                 }
  991.                 $strHtml .= $tabs . $tab ."</td>" . $lnEnd;
  992.             }
  993.             $strHtml .= $tabs . "</tr>" . $lnEnd;
  994.         }
  995.  
  996.         $strHtml .= $tabs . "</table>" . $lnEnd;
  997.         $strHtml .= $tabs . "</div>" . $lnEnd;
  998.  
  999.         return $strHtml;
  1000.     }
  1001.  
  1002.     /**
  1003.      * Renders the new value of progress bar.
  1004.      *
  1005.      * @return     void
  1006.      * @since      0.2
  1007.      * @access     public
  1008.      */
  1009.     function display()
  1010.     {
  1011.         static $lnEnd;
  1012.         static $cellAmount;
  1013.         static $determinate;
  1014.  
  1015.         if(!isset($lnEnd)) {
  1016.             $ui =& $this->_UI;
  1017.             $lnEnd = $ui->_getLineEnd();
  1018.             $cellAmount = ($this->getMaximum() - $this->getMinimum()) / $ui->getCellCount();
  1019.         }
  1020.  
  1021.         if (function_exists('ob_get_clean')) {
  1022.             $bar  = ob_get_clean();      // use for PHP 4.3+
  1023.         } else {
  1024.             $bar  = ob_get_contents();   // use for PHP 4.2+
  1025.             ob_end_clean();
  1026.         }
  1027.         $bar .= $lnEnd;
  1028.  
  1029.         $progressId = $this->getIdent().'_';
  1030.  
  1031.         if ($this->isIndeterminate()) {
  1032.             if (isset($determinate)) {
  1033.                 $determinate++;
  1034.                 $progress = $determinate;
  1035.             } else {
  1036.                 $progress = $determinate = 1;
  1037.             }
  1038.         } else {
  1039.             $progress = ($this->getValue() - $this->getMinimum()) / $cellAmount;
  1040.             $determinate = 0;
  1041.     }
  1042.         $bar .= '<script type="text/javascript">self.setprogress("'.$progressId.'",'.((int) $progress).',"'.$this->getString().'",'.$determinate.'); </script>';
  1043.  
  1044.         // sleep a bit ...
  1045.         for ($i=0; $i<($this->_anim_speed*1000); $i++) { }
  1046.  
  1047.         echo $bar;
  1048.         ob_start();
  1049.     }
  1050.  
  1051.     /**
  1052.      * Returns the current identification string.
  1053.      *
  1054.      * @return     string                   current Progress instance's identification string
  1055.      * @since      1.0
  1056.      * @access     public
  1057.      * @see        setIdent()
  1058.      */
  1059.     function getIdent()
  1060.     {
  1061.         return $this->_ident;
  1062.     }
  1063.  
  1064.     /**
  1065.      * Sets this Progress instance's identification string.
  1066.      *
  1067.      * @param      mixed     $ident         (optional) the new identification string.
  1068.      *
  1069.      * @since      1.0
  1070.      * @access     public
  1071.      * @see        getIdent()
  1072.      */
  1073.     function setIdent($ident = null)
  1074.     {
  1075.         if (is_null($ident)) {
  1076.             $this->_ident = 'p_' . substr(md5(microtime()), 0, 6);
  1077.         } else {
  1078.             $this->_ident = $ident;
  1079.     }
  1080.     }
  1081.  
  1082.     /**
  1083.      * Returns an array of all the listeners added to this progress bar.
  1084.      *
  1085.      * @return     array
  1086.      * @since      1.0
  1087.      * @access     public
  1088.      * @see        addListener(), removeListener()
  1089.      */
  1090.     function getListeners()
  1091.     {
  1092.         return $this->_listeners;
  1093.     }
  1094.  
  1095.     /**
  1096.      * Adds a HTML_Progress_Observer instance to the list of observers 
  1097.      * that are listening for messages emitted by this HTML_Progress instance.
  1098.      *
  1099.      * @param      object    $observer      The HTML_Progress_Observer instance 
  1100.      *                                      to attach as a listener.
  1101.      *
  1102.      * @return     boolean                  True if the observer is successfully attached.
  1103.      * @since      1.0
  1104.      * @access     public
  1105.      * @see        getListeners(), removeListener()
  1106.      */
  1107.     function addListener($observer)
  1108.     {
  1109.         if (!is_a($observer, 'HTML_Progress_Observer') &&
  1110.             !is_a($observer, 'HTML_Progress_Monitor')) {
  1111.             return false;
  1112.         }
  1113.         $this->_listeners[$observer->_id] = &$observer;
  1114.         return true;
  1115.     }
  1116.  
  1117.     /**
  1118.      * Removes a HTML_Progress_Observer instance from the list of observers.
  1119.      *
  1120.      * @param      object    $observer      The HTML_Progress_Observer instance 
  1121.      *                                      to detach from the list of listeners.
  1122.      *
  1123.      * @return     boolean                  True if the observer is successfully detached.
  1124.      * @since      1.0
  1125.      * @access     public
  1126.      * @see        getListeners(), addListener()
  1127.      */
  1128.     function removeListener($observer)
  1129.     {
  1130.         if ((!is_a($observer, 'HTML_Progress_Observer') && 
  1131.              !is_a($observer, 'HTML_Progress_Monitor')
  1132.              ) || 
  1133.             (!isset($this->_listeners[$observer->_id]))  ) {
  1134.  
  1135.             return false;
  1136.         }
  1137.         unset($this->_listeners[$observer->_id]);
  1138.         return true;
  1139.     }
  1140.  
  1141.     /**
  1142.      * Notifies all listeners that have registered interest in $event message.
  1143.      *
  1144.      * @param      mixed     $event         A hash describing the progress event.
  1145.      *
  1146.      * @since      1.0
  1147.      * @access     private
  1148.      * @see        setMinimum(), setMaximum(), setValue(), incValue()
  1149.      */
  1150.     function _announce($event)
  1151.     {
  1152.         foreach ($this->_listeners as $id => $listener) {
  1153.             $this->_listeners[$id]->notify($event);
  1154.         }
  1155.     }
  1156.  
  1157.     /**
  1158.      * Returns a horizontal progress bar structure as HTML.
  1159.      *
  1160.      * @return     string                   Horizontal HTML Progress bar
  1161.      * @since      1.0
  1162.      * @access     private
  1163.      */
  1164.     function _getProgressHbar_toHtml()
  1165.     {
  1166.         $ui =& $this->_UI;
  1167.         $tabs = $ui->_getTabs();
  1168.         $tab = $ui->_getTab();
  1169.         $lnEnd = $ui->_getLineEnd();
  1170.         $way_natural = ($ui->getFillWay() == 'natural');
  1171.         $cellAttr = $ui->getCellAttributes();
  1172.         $cellCount = $ui->getCellCount();
  1173.  
  1174.         $progressId = $this->getIdent().'_';
  1175.         $progressHtml = "";
  1176.  
  1177.         if ($way_natural) {
  1178.             // inactive cells first
  1179.             $pos = $cellAttr['spacing'];
  1180.             for ($i=0; $i<$cellCount; $i++) {
  1181.                 $progressHtml .= $tabs . $tab . $tab;
  1182.                 $progressHtml .= "<div id=\"". $progressId . sprintf($cellAttr['id'],$i) ."I\""; 
  1183.                 $progressHtml .= " class=\"".$cellAttr['class']."I\"";
  1184.                 $progressHtml .= " style=\"position:absolute;top:".$cellAttr['spacing']."px;left:".$pos."px;\"";
  1185.                 $progressHtml .= "> </div>" . $lnEnd;
  1186.                 $pos += ($cellAttr['width'] + $cellAttr['spacing']);
  1187.             }
  1188.             // then active cells
  1189.             $pos = $cellAttr['spacing'];
  1190.             for ($i=0; $i<$cellCount; $i++) {
  1191.                 $progressHtml .= $tabs . $tab . $tab;
  1192.                 $progressHtml .= "<div id=\"". $progressId . sprintf($cellAttr['id'],$i) ."A\""; 
  1193.                 $progressHtml .= " class=\"".$cellAttr['class']."A\"";
  1194.                 $progressHtml .= " style=\"position:absolute;top:".$cellAttr['spacing']."px;left:".$pos."px;";
  1195.                 if (isset($cellAttr[$i])) {
  1196.                     $progressHtml .= "color:".$cellAttr[$i]['color'].";\"";
  1197.                 } else {
  1198.                     $progressHtml .= "\"";
  1199.                 }
  1200.                 $progressHtml .= "> </div>" . $lnEnd;
  1201.                 $pos += ($cellAttr['width'] + $cellAttr['spacing']);
  1202.             }
  1203.         } else {
  1204.             // inactive cells first
  1205.             $pos = $cellAttr['spacing'];
  1206.             for ($i=$cellCount-1; $i>=0; $i--) {
  1207.                 $progressHtml .= $tabs . $tab . $tab;
  1208.                 $progressHtml .= "<div id=\"". $progressId . sprintf($cellAttr['id'],$i) ."I\"";
  1209.                 $progressHtml .= " class=\"".$cellAttr['class']."I\"";
  1210.                 $progressHtml .= " style=\"position:absolute;top:".$cellAttr['spacing']."px;left:".$pos."px;\"";
  1211.                 $progressHtml .= "> </div>" . $lnEnd;
  1212.                 $pos += ($cellAttr['width'] + $cellAttr['spacing']);
  1213.             }
  1214.             // then active cells
  1215.             $pos = $cellAttr['spacing'];
  1216.             for ($i=$cellCount-1; $i>=0; $i--) {
  1217.                 $progressHtml .= $tabs . $tab . $tab;
  1218.                 $progressHtml .= "<div id=\"". $progressId . sprintf($cellAttr['id'],$i) ."A\"";
  1219.                 $progressHtml .= " class=\"".$cellAttr['class']."A\"";
  1220.                 $progressHtml .= " style=\"position:absolute;top:".$cellAttr['spacing']."px;left:".$pos."px;";
  1221.                 if (isset($cellAttr[$i])) {
  1222.                     $progressHtml .= "color:".$cellAttr[$i]['color'].";\"";
  1223.                 } else {
  1224.                     $progressHtml .= "\"";
  1225.                 }
  1226.                 $progressHtml .= "> </div>" . $lnEnd;
  1227.                 $pos += ($cellAttr['width'] + $cellAttr['spacing']);
  1228.             }
  1229.         }
  1230.         return $progressHtml;
  1231.     }
  1232.  
  1233.     /**
  1234.      * Returns a vertical progress bar structure as HTML.
  1235.      *
  1236.      * @return     string                   Vertical HTML Progress bar
  1237.      * @since      1.0
  1238.      * @access     private
  1239.      */
  1240.     function _getProgressVbar_toHtml()
  1241.     {
  1242.         $ui =& $this->_UI;
  1243.         $tabs = $ui->_getTabs();
  1244.         $tab = $ui->_getTab();
  1245.         $lnEnd = $ui->_getLineEnd();
  1246.         $way_natural = ($ui->getFillWay() == 'natural');
  1247.         $cellAttr = $ui->getCellAttributes();
  1248.         $cellCount = $ui->getCellCount();
  1249.  
  1250.         $progressId = $this->getIdent().'_';
  1251.         $progressHtml = "";
  1252.  
  1253.         if ($way_natural) {
  1254.             // inactive cells first
  1255.             $pos = $cellAttr['spacing'];
  1256.             for ($i=$cellCount-1; $i>=0; $i--) {
  1257.                 $progressHtml .= $tabs . $tab . $tab;
  1258.                 $progressHtml .= "<div id=\"". $progressId . sprintf($cellAttr['id'],$i) ."I\"";
  1259.                 $progressHtml .= " class=\"".$cellAttr['class']."I\"";
  1260.                 $progressHtml .= " style=\"position:absolute;left:".$cellAttr['spacing']."px;top:".$pos."px;\"";
  1261.                 $progressHtml .= "> </div>" . $lnEnd;
  1262.                 $pos += ($cellAttr['height'] + $cellAttr['spacing']);
  1263.             }
  1264.             // then active cells
  1265.             $pos = $cellAttr['spacing'];
  1266.             for ($i=$cellCount-1; $i>=0; $i--) {
  1267.                 $progressHtml .= $tabs . $tab . $tab;
  1268.                 $progressHtml .= "<div id=\"". $progressId . sprintf($cellAttr['id'],$i) ."A\"";
  1269.                 $progressHtml .= " class=\"".$cellAttr['class']."A\"";
  1270.                 $progressHtml .= " style=\"position:absolute;left:".$cellAttr['spacing']."px;top:".$pos."px;";
  1271.                 if (isset($cellAttr[$i])) {
  1272.                     $progressHtml .= "color:".$cellAttr[$i]['color'].";\"";
  1273.                 } else {
  1274.                     $progressHtml .= "\"";
  1275.                 }
  1276.                 $progressHtml .= "> </div>" . $lnEnd;
  1277.                 $pos += ($cellAttr['height'] + $cellAttr['spacing']);
  1278.             }
  1279.         } else {
  1280.             // inactive cells first
  1281.             $pos = $cellAttr['spacing'];
  1282.             for ($i=0; $i<$cellCount; $i++) {
  1283.                 $progressHtml .= $tabs . $tab . $tab;
  1284.                 $progressHtml .= "<div id=\"". $progressId . sprintf($cellAttr['id'],$i) ."I\"";
  1285.                 $progressHtml .= " class=\"".$cellAttr['class']."I\"";
  1286.                 $progressHtml .= " style=\"position:absolute;left:".$cellAttr['spacing']."px;top:".$pos."px;\"";
  1287.                 $progressHtml .= "> </div>" . $lnEnd;
  1288.                 $pos += ($cellAttr['height'] + $cellAttr['spacing']);
  1289.             }
  1290.             // then active cells
  1291.             $pos = $cellAttr['spacing'];
  1292.             for ($i=0; $i<$cellCount; $i++) {
  1293.                 $progressHtml .= $tabs . $tab . $tab;
  1294.                 $progressHtml .= "<div id=\"". $progressId . sprintf($cellAttr['id'],$i) ."A\"";
  1295.                 $progressHtml .= " class=\"".$cellAttr['class']."A\"";
  1296.                 $progressHtml .= " style=\"position:absolute;left:".$cellAttr['spacing']."px;top:".$pos."px;";
  1297.                 if (isset($cellAttr[$i])) {
  1298.                     $progressHtml .= "color:".$cellAttr[$i]['color'].";\"";
  1299.                 } else {
  1300.                     $progressHtml .= "\"";
  1301.                 }
  1302.                 $progressHtml .= "> </div>" . $lnEnd;
  1303.                 $pos += ($cellAttr['height'] + $cellAttr['spacing']);
  1304.             }
  1305.         }
  1306.         return $progressHtml;
  1307.     }
  1308.  
  1309.     /**
  1310.      * Error message generator for package HTML_Progress
  1311.      *
  1312.      * @param      integer   $code
  1313.      * @param      array     $args
  1314.      * @param      integer   $state
  1315.      *
  1316.      * @return     string
  1317.      * @since      1.0
  1318.      * @access     private
  1319.      */
  1320.     function _getErrorMessage($code, $args, $state)
  1321.     {
  1322.         $messages = array(
  1323.             HTML_PROGRESS_ERROR_INVALID_INPUT =>
  1324.                 'invalid input, parameter #%paramnum% '
  1325.                     . '"%var%" was expecting '
  1326.                     . '"%expected%", instead got "%was%"',
  1327.             HTML_PROGRESS_ERROR_INVALID_CALLBACK =>
  1328.                 'invalid callback, parameter #%paramnum% '
  1329.                     . '"%var%" expecting %element%,'
  1330.                     . ' instead got "%was%" does not exists',
  1331.       );
  1332.         if (isset($messages[$code])) {
  1333.             $message = $messages[$code];
  1334.         } else {
  1335.             $message = 'Code ' . $code . ' is not a valid error code';
  1336.         }
  1337.         return Error_Raise::sprintfErrorMessageWithState($message, $args, $state);
  1338.     }
  1339. }
  1340. ?>