Détermine si le champ fonctionne avec les tags imbriqués.

@return  boolean
768463
public function isNested() {

        if (is_null($this->isNested)) {
            if ((isset($this->element['mode']) && $this->element['mode'] == 'nested')) {
                $this->isNested = true;
            }
        }

        return $this->isNested;
    }
86959
private function checkImageAltTags() {

        $html = $this->getPageContent();

        // for newly created page
        if ($html == '') {
            return false;
        }

        $dom = $this->createDOMDocumentFromHTML($html);

        $images = $dom->getElementsByTagName('img');

        $imagesWithAltTags = 0;
        foreach($images as $image){
            if($image->hasAttribute('alt') && $image->getAttribute('alt') != ''){
                $imagesWithAltTags++;
            }
        }
        if($imagesWithAltTags == $images->length){
            return true;
        }

        return false;
    }
20445
protected function tagsFromRequest() {
		$tags = $this->owner->getRequest()->getVar('tags') ? $this->owner->getRequest()->getVar('tags') : '';

		if (strlen($tags)) {
			$tags = explode(',', $tags);
		} else {
			$tags = array();
		}
		
		return $tags;
	}
512979
protected function isMatching()/*# : bool */
    {
        if (empty($this->tags)) {
            return true;
        } else {
            return $this->getContainer()->hasTag($this->tags);
        }
    }
780747
public static function getInstantiatedTagObjects()
    {
        $context = self::getInstance();
        foreach ($context->tags as $key => $config) {
            $context->instantiatTag($key);
        }
        
        return $context->tags;
    }
1124400
private function tag_has_default(string $tag){
    return in_array('default', array_values(
      \is_array($this->tags[$tag]) ?
        $this->tags[$tag] :
        $this->tags[$this->tags[$tag]]
    ));
  }
602452
public function isTrue(): bool
    {
        return (
            in_array($this->string, ['ok']) ||
            (true === filter_var($this->string, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE))
        );
    }
1051579
public function hasMonitoredTag()
    {
        if (! empty($this->tags)) {
            return app(EntriesRepository::class)->isMonitoring($this->tags);
        }

        return false;
    }
1267909
public function isPrefix()
    {
        $params = $this->Controller->request->params;
        if (key_exists('prefix', $params)) {
            $prefix = $params['prefix'];
            if ($prefix) {
                return true;
            }
        }
        return false;
    }
186115
public function hasTag ($tag)
	{
		
		foreach ($this->lines as $line)
		{
			if (strpos ($line, '@' . $tag) === 0)
			{
				return TRUE;
			}
		}
		
		return FALSE;
		
	}
13507
protected function isMarkdownable()
    {
        if (!isset($this->isMarkdownable[$this->parser->tagName])) {
            // simply not markdownable

            return false;
        }
        if ($this->parser->isStartTag) {
            $return = true;
            if ($this->keepHTML) {
                $diff = array_diff(array_keys($this->parser->tagAttributes), array_keys($this->isMarkdownable[$this->parser->tagName]));
                if (!empty($diff)) {
                    // non markdownable attributes given
                    $return = false;
                }
            }
            if ($return) {
                foreach ($this->isMarkdownable[$this->parser->tagName] as $attr => $type) {
                    if ($type == 'required' && !isset($this->parser->tagAttributes[$attr])) {
                        // required markdown attribute not given
                        $return = false;
                        break;
                    }
                }
            }
            if (!$return) {
                array_push($this->notConverted, $this->parser->tagName . '::' . implode('/', $this->parser->openTags));
            }

            return $return;
        } else {
            if (!empty($this->notConverted) && end($this->notConverted) === $this->parser->tagName . '::' . implode('/', $this->parser->openTags)) {
                array_pop($this->notConverted);

                return false;
            }

            return true;
        }
    }
1168115
protected function isTagsIntBased($tags)
    {
        return is_int($tags) || (is_array($tags) && isset($tags[0]) && is_int($tags[0]));
    }
876891
public function isVoidElement($tag = null)
    {
        if (null === $tag) {
            $tag = $this->getTag();
        }

        return in_array($tag, $this->voidElements);
    }
104236
protected function tags(&$tags, $simple = false, $delim = ',')
    {
        $tags = array();
        while ($this->tag($tt, $simple)) {
            $tags[] = $tt;
            if (!$this->literal($delim)) {
                break;
            }
        }
        if (count($tags) == 0) {
            return false;
        }

        return true;
    }
1025241
public static function hasTags()
    {
        if (Config::get('store') == 'global') {
            return count(self::$_tagStore);
        } elseif (Config::get('store') == 'internal') {
            return count(Config::getHTMLInstance()->tagStore);
        }
    }
412552
public function getTagFiltersDisplayName()
    {
        $expanded = $this->getTagFiltersExpanded();
        if ($expanded === null) {
            $result = tc('Tags', 'none');
        } elseif (count($expanded) === 0) {
            $result = tc('Tags', 'all');
        } else {
            $list = [];
            foreach ($expanded as $x) {
                switch ($x['operator']) {
                    case '<=':
                        $op = '≤';
                        break;
                    case '>=':
                        $op = '≥';
                        break;
                    default:
                        $op = $x['operator'];
                        break;
                }
                $list[] = "$op {$x['version']}";
            }
            $result = implode(' ∧ ', $list);
        }

        return $result;
    }
730445
public function tagsCount()
    {
        if ( !is_array( $this->IDArray ) || empty( $this->IDArray ) )
            return 0;

        return eZTagsObject::fetchListCount( array( 'id' => array( $this->IDArray ) ) );
    }