AbstractElementView.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Form\View\Form\Element;

abstract class AbstractElementView {

    protected $model;

    protected $expectedModelName;

    protected $elementWrap = '
        <li>
            <element />
        </li>
    ';

    protected $noWrap = FALSE;

    public function __construct(\TYPO3\CMS\Form\Domain\Model\Element\AbstractElement $model) {
        if ($this->isValidModel($model) === FALSE) {
            throw new \RuntimeException('Unexpected model "' . get_class($model) . '".');
        }
        $this->model = $model;
    }

    protected function isValidModel(\TYPO3\CMS\Form\Domain\Model\Element\AbstractElement $model) {
        return is_a($model, $this->getExpectedModelName($model));
    }

    protected function getExpectedModelName(\TYPO3\CMS\Form\Domain\Model\Element\AbstractElement $model) {
        if (!isset($this->expectedModelName)) {
            $specificName = \TYPO3\CMS\Form\Utility\FormUtility::getInstance()->getLastPartOfClassName($this);
            $this->expectedModelName = 'TYPO3\\CMS\\Form\\Domain\\Model\\Element\\' . $specificName . 'Element';
        }
        return $this->expectedModelName;
    }

    protected function parseXML(\DOMDocument $dom, \DOMNode $reference) {
        $node = $reference->firstChild;
        while (!is_null($node)) {
            $deleteNode = FALSE;
            $nodeType = $node->nodeType;
            $nodeName = $node->nodeName;
            switch ($nodeType) {
                case XML_TEXT_NODE:
                    break;
                case XML_ELEMENT_NODE:
                    switch ($nodeName) {
                        case 'containerWrap':
                            $this->replaceNodeWithFragment($dom, $node, $this->render('containerWrap'));
                            $deleteNode = TRUE;
                            break;
                        case 'elements':
                            $replaceNode = $this->getChildElements($dom);
                            $node->parentNode->replaceChild($replaceNode, $node);
                            break;
                        case 'button':

                        case 'fieldset':

                        case 'form':

                        case 'input':

                        case 'optgroup':

                        case 'select':
                            $this->setAttributes($node);
                            break;
                        case 'label':
                            if (!strrchr(get_class($this), 'AdditionalElement')) {
                                if ($this->model->additionalIsSet($nodeName)) {
                                    $this->replaceNodeWithFragment($dom, $node, $this->getAdditional('label'));
                                }
                                $deleteNode = TRUE;
                            } else {
                                if ($this->model->additionalIsSet($nodeName)) {
                                    $this->setAttributeWithValueofOtherAttribute($node, 'for', 'id');
                                } else {
                                    $deleteNode = TRUE;
                                }
                            }
                            break;
                        case 'legend':
                            if (!strrchr(get_class($this), 'AdditionalElement')) {
                                if ($this->model->additionalIsSet($nodeName)) {
                                    $this->replaceNodeWithFragment($dom, $node, $this->getAdditional('legend'));
                                }
                                $deleteNode = TRUE;
                            }
                            break;
                        case 'textarea':

                        case 'option':
                            $this->setAttributes($node);
                            $appendNode = $dom->createTextNode($this->getElementData());
                            $node->appendChild($appendNode);
                            break;
                        case 'errorvalue':

                        case 'labelvalue':

                        case 'legendvalue':

                        case 'mandatoryvalue':
                            $replaceNode = $dom->createTextNode($this->getAdditionalValue());
                            $node->parentNode->insertBefore($replaceNode, $node);
                            $deleteNode = TRUE;
                            break;
                        case 'mandatory':

                        case 'error':
                            if ($this->model->additionalIsSet($nodeName)) {
                                $this->replaceNodeWithFragment($dom, $node, $this->getAdditional($nodeName));
                            }
                            $deleteNode = TRUE;
                            break;
                        case 'content':

                        case 'header':

                        case 'textblock':
                            $replaceNode = $dom->createTextNode($this->getElementData(FALSE));
                            $node->parentNode->insertBefore($replaceNode, $node);
                            $deleteNode = TRUE;
                            break;
                    }
                    break;
            }
            // Parse the child nodes of this node if available
            if ($node->hasChildNodes()) {
                $this->parseXML($dom, $node);
            }
            // Get the current node for deletion if replaced. We need this because nextSibling can be empty
            $oldNode = $node;
            // Go to next sibling to parse
            $node = $node->nextSibling;
            // Delete the old node. This can only be done after going to the next sibling
            if ($deleteNode) {
                $oldNode->parentNode->removeChild($oldNode);
            }
        }
    }

    public function render($type = 'element', $returnFirstChild = TRUE) {
        // Disables the functionality to allow external entities to be loaded when parsing the XML, must be kept
        $previousValueOfEntityLoader = libxml_disable_entity_loader(TRUE);
        $useLayout = $this->getLayout((string) $type);
        $dom = new \DOMDocument('1.0', 'utf-8');
        $dom->formatOutput = TRUE;
        $dom->preserveWhiteSpace = FALSE;
        $dom->loadXML($useLayout);
        $this->parseXML($dom, $dom);
        libxml_disable_entity_loader($previousValueOfEntityLoader);
        if ($returnFirstChild) {
            return $dom->firstChild;
        } else {
            return $dom;
        }
    }

    public function getLayout($type) {
        $layoutHandler = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Form\\Layout');
        switch ($type) {
            case 'element':
                $layoutDefault = $this->layout;
                $objectClass = get_class($this);
                $type = \TYPO3\CMS\Form\Utility\FormUtility::getInstance()->getLastPartOfClassName($this, TRUE);
                if (strrchr($objectClass, 'AdditionalElement')) {
                    $additionalModel = $this->model->getAdditionalObjectByKey($type);
                    $layoutOverride = $additionalModel->getLayout();
                } else {
                    $layoutOverride = $this->model->getLayout();
                }
                $layout = $layoutHandler->getLayoutByObject($type, $layoutDefault, $layoutOverride);
                break;
            case 'elementWrap':
                $layoutDefault = $this->elementWrap;
                $elementWrap = $layoutHandler->getLayoutByObject($type, $layoutDefault, $layoutOverride);
                $layout = str_replace('<element />', $this->getLayout('element'), $elementWrap);
                break;
            case 'containerWrap':
                $layoutDefault = $this->containerWrap;
                $layout = $layoutHandler->getLayoutByObject($type, $layoutDefault, $layoutOverride);
                break;
        }
        return $layout;
    }

    public function replaceNodeWithFragment(\DOMDocument $dom, \DOMNode $node, \DOMNode $value) {
        $replaceNode = $dom->createDocumentFragment();
        $domNode = $dom->importNode($value, TRUE);
        $replaceNode->appendChild($domNode);
        $node->parentNode->insertBefore($replaceNode, $node);
    }

    public function setAttributes(\DOMElement $domElement) {
        $attributes = $this->model->getAttributes();
        foreach ($attributes as $key => $attribute) {
            if (!empty($attribute)) {
                $value = htmlspecialchars($attribute->getValue(), ENT_QUOTES);
                if ($value !== '') {
                    $domElement->setAttribute($key, $value);
                }
            }
        }
    }

    public function setAttribute(\DOMElement $domElement, $key) {
        $value = htmlspecialchars($this->model->getAttributeValue((string) $key), ENT_QUOTES);
        if ($value !== '') {
            $domElement->setAttribute($key, $value);
        }
    }

    public function setAttributeWithValueofOtherAttribute(\DOMElement $domElement, $key, $other) {
        $value = htmlspecialchars($this->model->getAttributeValue((string) $other), ENT_QUOTES);
        if ($value !== '') {
            $domElement->setAttribute($key, $value);
        }
    }

    protected function createAdditional($class) {
        $class = strtolower((string) $class);
        $className = 'TYPO3\\CMS\\Form\\View\\Form\\Additional\\' . ucfirst($class) . 'AdditionalElementView';
        return \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance($className, $this->model);
    }

    public function getAdditional($key) {
        $additional = $this->createAdditional($key);
        return $additional->render();
    }

    public function getElementData($encodeSpecialCharacters = TRUE) {
        $elementData = $this->model->getData();
        if ($encodeSpecialCharacters) {
            $elementData = htmlspecialchars($elementData, ENT_QUOTES);
        }
        return $elementData;
    }

    public function getElementWrapId() {
        $elementId = (int)$this->model->getElementId();
        $wrapId = 'csc-form-' . $elementId;
        return $wrapId;
    }

    public function getElementWrapType() {
        $elementType = strtolower(\TYPO3\CMS\Form\Utility\FormUtility::getInstance()->getLastPartOfClassName($this));
        $wrapType = 'csc-form-element csc-form-element-' . $elementType;
        return $wrapType;
    }

    public function getElementWraps() {
        $wraps = array(
            $this->getElementWrapId(),
            $this->getElementWrapType()
        );
        return implode(' ', $wraps);
    }

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

}