1. sfWidgetFormSchema.class.php
  2. /**
 * sfWidgetFormSchema represents an array of fields.
 *
 * A field is a named validator.
 *
 * @package    symfony
 * @subpackage widget
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfWidgetFormSchema.class.php 26870 2010-01-19 10:34:52Z fabien $
 */
  3. class sfWidgetFormSchema extends sfWidgetForm implements ArrayAccess
  4. {
  5.   const
  6.     FIRST  = 'first',
  7.     LAST   = 'last',
  8.     BEFORE = 'before',
  9.     AFTER  = 'after';
  11.   protected static
  12.     $defaultFormatterName = 'table';
  14.   protected
  15.     $formFormatters = array(),
  16.     $fields         = array(),
  17.     $positions      = array(),
  18.     $helps          = array();
  20.   /**
  21.    * Constructor.
  22.    *
  23.    * The first argument can be:
  24.    *
  25.    *  * null
  26.    *  * an array of sfWidget instances
  27.    *
  28.    * Available options:
  29.    *
  30.    *  * name_format:    The sprintf pattern to use for input names
  31.    *  * form_formatter: The form formatter name (table and list are bundled)
  32.    *
  33.    * @param mixed $fields     Initial fields
  34.    * @param array $options    An array of options
  35.    * @param array $attributes An array of default HTML attributes
  36.    * @param array $labels     An array of HTML labels
  37.    * @param array $helps      An array of help texts
  38.    *
  39.    * @throws InvalidArgumentException when the passed fields not null or array
  40.    *
  41.    * @see sfWidgetForm
  42.    */
  43.   public function __construct($fields = null, $options = array(), $attributes = array(), $labels = array(), $helps = array())
  44.   {
  45.     $this->addOption('name_format', '%s');
  46.     $this->addOption('form_formatter', null);
  48.     parent::__construct($options, $attributes);
  50.     if (is_array($fields))
  51.     {
  52.       foreach ($fields as $name => $widget)
  53.       {
  54.         $this[$name] = $widget;
  55.       }
  56.     }
  57.     else if (null !== $fields)
  58.     {
  59.       throw new InvalidArgumentException('sfWidgetFormSchema constructor takes an array of sfWidget objects.');
  60.     }
  62.     $this->setLabels($labels);
  63.     $this->helps = $helps;
  64.   }
  66.   /**
  67.    * Sets the default value for a field.
  68.    *
  69.    * @param string $name  The field name
  70.    * @param string $value The default value (required - the default value is here because PHP do not allow signature changes with inheritance)
  71.    *
  72.    * @return sfWidget The current widget instance
  73.    */
  74.   public function setDefault($name, $value = null)
  75.   {
  76.     $this[$name]->setDefault($value);
  78.     return $this;
  79.   }
  81.   /**
  82.    * Gets the default value of a field.
  83.    *
  84.    * @param string $name The field name (required - the default value is here because PHP do not allow signature changes with inheritance)
  85.    *
  86.    * @return string The default value
  87.    */
  88.   public function getDefault($name = null)
  89.   {
  90.     return $this[$name]->getDefault();
  91.   }
  93.   /**
  94.    * Sets the default values for the widget.
  95.    *
  96.    * @param array $values The default values for the widget
  97.    *
  98.    * @return sfWidget The current widget instance
  99.    */
  100.   public function setDefaults(array $values)
  101.   {
  102.     foreach ($this->fields as $name => $widget)
  103.     {
  104.       if (array_key_exists($name, $values))
  105.       {
  106.         $widget->setDefault($values[$name]);
  107.       }
  108.     }
  110.     return $this;
  111.   }
  113.   /**
  114.    * Returns the defaults values for the widget schema.
  115.    *
  116.    * @return array An array of default values
  117.    */
  118.   public function getDefaults()
  119.   {
  120.     $defaults = array();
  122.     foreach ($this->fields as $name => $widget)
  123.     {
  124.       $defaults[$name] = $widget instanceof sfWidgetFormSchema ? $widget->getDefaults() : $widget->getDefault();
  125.     }
  127.     return $defaults;
  128.   }
  130.   /**
  131.    * Adds a form formatter.
  132.    *
  133.    * @param string                      $name      The formatter name
  134.    * @param sfWidgetFormSchemaFormatter $formatter An sfWidgetFormSchemaFormatter instance
  135.    *
  136.    * @return sfWidget The current widget instance
  137.    */
  138.   public function addFormFormatter($name, sfWidgetFormSchemaFormatter $formatter)
  139.   {
  140.     $this->formFormatters[$name] = $formatter;
  142.     return $this;
  143.   }
  145.   /**
  146.    * Returns all the form formats defined for this form schema.
  147.    *
  148.    * @return array An array of named form formats
  149.    */
  150.   public function getFormFormatters()
  151.   {
  152.     return $this->formFormatters;
  153.   }
  155.   /**
  156.    * Sets the generic default formatter name used by the class. If you want all
  157.    * of your forms to be generated with the <code>list</code> format, you can
  158.    * do it in a project or application configuration class:
  159.    *
  160.    * <pre>
  161.    * class ProjectConfiguration extends sfProjectConfiguration
  162.    * {
  163.    *   public function setup()
  164.    *   {
  165.    *     sfWidgetFormSchema::setDefaultFormFormatterName('list');
  166.    *   }
  167.    * }
  168.    * </pre>
  169.    *
  170.    * @param string $name New default formatter name
  171.    */
  172.   static public function setDefaultFormFormatterName($name)
  173.   {
  174.     self::$defaultFormatterName = $name;
  175.   }
  177.   /**
  178.    * Sets the form formatter name to use when rendering the widget schema.
  179.    *
  180.    * @param string $name The form formatter name
  181.    *
  182.    * @return sfWidget The current widget instance
  183.    */
  184.   public function setFormFormatterName($name)
  185.   {
  186.     $this->options['form_formatter'] = $name;
  188.     return $this;
  189.   }
  191.   /**
  192.    * Gets the form formatter name that will be used to render the widget schema.
  193.    *
  194.    * @return string The form formatter name
  195.    */
  196.   public function getFormFormatterName()
  197.   {
  198.     return null === $this->options['form_formatter'] ? self::$defaultFormatterName : $this->options['form_formatter'];
  199.   }
  201.   /**
  202.    * Returns the form formatter to use for widget schema rendering
  203.    *
  204.    * @return sfWidgetFormSchemaFormatter sfWidgetFormSchemaFormatter instance
  205.    *
  206.    * @throws InvalidArgumentException when the form formatter not exists
  207.    */
  208.   public function getFormFormatter()
  209.   {
  210.     $name = $this->getFormFormatterName();
  212.     if (!isset($this->formFormatters[$name]))
  213.     {
  214.       $class = 'sfWidgetFormSchemaFormatter'.ucfirst($name);
  216.       if (!class_exists($class))
  217.       {
  218.         throw new InvalidArgumentException(sprintf('The form formatter "%s" does not exist.', $name));
  219.       }
  221.       $this->formFormatters[$name] = new $class($this);
  222.     }
  224.     return $this->formFormatters[$name];
  225.   }
  227.   /**
  228.    * Sets the format string for the name HTML attribute.
  229.    *
  230.    * If you are using the form framework with symfony, do not use a reserved word in the
  231.    * name format.  If you do, symfony may act in an unexpected manner.
  232.    *
  233.    * For symfony 1.1+, the following words are reserved and must NOT be used as
  234.    * the name format:
  235.    *
  236.    *  * module    (example: module[%s])
  237.    *  * action    (example: action[%s])
  238.    *
  239.    * However, you CAN use other variations, such as actions[%s] (note the s).
  240.    *
  241.    * @param string $format The format string (must contain a %s for the name placeholder)
  242.    *
  243.    * @return sfWidget The current widget instance
  244.    *
  245.    * @throws InvalidArgumentException when no %s exists in the format
  246.    */
  247.   public function setNameFormat($format)
  248.   {
  249.     if (false !== $format && false === strpos($format, '%s'))
  250.     {
  251.       throw new InvalidArgumentException(sprintf('The name format must contain %%s ("%s" given)', $format));
  252.     }
  254.     $this->options['name_format'] = $format;
  256.     return $this;
  257.   }
  259.   /**
  260.    * Gets the format string for the name HTML attribute.
  261.    *
  262.    * @return string The format string
  263.    */
  264.   public function getNameFormat()
  265.   {
  266.     return $this->options['name_format'];
  267.   }
  269.   /**
  270.    * Sets the label names to render for each field.
  271.    *
  272.    * @param array $labels  An array of label names
  273.    *
  274.    * @return sfWidget The current widget instance
  275.    */
  276.   public function setLabels(array $labels)
  277.   {
  278.     foreach ($this->fields as $name => $widget)
  279.     {
  280.       if (array_key_exists($name, $labels))
  281.       {
  282.         $widget->setLabel($labels[$name]);
  283.       }
  284.     }
  286.     return $this;
  287.   }
  289.   /**
  290.    * Gets the labels.
  291.    *
  292.    * @return array An array of label names
  293.    */
  294.   public function getLabels()
  295.   {
  296.     $labels = array();
  298.     foreach ($this->fields as $name => $widget)
  299.     {
  300.       $labels[$name] = $widget->getLabel();
  301.     }
  303.     return $labels;
  304.   }
  306.   /**
  307.    * Sets a label.
  308.    *
  309.    * @param string $name  The field name
  310.    * @param string $value The label name (required - the default value is here because PHP do not allow signature changes with inheritance)
  311.    *
  312.    * @return sfWidget The current widget instance
  313.    *
  314.    * @throws InvalidArgumentException when you try to set a label on a none existing widget
  315.    */
  316.   public function setLabel($name, $value = null)
  317.   {
  318.     if (2 == func_num_args())
  319.     {
  320.       if (!isset($this->fields[$name]))
  321.       {
  322.         throw new InvalidArgumentException(sprintf('Unable to set the label on an unexistant widget ("%s").', $name));
  323.       }
  325.       $this->fields[$name]->setLabel($value);
  326.     }
  327.     else
  328.     {
  329.       // set the label for this widget schema
  330.       parent::setLabel($name);
  331.     }
  333.     return $this;
  334.   }
  336.   /**
  337.    * Gets a label by field name.
  338.    *
  339.    * @param  string $name  The field name (required - the default value is here because PHP do not allow signature changes with inheritance)
  340.    *
  341.    * @return string The label name or an empty string if it is not defined
  342.    *
  343.    * @throws InvalidArgumentException when you try to get a label for a none existing widget
  344.    */
  345.   public function getLabel($name = null)
  346.   {
  347.     if (1 == func_num_args())
  348.     {
  349.       if (!isset($this->fields[$name]))
  350.       {
  351.         throw new InvalidArgumentException(sprintf('Unable to get the label on an unexistant widget ("%s").', $name));
  352.       }
  354.       return $this->fields[$name]->getLabel();
  355.     }
  356.     else
  357.     {
  358.       // label for this widget schema
  359.       return parent::getLabel();
  360.     }
  361.   }
  363.   /**
  364.    * Sets the help texts to render for each field.
  365.    *
  366.    * @param array $helps An array of help texts
  367.    *
  368.    * @return sfWidget The current widget instance
  369.    */
  370.   public function setHelps(array $helps)
  371.   {
  372.     $this->helps = $helps;
  374.     return $this;
  375.   }
  377.   /**
  378.    * Sets the help texts.
  379.    *
  380.    * @return array An array of help texts
  381.    */
  382.   public function getHelps()
  383.   {
  384.     return $this->helps;
  385.   }
  387.   /**
  388.    * Sets a help text.
  389.    *
  390.    * @param string $name The field name
  391.    * @param string $help The help text
  392.    *
  393.    * @return sfWidget The current widget instance
  394.    */
  395.   public function setHelp($name, $help)
  396.   {
  397.     $this->helps[$name] = $help;
  399.     return $this;
  400.   }
  402.   /**
  403.    * Gets a text help by field name.
  404.    *
  405.    * @param string $name The field name
  406.    *
  407.    * @return string The help text or an empty string if it is not defined
  408.    */
  409.   public function getHelp($name)
  410.   {
  411.     return array_key_exists($name, $this->helps) ? $this->helps[$name] : '';
  412.   }
  414.   /**
  415.    * Gets the stylesheet paths associated with the widget.
  416.    *
  417.    * @return array An array of stylesheet paths
  418.    */
  419.   public function getStylesheets()
  420.   {
  421.     $stylesheets = array();
  423.     foreach ($this->fields as $field)
  424.     {
  425.       $stylesheets = array_merge($stylesheets, $field->getStylesheets());
  426.     }
  428.     return $stylesheets;
  429.   }
  431.   /**
  432.    * Gets the JavaScript paths associated with the widget.
  433.    *
  434.    * @return array An array of JavaScript paths
  435.    */
  436.   public function getJavaScripts()
  437.   {
  438.     $javascripts = array();
  440.     foreach ($this->fields as $field)
  441.     {
  442.       $javascripts = array_merge($javascripts, $field->getJavaScripts());
  443.     }
  445.     return array_unique($javascripts);
  446.   }
  448.   /**
  449.    * Returns true if the widget schema needs a multipart form.
  450.    *
  451.    * @return bool true if the widget schema needs a multipart form, false otherwise
  452.    */
  453.   public function needsMultipartForm()
  454.   {
  455.     foreach ($this->fields as $field)
  456.     {
  457.       if ($field->needsMultipartForm())
  458.       {
  459.         return true;
  460.       }
  461.     }
  463.     return false;
  464.   }
  466.   /**
  467.    * Renders a field by name.
  468.    *
  469.    * @param string $name       The field name
  470.    * @param string $value      The field value
  471.    * @param array  $attributes An array of HTML attributes to be merged with the current HTML attributes
  472.    * @param array  $errors     An array of errors for the field
  473.    *
  474.    * @return string An HTML string representing the rendered widget
  475.    *
  476.    * @throws InvalidArgumentException when the widget not exist
  477.    */
  478.   public function renderField($name, $value = null, $attributes = array(), $errors = array())
  479.   {
  480.     if (null === $widget = $this[$name])
  481.     {
  482.       throw new InvalidArgumentException(sprintf('The field named "%s" does not exist.', $name));
  483.     }
  485.     if ($widget instanceof sfWidgetFormSchema && $errors && !$errors instanceof sfValidatorErrorSchema)
  486.     {
  487.       $errors = new sfValidatorErrorSchema($errors->getValidator(), array($errors));
  488.     }
  490.     // we clone the widget because we want to change the id format temporarily
  491.     $clone = clone $widget;
  492.     $clone->setIdFormat($this->options['id_format']);
  494.     return $clone->render($this->generateName($name), $value, array_merge($clone->getAttributes(), $attributes), $errors);
  495.   }
  497.   /**
  498.    * Renders the widget.
  499.    *
  500.    * @param string $name       The name of the HTML widget
  501.    * @param mixed  $values     The values of the widget
  502.    * @param array  $attributes An array of HTML attributes
  503.    * @param array  $errors     An array of errors
  504.    *
  505.    * @return string An HTML representation of the widget
  506.    *
  507.    * @throws InvalidArgumentException when values type is not array|ArrayAccess
  508.    */
  509.   public function render($name, $values = array(), $attributes = array(), $errors = array())
  510.   {
  511.     if (null === $values)
  512.     {
  513.       $values = array();
  514.     }
  516.     if (!is_array($values) && !$values instanceof ArrayAccess)
  517.     {
  518.       throw new InvalidArgumentException('You must pass an array of values to render a widget schema');
  519.     }
  521.     $formFormat = $this->getFormFormatter();
  523.     $rows = array();
  524.     $hiddenRows = array();
  525.     $errorRows = array();
  527.     // render each field
  528.     foreach ($this->positions as $name)
  529.     {
  530.       $widget = $this[$name];
  531.       $value = isset($values[$name]) ? $values[$name] : null;
  532.       $error = isset($errors[$name]) ? $errors[$name] : array();
  533.       $widgetAttributes = isset($attributes[$name]) ? $attributes[$name] : array();
  535.       if ($widget instanceof sfWidgetForm && $widget->isHidden())
  536.       {
  537.         $hiddenRows[] = $this->renderField($name, $value, $widgetAttributes);
  538.       }
  539.       else
  540.       {
  541.         $field = $this->renderField($name, $value, $widgetAttributes, $error);
  543.         // don't add a label tag and errors if we embed a form schema
  544.         $label = $widget instanceof sfWidgetFormSchema ? $this->getFormFormatter()->generateLabelName($name) : $this->getFormFormatter()->generateLabel($name);
  545.         $error = $widget instanceof sfWidgetFormSchema ? array() : $error;
  547.         $rows[] = $formFormat->formatRow($label, $field, $error, $this->getHelp($name));
  548.       }
  549.     }
  551.     if ($rows)
  552.     {
  553.       // insert hidden fields in the last row
  554.       for ($i = 0, $max = count($rows); $i < $max; $i++)
  555.       {
  556.         $rows[$i] = strtr($rows[$i], array('%hidden_fields%' => $i == $max - 1 ? implode("\n", $hiddenRows) : ''));
  557.       }
  558.     }
  559.     else
  560.     {
  561.       // only hidden fields
  562.       $rows[0] = implode("\n", $hiddenRows);
  563.     }
  565.     return $this->getFormFormatter()->formatErrorRow($this->getGlobalErrors($errors)).implode('', $rows);
  566.   }
  568.   /**
  569.    * Gets errors that need to be included in global errors.
  570.    *
  571.    * @param array $errors An array of errors
  572.    *
  573.    * @return string An HTML representation of global errors for the widget
  574.    */
  575.   public function getGlobalErrors($errors)
  576.   {
  577.     $globalErrors = array();
  579.     // global errors and errors for non existent fields
  580.     if (null !== $errors)
  581.     {
  582.       foreach ($errors as $name => $error)
  583.       {
  584.         if (!isset($this->fields[$name]))
  585.         {
  586.           $globalErrors[] = $error;
  587.         }
  588.       }
  589.     }
  591.     // errors for hidden fields
  592.     foreach ($this->positions as $name)
  593.     {
  594.       if ($this[$name] instanceof sfWidgetForm && $this[$name]->isHidden())
  595.       {
  596.         if (isset($errors[$name]))
  597.         {
  598.           $globalErrors[$this->getFormFormatter()->generateLabelName($name)] = $errors[$name];
  599.         }
  600.       }
  601.     }
  603.     return $globalErrors;
  604.   }
  606.   /**
  607.    * Generates a name.
  608.    *
  609.    * @param string $name The name
  610.    *
  611.    * @return string The generated name
  612.    */
  613.   public function generateName($name)
  614.   {
  615.     $format = $this->getNameFormat();
  617.     if ('[%s]' == substr($format, -4) && preg_match('/^(.+?)\[(.+)\]$/', $name, $match))
  618.     {
  619.       $name = sprintf('%s[%s][%s]', substr($format, 0, -4), $match[1], $match[2]);
  620.     }
  621.     else if (false !== $format)
  622.     {
  623.       $name = sprintf($format, $name);
  624.     }
  626.     if ($parent = $this->getParent())
  627.     {
  628.       $name = $parent->generateName($name);
  629.     }
  631.     return $name;
  632.   }
  634.   /**
  635.    * Returns true if the schema has a field with the given name (implements the ArrayAccess interface).
  636.    *
  637.    * @param string $name The field name
  638.    *
  639.    * @return bool true if the schema has a field with the given name, false otherwise
  640.    */
  641.   public function offsetExists($name)
  642.   {
  643.     return isset($this->fields[$name]);
  644.   }
  646.   /**
  647.    * Gets the field associated with the given name (implements the ArrayAccess interface).
  648.    *
  649.    * @param string $name The field name
  650.    *
  651.    * @return sfWidget|null The sfWidget instance associated with the given name, null if it does not exist
  652.    */
  653.   public function offsetGet($name)
  654.   {
  655.     return isset($this->fields[$name]) ? $this->fields[$name] : null;
  656.   }
  658.   /**
  659.    * Sets a field (implements the ArrayAccess interface).
  660.    *
  661.    * @param string   $name   The field name
  662.    * @param sfWidget $widget An sfWidget instance
  663.    *
  664.    * @throws InvalidArgumentException when the field is not instance of sfWidget
  665.    */
  666.   public function offsetSet($name, $widget)
  667.   {
  668.     if (!$widget instanceof sfWidget)
  669.     {
  670.       throw new InvalidArgumentException('A field must be an instance of sfWidget.');
  671.     }
  673.     if (!isset($this->fields[$name]))
  674.     {
  675.       $this->positions[] = (string) $name;
  676.     }
  678.     $this->fields[$name] = clone $widget;
  679.     $this->fields[$name]->setParent($this);
  681.     if ($widget instanceof sfWidgetFormSchema)
  682.     {
  683.       $this->fields[$name]->setNameFormat($name.'[%s]');
  684.     }
  685.   }
  687.   /**
  688.    * Removes a field by name (implements the ArrayAccess interface).
  689.    *
  690.    * @param string $name field name
  691.    */
  692.   public function offsetUnset($name)
  693.   {
  694.     unset($this->fields[$name]);
  695.     if (false !== $position = array_search((string) $name, $this->positions))
  696.     {
  697.       unset($this->positions[$position]);
  699.       $this->positions = array_values($this->positions);
  700.     }
  701.   }
  703.   /**
  704.    * Returns an array of fields.
  705.    *
  706.    * @return sfWidget An array of sfWidget instance
  707.    */
  708.   public function getFields()
  709.   {
  710.     return $this->fields;
  711.   }
  713.   /**
  714.    * Gets the positions of the fields.
  715.    *
  716.    * The field positions are only used when rendering the schema with ->render().
  717.    *
  718.    * @return array An ordered array of field names
  719.    */
  720.   public function getPositions()
  721.   {
  722.     return $this->positions;
  723.   }
  725.   /**
  726.    * Sets the positions of the fields.
  727.    *
  728.    * @param array $positions An ordered array of field names
  729.    *
  730.    * @return sfWidget The current widget instance
  731.    *
  732.    * @throws InvalidArgumentException when not all fields set in $positions
  733.    *
  734.    * @see getPositions()
  735.    */
  736.   public function setPositions(array $positions)
  737.   {
  738.     $positions = array_unique(array_values($positions));
  739.     $current   = array_keys($this->fields);
  741.     if ($diff = array_diff($positions, $current))
  742.     {
  743.       throw new InvalidArgumentException('Widget schema does not include the following field(s): '.implode(', ', $diff));
  744.     }
  746.     if ($diff = array_diff($current, $positions))
  747.     {
  748.       throw new InvalidArgumentException('Positions array must include all fields. Missing: '.implode(', ', $diff));
  749.     }
  751.     foreach ($positions as &$position)
  752.     {
  753.       $position = (string) $position;
  754.     }
  756.     $this->positions = $positions;
  758.     return $this;
  759.   }
  761.   /**
  762.    * Moves a field in a given position
  763.    *
  764.    * Available actions are:
  765.    *
  766.    *  * sfWidgetFormSchema::BEFORE
  767.    *  * sfWidgetFormSchema::AFTER
  768.    *  * sfWidgetFormSchema::LAST
  769.    *  * sfWidgetFormSchema::FIRST
  770.    *
  771.    * @param string   $field  The field name to move
  772.    * @param constant $action The action (see above for all possible actions)
  773.    * @param string   $pivot  The field name used for AFTER and BEFORE actions
  774.    *
  775.    * @throws InvalidArgumentException when field not exist
  776.    * @throws InvalidArgumentException when relative field not exist
  777.    * @throws LogicException           when you try to move a field without a relative field
  778.    * @throws LogicException           when the $action not exist
  779.    */
  780.   public function moveField($field, $action, $pivot = null)
  781.   {
  782.     $field = (string) $field;
  783.     if (false === $fieldPosition = array_search($field, $this->positions))
  784.     {
  785.       throw new InvalidArgumentException(sprintf('Field "%s" does not exist.', $field));
  786.     }
  787.     unset($this->positions[$fieldPosition]);
  788.     $this->positions = array_values($this->positions);
  790.     if (null !== $pivot)
  791.     {
  792.       $pivot = (string) $pivot;
  793.       if (false === $pivotPosition = array_search($pivot, $this->positions))
  794.       {
  795.         throw new InvalidArgumentException(sprintf('Field "%s" does not exist.', $pivot));
  796.       }
  797.     }
  799.     switch ($action)
  800.     {
  801.       case sfWidgetFormSchema::FIRST:
  802.         array_unshift($this->positions, $field);
  803.         break;
  804.       case sfWidgetFormSchema::LAST:
  805.         array_push($this->positions, $field);
  806.         break;
  807.       case sfWidgetFormSchema::BEFORE:
  808.         if (null === $pivot)
  809.         {
  810.           throw new LogicException(sprintf('Unable to move field "%s" without a relative field.', $field));
  811.         }
  812.         $this->positions = array_merge(
  813.           array_slice($this->positions, 0, $pivotPosition),
  814.           array($field),
  815.           array_slice($this->positions, $pivotPosition)
  816.         );
  817.         break;
  818.       case sfWidgetFormSchema::AFTER:
  819.         if (null === $pivot)
  820.         {
  821.           throw new LogicException(sprintf('Unable to move field "%s" without a relative field.', $field));
  822.         }
  823.         $this->positions = array_merge(
  824.           array_slice($this->positions, 0, $pivotPosition + 1),
  825.           array($field),
  826.           array_slice($this->positions, $pivotPosition + 1)
  827.         );
  828.         break;
  829.       default:
  830.         throw new LogicException(sprintf('Unknown move operation for field "%s".', $field));
  831.     }
  832.   }
  834.   public function __clone()
  835.   {
  836.     foreach ($this->fields as $name => $field)
  837.     {
  838.       // offsetSet will clone the field and change the parent
  839.       $this[$name] = $field;
  840.     }
  842.     foreach ($this->formFormatters as &$formFormatter)
  843.     {
  844.       $formFormatter = clone $formFormatter;
  845.       $formFormatter->setWidgetSchema($this);
  846.     }
  847.   }
  848. }
Debug toolbar