HTML_QuickForm
[ class tree: HTML_QuickForm ] [ index: HTML_QuickForm ] [ all elements ]

Source for file file.php

Documentation is available at file.php

  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  3.  
  4. /**
  5.  * HTML class for a file upload field
  6.  * 
  7.  * PHP versions 4 and 5
  8.  *
  9.  * LICENSE: This source file is subject to version 3.01 of the PHP license
  10.  * that is available through the world-wide-web at the following URI:
  11.  * http://www.php.net/license/3_01.txt If you did not receive a copy of
  12.  * the PHP License and are unable to obtain it through the web, please
  13.  * send a note to license@php.net so we can mail you a copy immediately.
  14.  *
  15.  * @category    HTML
  16.  * @package     HTML_QuickForm
  17.  * @author      Adam Daniel <adaniel1@eesus.jnj.com>
  18.  * @author      Bertrand Mansion <bmansion@mamasam.com>
  19.  * @author      Alexey Borzov <avb@php.net>
  20.  * @copyright   2001-2011 The PHP Group
  21.  * @license     http://www.php.net/license/3_01.txt PHP License 3.01
  22.  * @version     CVS: $Id: file.php 317587 2011-10-01 07:55:53Z avb $
  23.  * @link        http://pear.php.net/package/HTML_QuickForm
  24.  */
  25.  
  26. /**
  27.  * Base class for <input /> form elements
  28.  */
  29. require_once 'HTML/QuickForm/input.php';
  30.  
  31. // register file-related rules
  32. if (class_exists('HTML_QuickForm')) {
  33.     HTML_QuickForm::registerRule('uploadedfile''callback''_ruleIsUploadedFile''HTML_QuickForm_file');
  34.     HTML_QuickForm::registerRule('maxfilesize''callback''_ruleCheckMaxFileSize''HTML_QuickForm_file');
  35.     HTML_QuickForm::registerRule('mimetype''callback''_ruleCheckMimeType''HTML_QuickForm_file');
  36.     HTML_QuickForm::registerRule('filename''callback''_ruleCheckFileName''HTML_QuickForm_file');
  37. }
  38.  
  39. /**
  40.  * HTML class for a file upload field
  41.  * 
  42.  * @category    HTML
  43.  * @package     HTML_QuickForm
  44.  * @author      Adam Daniel <adaniel1@eesus.jnj.com>
  45.  * @author      Bertrand Mansion <bmansion@mamasam.com>
  46.  * @author      Alexey Borzov <avb@php.net>
  47.  * @version     Release: 3.2.13
  48.  * @since       1.0
  49.  */
  50. {
  51.     // {{{ properties
  52.  
  53.    /**
  54.     * Uploaded file data, from $_FILES
  55.     * @var array 
  56.     */
  57.     var $_value = null;
  58.  
  59.     // }}}
  60.     // {{{ constructor
  61.  
  62.     /**
  63.      * Class constructor
  64.      * 
  65.      * @param     string    Input field name attribute
  66.      * @param     string    Input field label
  67.      * @param     mixed     (optional)Either a typical HTML attribute string
  68.      *                       or an associative array
  69.      * @since     1.0
  70.      * @access    public
  71.      */
  72.     function HTML_QuickForm_file($elementName=null$elementLabel=null$attributes=null)
  73.     {
  74.         HTML_QuickForm_input::HTML_QuickForm_input($elementName$elementLabel$attributes);
  75.         $this->setType('file');
  76.     //end constructor
  77.     
  78.     // }}}
  79.     // {{{ setSize()
  80.  
  81.     /**
  82.      * Sets size of file element
  83.      * 
  84.      * @param     int    Size of file element
  85.      * @since     1.0
  86.      * @access    public
  87.      */
  88.     function setSize($size)
  89.     {
  90.         $this->updateAttributes(array('size' => $size));
  91.     //end func setSize
  92.     
  93.     // }}}
  94.     // {{{ getSize()
  95.  
  96.     /**
  97.      * Returns size of file element
  98.      * 
  99.      * @since     1.0
  100.      * @access    public
  101.      * @return    int 
  102.      */
  103.     function getSize()
  104.     {
  105.         return $this->getAttribute('size');
  106.     //end func getSize
  107.  
  108.     // }}}
  109.     // {{{ freeze()
  110.  
  111.     /**
  112.      * Freeze the element so that only its value is returned
  113.      * 
  114.      * @access    public
  115.      * @return    bool 
  116.      */
  117.     function freeze()
  118.     {
  119.         return false;
  120.     //end func freeze
  121.  
  122.     // }}}
  123.     // {{{ setValue()
  124.  
  125.     /**
  126.      * Sets value for file element.
  127.      * 
  128.      * Actually this does nothing. The function is defined here to override
  129.      * HTML_Quickform_input's behaviour of setting the 'value' attribute. As
  130.      * no sane user-agent uses <input type="file">'s value for anything
  131.      * (because of security implications) we implement file's value as a
  132.      * read-only property with a special meaning.
  133.      * 
  134.      * @param     mixed    Value for file element
  135.      * @since     3.0
  136.      * @access    public
  137.      */
  138.     function setValue($value)
  139.     {
  140.         return null;
  141.     //end func setValue
  142.     
  143.     // }}}
  144.     // {{{ getValue()
  145.  
  146.     /**
  147.      * Returns information about the uploaded file
  148.      *
  149.      * @since     3.0
  150.      * @access    public
  151.      * @return    array 
  152.      */
  153.     function getValue()
  154.     {
  155.         return $this->_value;
  156.     // end func getValue
  157.  
  158.     // }}}
  159.     // {{{ onQuickFormEvent()
  160.  
  161.     /**
  162.      * Called by HTML_QuickForm whenever form event is made on this element
  163.      *
  164.      * @param     string    Name of event
  165.      * @param     mixed     event arguments
  166.      * @param     object    calling object
  167.      * @since     1.0
  168.      * @access    public
  169.      * @return    bool 
  170.      */
  171.     function onQuickFormEvent($event$arg&$caller)
  172.     {
  173.         switch ($event{
  174.             case 'updateValue':
  175.                 if ($caller->getAttribute('method'== 'get'{
  176.                     return PEAR::raiseError('Cannot add a file upload field to a GET method form');
  177.                 }
  178.                 $this->_value $this->_findValue();
  179.                 $caller->updateAttributes(array('enctype' => 'multipart/form-data'));
  180.                 $caller->setMaxFileSize();
  181.                 break;
  182.             case 'addElement':
  183.                 $this->onQuickFormEvent('createElement'$arg$caller);
  184.                 return $this->onQuickFormEvent('updateValue'null$caller);
  185.                 break;
  186.             case 'createElement':
  187.                 $className get_class($this);
  188.                 $this->$className($arg[0]$arg[1]$arg[2]);
  189.                 break;
  190.         }
  191.         return true;
  192.     // end func onQuickFormEvent
  193.  
  194.     // }}}
  195.     // {{{ moveUploadedFile()
  196.  
  197.     /**
  198.      * Moves an uploaded file into the destination
  199.      * 
  200.      * @param    string  Destination directory path
  201.      * @param    string  New file name
  202.      * @access   public
  203.      * @return   bool    Whether the file was moved successfully
  204.      */
  205.     function moveUploadedFile($dest$fileName '')
  206.     {
  207.         if ($dest != ''  && substr($dest-1!= '/'{
  208.             $dest .= '/';
  209.         }
  210.         $fileName ($fileName != ''$fileName basename($this->_value['name']);
  211.         return move_uploaded_file($this->_value['tmp_name']$dest $fileName)
  212.     // end func moveUploadedFile
  213.     
  214.     // }}}
  215.     // {{{ isUploadedFile()
  216.  
  217.     /**
  218.      * Checks if the element contains an uploaded file
  219.      *
  220.      * @access    public
  221.      * @return    bool      true if file has been uploaded, false otherwise
  222.      */
  223.     function isUploadedFile()
  224.     {
  225.         return $this->_ruleIsUploadedFile($this->_value);
  226.     // end func isUploadedFile
  227.  
  228.     // }}}
  229.     // {{{ _ruleIsUploadedFile()
  230.  
  231.     /**
  232.      * Checks if the given element contains an uploaded file
  233.      *
  234.      * @param     array     Uploaded file info (from $_FILES)
  235.      * @access    private
  236.      * @return    bool      true if file has been uploaded, false otherwise
  237.      */
  238.     function _ruleIsUploadedFile($elementValue)
  239.     {
  240.         if ((isset($elementValue['error']&& $elementValue['error'== 0||
  241.             (!empty($elementValue['tmp_name']&& $elementValue['tmp_name'!= 'none')) {
  242.             return is_uploaded_file($elementValue['tmp_name']);
  243.         else {
  244.             return false;
  245.         }
  246.     // end func _ruleIsUploadedFile
  247.     
  248.     // }}}
  249.     // {{{ _ruleCheckMaxFileSize()
  250.  
  251.     /**
  252.      * Checks that the file does not exceed the max file size
  253.      *
  254.      * @param     array     Uploaded file info (from $_FILES)
  255.      * @param     int       Max file size
  256.      * @access    private
  257.      * @return    bool      true if filesize is lower than maxsize, false otherwise
  258.      */
  259.     function _ruleCheckMaxFileSize($elementValue$maxSize)
  260.     {
  261.         if (!empty($elementValue['error']&& 
  262.             (UPLOAD_ERR_FORM_SIZE == $elementValue['error'|| UPLOAD_ERR_INI_SIZE == $elementValue['error'])) {
  263.             return false;
  264.         }
  265.         if (!HTML_QuickForm_file::_ruleIsUploadedFile($elementValue)) {
  266.             return true;
  267.         }
  268.         return ($maxSize >= @filesize($elementValue['tmp_name']));
  269.     // end func _ruleCheckMaxFileSize
  270.  
  271.     // }}}
  272.     // {{{ _ruleCheckMimeType()
  273.  
  274.     /**
  275.      * Checks if the given element contains an uploaded file of the right mime type
  276.      *
  277.      * @param     array     Uploaded file info (from $_FILES)
  278.      * @param     mixed     Mime Type (can be an array of allowed types)
  279.      * @access    private
  280.      * @return    bool      true if mimetype is correct, false otherwise
  281.      */
  282.     function _ruleCheckMimeType($elementValue$mimeType)
  283.     {
  284.         if (!HTML_QuickForm_file::_ruleIsUploadedFile($elementValue)) {
  285.             return true;
  286.         }
  287.         if (is_array($mimeType)) {
  288.             return in_array($elementValue['type']$mimeType);
  289.         }
  290.         return $elementValue['type'== $mimeType;
  291.     // end func _ruleCheckMimeType
  292.  
  293.     // }}}
  294.     // {{{ _ruleCheckFileName()
  295.  
  296.     /**
  297.      * Checks if the given element contains an uploaded file of the filename regex
  298.      *
  299.      * @param     array     Uploaded file info (from $_FILES)
  300.      * @param     string    Regular expression
  301.      * @access    private
  302.      * @return    bool      true if name matches regex, false otherwise
  303.      */
  304.     function _ruleCheckFileName($elementValue$regex)
  305.     {
  306.         if (!HTML_QuickForm_file::_ruleIsUploadedFile($elementValue)) {
  307.             return true;
  308.         }
  309.         return (bool)preg_match($regex$elementValue['name']);
  310.     // end func _ruleCheckFileName
  311.     
  312.     // }}}
  313.     // {{{ _findValue()
  314.  
  315.    /**
  316.     * Tries to find the element value from the values array
  317.     * 
  318.     * Needs to be redefined here as $_FILES is populated differently from
  319.     * other arrays when element name is of the form foo[bar]
  320.     * 
  321.     * @access    private
  322.     * @return    mixed 
  323.     */
  324.     function _findValue()
  325.     {
  326.         if (empty($_FILES)) {
  327.             return null;
  328.         }
  329.         $elementName $this->getName();
  330.         if (isset($_FILES[$elementName])) {
  331.             return $_FILES[$elementName];
  332.         elseif (false !== ($pos strpos($elementName'['))) {
  333.             $base  str_replace(
  334.                         array('\\''\'')array('\\\\''\\\''),
  335.                         substr($elementName0$pos)
  336.                     )
  337.             $idx   "['" str_replace(
  338.                         array('\\''\''']''[')array('\\\\''\\\''''"']['"),
  339.                         substr($elementName$pos + 1-1)
  340.                      "']";
  341.             $props = array('name''type''size''tmp_name''error');
  342.             $code  = "if (!isset(\$_FILES['{$base}']['name']{$idx})) {\n" .
  343.                      "    return null;\n" .
  344.                      "} else {\n" .
  345.                      "    \$value = array();\n";
  346.             foreach ($props as $prop{
  347.                 $code .= "    \$value['{$prop}'] = \$_FILES['{$base}']['{$prop}']{$idx};\n";
  348.             }
  349.             return eval($code "    return \$value;\n}\n");
  350.         else {
  351.             return null;
  352.         }
  353.     }
  354.  
  355.     // }}}
  356. // end class HTML_QuickForm_file
  357. ?>

Documentation generated on Sat, 01 Oct 2011 09:00:10 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.