Source for file BaseWidgets.php

Documentation is available at BaseWidgets.php

  1. <?php
  2.     /**
  3.      * The standard widgets
  4.      * @copyright Copyright (c) 2006,2007 Mirchev Ideas Ltd. All rights reserved.
  5.      * @package MIPHPF
  6.      */
  7.  
  8.     /**
  9.      * Base class for the base widgets: text, checkbox, radio, select
  10.      * @copyright Copyright (c) 2006,2007 Mirchev Ideas Ltd. All rights reserved.
  11.      * @package MIPHPF
  12.      */
  13.     class miBaseWidget extends miWidget {
  14.         protected $_fieldName;
  15.         
  16.         /**
  17.          * Sets the field name
  18.          * 
  19.          * @param string $fieldName the name of the field
  20.          */
  21.         public function setFieldName($fieldName)
  22.         {
  23.             $this->_fieldName = $fieldName;
  24.         }
  25.         
  26.         /**
  27.          * Retrieves the field name
  28.          * 
  29.          * @return string the field name
  30.          */
  31.         public function getFieldName()
  32.         {
  33.             return $this->_fieldName;
  34.         }
  35.     }
  36.     
  37.     
  38.     /**
  39.      * Text widget
  40.      * Use it with input type="text" and with textarea
  41.      * @copyright Copyright (c) 2006,2007 Mirchev Ideas Ltd. All rights reserved.
  42.      * @package MIPHPF
  43.      */
  44.     class miBaseTextWidget extends miBaseWidget {
  45.         /**
  46.          * 
  47.          */
  48.         function getControl()
  49.         {
  50.             return array($this->_fieldName => miI18N::htmlEscape($this->_webForm->getFormData($this->_fieldName)));
  51.         }
  52.         
  53.         /**
  54.          * Returns the text widget contents to be displayed
  55.          * 
  56.          * @return array 
  57.          */
  58.         function getEditableControl()
  59.         {
  60.             return array($this->_fieldName => miI18N::htmlEscape($this->_webForm->getFormData($this->_fieldName)));
  61.         }
  62.         
  63.         /**
  64.          * Process the form submissions and returns the text widget data
  65.          * 
  66.          * @return array 
  67.          */
  68.         function getData()
  69.         {
  70.             if (isset($this->_properties['readOnly']) && $this->_properties['readOnly']) {
  71.                 return array();    
  72.             }
  73.             return array($this->_fieldName => miGetParamDefault($this->_fieldName, ''));
  74.         }
  75.         
  76.         /**
  77.          * Validates the text widget
  78.          */
  79.         public function validateData(miWebFormErrorsHandler &$errors)
  80.         {
  81.             if (isset($this->_properties['minLength'])) {
  82.                 if (strlen(miGetParamDefault($this->_fieldName, '')) < $this->_properties['minLength'])
  83.                     $errors->addError($this->_fieldName, 'Field too short');
  84.             }
  85.             if (isset($this->_properties['maxLength'])) {
  86.                 if (strlen(miGetParamDefault($this->_fieldName, '')) > $this->_properties['maxLength'])
  87.                     $errors->addError($this->_fieldName, 'Field too long');
  88.             }
  89.         }
  90.     }
  91.     
  92.     
  93.     /**
  94.      * Checkbox widget
  95.      * Use it with input type="checkbox"
  96.      * @copyright Copyright (c) 2006,2007 Mirchev Ideas Ltd. All rights reserved.
  97.      * @package MIPHPF
  98.      */
  99.     class miBaseCheckboxWidget extends miBaseWidget {
  100.         const VIEW_CHECKED = 'Yes';
  101.         const VIEW_UNCHECKED = 'No';
  102.         
  103.         protected $_defaultValue = false;
  104.         
  105.         public function __construct(miWebForm &$webForm, $properties = array())
  106.         {
  107.             parent::__construct($webForm, $properties);
  108.             if (isset($this->_properties['defaultValue']))
  109.                 $this->_defaultValue = $this->_properties['defaultValue'];
  110.         }
  111.         
  112.         /**
  113.          * Sets the default state of the checkbox
  114.          * 
  115.          * @param boolean $defaultValue 
  116.          */
  117.         public function setDefaultValue($defaultValue)
  118.         {
  119.             $this->_defaultValue = $defaultValue;
  120.         }
  121.         
  122.         protected function getValue()
  123.         {
  124.             $value = $this->_webForm->getFormData($this->_fieldName);
  125.             if (is_null($value) and !is_null($this->_defaultValue))
  126.                 return $this->_defaultValue;
  127.             return $value;
  128.         }
  129.         
  130.         /**
  131.          * 
  132.          */
  133.         function getControl()
  134.         {
  135.             return array($this->_fieldName => $this->getValue() ? miBaseCheckboxWidget::VIEW_CHECKED : miBaseCheckboxWidget::VIEW_UNCHECKED);
  136.         }
  137.         
  138.         /**
  139.          * Returns the checkbox widget contents to be displayed
  140.          * 
  141.          * @return array 
  142.          */
  143.         function getEditableControl()
  144.         {
  145.             return array($this->_fieldName => $this->getValue() ? 'checked="checked"' : '');
  146.         }
  147.         
  148.         /**
  149.          * Process the form submissions and returns the checkbox widget data
  150.          * 
  151.          * @return array 
  152.          */
  153.         function getData()
  154.         {
  155.             // The checkbox is checked if the value is non-empty string
  156.             return array($this->_fieldName => (miGetParamDefault($this->_fieldName, '') == '') ? false : true);
  157.         }
  158.     }
  159.     
  160.     
  161.     /**
  162.      * Radio buttons widget
  163.      * Use it with input type="radio"
  164.      * 
  165.      * This class supports a group of radio buttons
  166.      * @copyright Copyright (c) 2006,2007 Mirchev Ideas Ltd. All rights reserved.
  167.      * @package MIPHPF
  168.      */
  169.     class miBaseRadioWidget extends miBaseWidget {
  170.         /**
  171.          * Array with the radio buttons
  172.          * 
  173.          * @access protected
  174.          */
  175.         protected $_radioButtons = array();
  176.         
  177.         /**
  178.          * The index of the default radio button
  179.          * 
  180.          * @access protected
  181.          */
  182.         protected $_defaultRadioIndex = null;
  183.         
  184.         /**
  185.          * Sets the radio buttons
  186.          * The $radioButtons is an associative array
  187.          * where the key is used to separate the radio buttons within a group and
  188.          * the value is the display value of the radio button
  189.          * If $defaultRadioIndex is not set the first radio button is checked.
  190.          * 
  191.          * @access public
  192.          * @param array $radioButtons 
  193.          * @param string|int$defaultRadioIndex the index of the default radio button (optional)
  194.          */
  195.         public function setRadioButtons($radioButtons, $defaultRadioIndex = null)
  196.         {
  197.             $this->_radioButtons = $radioButtons;
  198.             
  199.             // Make sure that the default index is valid
  200.             if ($defaultRadioIndex !== null) {
  201.                 if (empty($radioButtons[$defaultRadioIndex]))
  202.                     throw new miConfigurationException('The default radio index "' . $defaultRadioIndex . '" is invalid. Must be either valid, or null.', miConfigurationException::EXCEPTION_DEFAULT_RADIO_INDEX_INVALID);
  203.                 $this->_defaultRadioIndex = $defaultRadioIndex;
  204.             }
  205.         }
  206.         
  207.         /**
  208.          * 
  209.          */
  210.         function getControl()
  211.         {
  212.             $value = $this->_webForm->getFormData($this->_fieldName);
  213.             return array($this->_fieldName => miI18N::htmlEscape(@$this->_radioButtons[$value]));
  214.         }
  215.         
  216.         protected function getValue()
  217.         {
  218.             $value = $this->_webForm->getFormData($this->_fieldName);
  219.             if (!empty($this->_radioButtons[$value]))
  220.                 return $value;
  221.             
  222.             // If we cannot find the $value in the radioButtons group use the default
  223.             if ($this->_defaultRadioIndex === null) {
  224.                 reset($this->_radioButtons);
  225.                 return key($this->_radioButtons);
  226.             } else
  227.                 return $this->_defaultRadioIndex;
  228.         }
  229.         
  230.         /**
  231.          * Returns the widget contents to be displayed
  232.          * 
  233.          * @return array 
  234.          */
  235.         public function getEditableControl()
  236.         {
  237.             $value = $this->getValue();
  238.             
  239.             $display = array();
  240.             foreach ($this->_radioButtons as $key => $option) {
  241.                 $display[$this->_fieldName . '_' . $key] = ($value == $key) ? 'checked="checked"' : '';
  242.             }
  243.             return $display;
  244.         }
  245.         
  246.         /**
  247.          * Process the form submissions and returns the widget data
  248.          * 
  249.          * @return array 
  250.          */
  251.         public function getData()
  252.         {
  253.             return array($this->_fieldName => miGetParamDefault($this->_fieldName, ''));
  254.         }
  255.     }
  256.     
  257.     
  258.     /**
  259.      * Select widget
  260.      * Use it with select tag
  261.      * @copyright Copyright (c) 2006,2007 Mirchev Ideas Ltd. All rights reserved.
  262.      * @package MIPHPF
  263.      */
  264.     class miBaseSelectWidget extends miBaseWidget {
  265.         /**
  266.          * 
  267.          * @access protected
  268.          */
  269.         protected $_options = array();
  270.         
  271.         /**
  272.          * 
  273.          * @access protected
  274.          */
  275.         protected $_defaultOptionIndex = null;
  276.         
  277.         /**
  278.          * @access public
  279.          */
  280.         public function setOptions($options, $defaultOptionIndex = null)
  281.         {
  282.             $this->_options = $options;
  283.             
  284.             // Make sure the _defaultOptionIndex is valid or null
  285.             if ($defaultOptionIndex !== null) {
  286.                 if (empty($options[$defaultOptionIndex]))
  287.                     throw new miConfigurationException('The default select option index "' . $defaultOptionIndex . '" is invalid. Must be either valid, or null.', miConfigurationException::EXCEPTION_DEFAULT_OPTION_INDEX_INVALID);
  288.                 $this->_defaultOptionIndex = $defaultOptionIndex;
  289.             }
  290.         }
  291.         
  292.         /**
  293.          * 
  294.          */
  295.         function getControl()
  296.         {
  297.             $value = $this->_webForm->getFormData($this->_fieldName);
  298.             return array($this->_fieldName => miI18N::htmlEscape(@$this->_options[$value]));
  299.         }
  300.         
  301.         protected function getValue()
  302.         {
  303.             $value = $this->_webForm->getFormData($this->_fieldName);
  304.             if (!empty($this->_options[$value]))
  305.                 return $value;
  306.             
  307.             if ($this->_defaultOptionIndex === null) {
  308.                 reset($this->_options);
  309.                 return key($this->_options);
  310.             } else
  311.                 return $this->_defaultOptionIndex;
  312.         }
  313.         
  314.         /**
  315.          * Returns the widget contents to be displayed
  316.          * 
  317.          * @return array 
  318.          */
  319.         public function getEditableControl()
  320.         {
  321.             $value = $this->getValue();
  322.             
  323.             $html = '';
  324.             foreach ($this->_options as $key => $option)
  325.                 $html .= '<option value="' . miI18N::htmlEscape($key) . '"' . ($key == $value?' selected="selected"':'') . '>' . miI18N::htmlEscape($option) . '</option>';
  326.             return array($this->_fieldName => $html);
  327.         }
  328.         
  329.         /**
  330.          * Process the form submissions and returns the widget data
  331.          * 
  332.          * @return array 
  333.          */
  334.         public function getData()
  335.         {
  336.             if (isset($this->_properties['readOnly']) && $this->_properties['readOnly']) {
  337.                 return array();    
  338.             }
  339.             return array($this->_fieldName => miGetParamDefault($this->_fieldName, ''));
  340.         }
  341.     }
  342. ?>

Documentation generated on Thu, 08 May 2008 16:57:10 +0300 by phpDocumentor 1.4.1