FieldGroup.class.php

<?php

class spunQ_FieldGroup extends spunQ_Field implements spunQ_IFieldContainer {

    protected $fields = array();

    public function show($value = NULL, $template = NULL, $templateParameters = array(), $htmlIdPostFix = '') {
        if ($this->useSubmittedValue && $this->container->wasSubmitted() && $this->submittedValueValid()) {
            $value = $this->getSubmittedValue();
        }
        $value = $this->spunQToRaw($value);
        if (!is_array($value)) {
            throw new spunQ_HtmlException('spunQ.html.form.FieldGroup.spunQToRaw.notArray', spunQ_Type::getDescription($value));
        }
        $missingKeys = array_diff_key($this->fields, $value);
        if (!empty($missingKeys)) {
            throw new spunQ_HtmlException('spunQ.html.form.FieldGroup.spunQToRaw.missingKeys', array_keys($missingKeys));
        }
        if (is_string($template)) {
            $templateParameters['value'] = $value;
            $templateParameters['field'] = $this;
            $templateParameters['htmlIdPostFix'] = $htmlIdPostFix;
            template($template, $templateParameters);
        } else {
            foreach ($this->getFields() as $fieldName => $field) {
                $field = $this->getField($fieldName);
                $fieldValue = $value[$fieldName];
                $fieldTemplate = NULL;
                $fieldTemplateParameters = NULL;
                if (isset($template[$fieldName])) {
                    $fieldTemplate = $template[$fieldName];
                }
                if (isset($templateParameters[$fieldName])) {
                    $fieldTemplateParameters = $templateParameters[$fieldName];
                }
                $field->show($fieldValue, $fieldTemplate, $fieldTemplateParameters, $htmlIdPostFix);
                echo '<br/>';
            }
        }
        return $this;
    }

    public function getFields() {
        return $this->fields;
    }

    public function getField($name) {
        if (!isset($this->fields[$name])) {
            throw new spunQ_HtmlException('spunQ.html.form.FieldDoesNotExist', $this->getName(), $name);
        }
        return $this->fields[$name];
    }

    public function __clone() {
        foreach ($this->fields as &$field) {
            $field = clone($field);
            $field->setContainer($this);
        }
        unset($field);
        parent::__clone();
        return NULL;
    }

    public function wasSubmitted() {
        return $this->container->wasSubmitted();
    }

    public function addField(spunQ_IField $field) {
        $this->fields[$field->getName()] = $field;
        $field->setContainer($this);
        return $this;
    }

    public function removeField(spunQ_IField $field) {
        unset($this->fields[$field->getName()]);
        return $this;
    }

    public function getTypeString() {
        return $this->getTypePath();
    }

    public function getFieldHtmlId($field, $postfix) {
        return $this->getHtmlId($postfix) . '-' . preg_replace('/[^a-z0-9-]/i', '-', $field->getName());
    }

    public function getFieldHtmlName($field) {
        return $this->getHtmlName() . '[' . $field->getName() . ']';
    }

    public function submittedValueValid() {
        foreach ($this->fields as $field) {
            if (!$field->submittedValueValid()) {
                return false;
            }
        }
        return parent::submittedValueValid();
    }

    public function showValidatorsJs() {
        foreach ($this->fields as $field) {
            $field->showValidatorsJs();
        }
        return parent::showValidatorsJs();
    }

    public function getFieldByPath($path) {
        if (is_string($path)) {
            $path = explode('.', $path);
        }
        $part = reset($path);
        foreach ($this->fields as $field) {
            if ($field->getTypePathPart() === $part) {
                array_shift($path);
                if (empty($path)) {
                    return $field;
                }
                return $field->getFieldByPath($path);
            }
        }
        return parent::getFieldByPath($path);
    }

    public function setUseSubmittedValue($useSubmittedValue = true) {
        parent::setUseSubmittedValue($useSubmittedValue);
        foreach ($this->fields as $field) {
            $field->setUseSubmittedValue($useSubmittedValue);
        }
        return $this;
    }

    public function getDisplayValue($originalValue) {
        if ($this->getUseSubmittedValue() && $this->container->wasSubmitted()) {
            return $this->spunQToRaw($this->getSubmittedValue());
        }
        return $this->spunQToRaw($originalValue);
    }

    protected function spunQToRaw($value) {
        if ($value === NULL) {
            $value = array();
            foreach ($this->getFields() as $fieldName => $field) {
                $value[$fieldName] = NULL;
            }
        }
        return parent::spunQToRaw($value);
    }

    protected function rawToSpunQ(&$value) {
        if ($value === NULL) {
            $value = array();
        } elseif (!is_array($value)) {
            throw new spunQ_InvalidRawValueException('spunQ.html.form.FieldGroup.processSubmission.NotAnArray', spunQ_Type::getDescription($value));
        }
        $fieldsSuccess = true;
        foreach ($this->fields as $fieldName => $field) {
            if (!isset($value[$fieldName])) {
                $value[$fieldName] = NULL;
            }
            $fieldsSuccess = $field->_processSubmission($value[$fieldName]) && $fieldsSuccess;
        }
        if (!$fieldsSuccess) {
            return false;
        }
        return parent::rawToSpunQ($value);
    }

}

---