@param float $resolutionX
@param float $resolutionY

@return $this
965727
public function setResolution($resolutionX, $resolutionY)
    {
        $this->resolutionX = $resolutionX;
        $this->resolutionY = $resolutionY;

        return $this;
    }
738703
public static function fromInvalidResolver($resolver) : self
    {
        return new self(sprintf(
            'Invalid resolver found, expected `' . ResolverInterface::class . '`, `%s` given.',
            is_object($resolver) ? get_class($resolver) : gettype($resolver)
        ));
    }
1067825
public function setResolutionInfo(\AgentSIB\Diadoc\Api\Proto\Events\ResolutionInfo $value = null)
    {
        $this->ResolutionInfo = $value;
    }
1292927
public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $defaultConfigs = array(
            'datagrid_exists' => $this->datagridExists,   
        );
        
        $resolver->setDefaults(array(
            'allow_add' => true,
            'allow_delete' => true,
            'prototype' => true,
            'by_reference' => false,
            'type' => 'thrace_multi_select',
            'translation_domain' => 'ThraceFormBundle',
            'configs' => $defaultConfigs,
        ));
        
        $resolver->setNormalizers(array(            
            'configs' => function (Options $options, $value) use ($defaultConfigs){
                $configs = array_replace_recursive($defaultConfigs, $value);
                return $configs;
            }
        ));
          
        $resolver->setRequired(array('grid'));
        
        $resolver->setAllowedTypes(array(
            'grid' => array('object'),
        ));
    }
333547
public function addCustomResolver($id, $resolver)
    {
        if (!$resolver instanceof EventResolverInterface) {
            $this->handleException(new InvalidServiceException(
                'Resolver Service must implement'.EventResolverInterface::class
            ));

            return;
        }

        $this->customResolvers[$id] = $resolver;
    }
668220
public function configureOptions(OptionsResolver $resolver)
    {
        $labelTrueNormalizer = function (Options $options, $value) {
            return !is_null($value) ? (string) $value : $this->humanize($options['value_true']);
        };

        $labelFalseNormalizer = function (Options $options, $value) {
            return !is_null($value) ? (string) $value : $this->humanize($options['value_false']);
        };

        $choicesNormalizer = function (Options $options) {
            return [
                $options['label_true'] => $options['value_true'],
                $options['label_false'] => $options['value_false'],
            ];
        };

        $expandedNormalizer = function (Options $options) {
            return 'choice' !== $options['widget'];
        };

        $multipleNormalizer = function () {
            return false;
        };

        $resolver->setDefaults([
            'label_true' => null,
            'label_false' => null,
            'value_true' => 'yes',
            'value_false' => 'no',
            'widget' => 'choice',
        ]);

        $resolver->setNormalizer('label_true', $labelTrueNormalizer);
        $resolver->setNormalizer('label_false', $labelFalseNormalizer);
        $resolver->setNormalizer('choices', $choicesNormalizer);
        $resolver->setNormalizer('expanded', $expandedNormalizer);
        $resolver->setNormalizer('multiple', $multipleNormalizer);

        $resolver->setAllowedTypes('value_true', ['string', 'integer', 'float']);
        $resolver->setAllowedTypes('value_false', ['string', 'integer', 'float']);
        $resolver->setAllowedTypes('label_true', ['string', 'null']);
        $resolver->setAllowedTypes('label_false', ['string', 'null']);

        $resolver->setAllowedValues('widget', ['choice', 'radio']);
    }
544489
public function addResolutionRequestDenials(\AgentSIB\Diadoc\Api\Proto\Events\ResolutionRequestDenialAttachment $value)
    {
        if ($this->ResolutionRequestDenials === null) {
            $this->ResolutionRequestDenials = new \Protobuf\MessageCollection();
        }

        $this->ResolutionRequestDenials->add($value);
    }
48527
public function resolve($scopeType, $scopeCode)
    {
        if (isset($this->resolvedScopeCodes[$scopeType][$scopeCode])) {
            return $this->resolvedScopeCodes[$scopeType][$scopeCode];
        }

        $resolverScopeCode = $scopeCode;

        if (($scopeCode === null || is_numeric($scopeCode))
            && $scopeType !== ScopeConfigInterface::SCOPE_TYPE_DEFAULT
        ) {
            $scopeResolver     = $this->scopeResolverPool->get($scopeType);
            $resolverScopeCode = $scopeResolver->getScope($scopeCode);
        }

        if ($resolverScopeCode instanceof \Magento\Framework\App\ScopeInterface) {
            $resolverScopeCode = $resolverScopeCode->getCode();
        }

        $this->resolvedScopeCodes[$scopeType][$scopeCode] = $resolverScopeCode;

        return $resolverScopeCode;
    }
864367
public function foreignKeySuffix($foreignKeySuffix = null)
    {
        if ($foreignKeySuffix === null)
        {
            return $this->_foreignKeySuffix;
        }
        $this->_foreignKeySuffix = $foreignKeySuffix;

        return $this;
    }
521157
public function resizeXorY($x, $y)
    {
        if ($x > $y) {
            $this->resizeX($x);
        } else {
            $this->resizeY($y);
        }
    }
1223502
public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setRequired(
            [
                'family',
            ]
        );
        $resolver->setAllowedTypes('family', ['string', FamilyInterface::class]);
        $resolver->setDefaults(
            [
                'repository' => null,
                'ignore_missing' => true,
            ]
        );
        $resolver->setAllowedTypes('repository', ['NULL', DataRepository::class]);
        $resolver->setAllowedTypes('ignore_missing', ['bool']);

        /** @noinspection PhpUnusedParameterInspection */
        $resolver->setNormalizer(
            'family',
            function (Options $options, $value) {
                if ($value instanceof FamilyInterface) {
                    return $value;
                }

                return $this->familyRegistry->getFamily($value);
            }
        );
        $resolver->setNormalizer(
            'repository',
            function (Options $options, $value) {
                if ($value instanceof DataRepository) {
                    return $value;
                }
                /** @var FamilyInterface $family */
                $family = $options['family'];

                return $this->entityManager->getRepository($family->getDataClass());
            }
        );
    }
542737
public function load($resolveXInclude = false){
        
        $returnValue = null;

        if(!$this->valid){
            libxml_use_internal_errors(true); //retrieve errors if no validation has been done previously
        }

        //load it using the DOMDocument library
        $xml = new DOMDocument();
        
        switch($this->sourceType){
            case self::SOURCE_FLYFILE:
                if ($this->source->exists()) {
                    $xml->load($this->source->read());
                }
                break;
            case self::SOURCE_FILE:
                $xml->load($this->source);
                break;
            case self::SOURCE_URL:
                $xmlContent = tao_helpers_Request::load($this->source, true);
                $xml->loadXML($xmlContent);
                break;
            case self::SOURCE_STRING:
                $xml->loadXML($this->source);
                break;
        }

        if($xml !== false){

            $basePath = '';
            if($this->sourceType == self::SOURCE_FILE || $this->sourceType == self::SOURCE_URL){
                $basePath = dirname($this->source).'/';
            }
            //build the item from the xml
            $parserFactory = new ParserFactory($xml, $basePath);
            try{
                $returnValue = $parserFactory->load();
            }catch(UnsupportedQtiElement $e){
                $this->addError($e);
            }

            if(!$this->valid){
                $this->valid = true;
                libxml_clear_errors();
            }
        }else if(!$this->valid){
            $this->addErrors(libxml_get_errors());
            libxml_clear_errors();
        }

        return $returnValue;
    }
1365364
public function setResolution(\BlackForest\PiwikBundle\Entity\PiwikResolution $resolution = null)
    {
        $this->resolution = $resolution;

        return $this;
    }
1006879
public function setLiveInfoPosition($positionX, $positionY, $positionZ = null)
    {
        $this->setPositionProperty($this->liveInfoProperties, $positionX, $positionY, $positionZ);
        return $this;
    }
985635
public function setX($x)
    {

        $this->x = MathUtil::capValue($x, 0, XyzColorInterface::REF_X);

        return $this;
    }
740476
public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        parent::setDefaultOptions($resolver);

        $resolver
            ->setDefaults(array(
                'max_length' => function(Options $options, $previous)
                {
                    if(null !== ($len = $options['field']->getMaxLength()))
                    {
                        return $len;
                    }
                    return $previous;
                }
        ));
    }
614164
public function setChronoPosition($positionX, $positionY, $positionZ = null)
    {
        $this->setPositionProperty($this->chronoProperties, $positionX, $positionY, $positionZ);
        return $this;
    }