vendor/pimcore/pimcore/models/Asset/Image/Thumbnail/Config.php line 950

Open in your IDE?
  1. <?php
  3. /**
  4.  * Pimcore
  5.  *
  6.  * This source file is available under two different licenses:
  7.  * - GNU General Public License version 3 (GPLv3)
  8.  * - Pimcore Commercial License (PCL)
  9.  * Full copyright and license information is available in
  10.  * LICENSE.md which is distributed with this source code.
  11.  *
  12.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  14.  */
  16. namespace Pimcore\Model\Asset\Image\Thumbnail;
  18. use Pimcore\Cache\RuntimeCache;
  19. use Pimcore\Logger;
  20. use Pimcore\Model;
  21. use Pimcore\Tool\Serialize;
  23. /**
  24.  * @method bool isWriteable()
  25.  * @method string getWriteTarget()
  26.  * @method void delete(bool $forceClearTempFiles = false)
  27.  * @method void save(bool $forceClearTempFiles = false)
  28.  */
  29. final class Config extends Model\AbstractModel
  30. {
  31.     use Model\Asset\Thumbnail\ClearTempFilesTrait;
  33.     /**
  34.      * @internal
  35.      */
  36.     protected const PREVIEW_THUMBNAIL_NAME = 'pimcore-system-treepreview';
  38.     /**
  39.      * format of array:
  40.      * array(
  41.      array(
  42.      "method" => "myName",
  43.      "arguments" =>
  44.      array(
  45.      "width" => 345,
  46.      "height" => 200
  47.      )
  48.      )
  49.      * )
  50.      *
  51.      * @internal
  52.      *
  53.      * @var array
  54.      */
  55.     protected $items = [];
  57.     /**
  58.      * @internal
  59.      *
  60.      * @var array
  61.      */
  62.     protected $medias = [];
  64.     /**
  65.      * @internal
  66.      *
  67.      * @var string
  68.      */
  69.     protected $name = '';
  71.     /**
  72.      * @internal
  73.      *
  74.      * @var string
  75.      */
  76.     protected $description = '';
  78.     /**
  79.      * @internal
  80.      *
  81.      * @var string
  82.      */
  83.     protected $group = '';
  85.     /**
  86.      * @internal
  87.      *
  88.      * @var string
  89.      */
  90.     protected $format = 'SOURCE';
  92.     /**
  93.      * @internal
  94.      *
  95.      * @var int
  96.      */
  97.     protected $quality = 85;
  99.     /**
  100.      * @internal
  101.      *
  102.      * @var float|null
  103.      */
  104.     protected $highResolution;
  106.     /**
  107.      * @internal
  108.      *
  109.      * @var bool
  110.      */
  111.     protected $preserveColor = false;
  113.     /**
  114.      * @internal
  115.      *
  116.      * @var bool
  117.      */
  118.     protected $preserveMetaData = false;
  120.     /**
  121.      * @internal
  122.      *
  123.      * @var bool
  124.      */
  125.     protected $rasterizeSVG = false;
  127.     /**
  128.      * @internal
  129.      *
  130.      * @var bool
  131.      */
  132.     protected $downloadable = false;
  134.     /**
  135.      * @internal
  136.      *
  137.      * @var int|null
  138.      */
  139.     protected $modificationDate;
  141.     /**
  142.      * @internal
  143.      *
  144.      * @var int|null
  145.      */
  146.     protected $creationDate;
  148.     /**
  149.      * @internal
  150.      *
  151.      * @var string|null
  152.      */
  153.     protected $filenameSuffix;
  155.     /**
  156.      * @internal
  157.      *
  158.      * @var bool
  159.      */
  160.     protected $preserveAnimation = false;
  162.     /**
  163.      * @internal
  164.      *
  165.      * @param string|array|self $config
  166.      *
  167.      * @return self|null
  168.      */
  169.     public static function getByAutoDetect($config)
  170.     {
  171.         $thumbnail = null;
  173.         if (is_string($config)) {
  174.             try {
  175.                 $thumbnail = self::getByName($config);
  176.             } catch (\Exception $e) {
  177.                 Logger::error('requested thumbnail ' . $config . ' is not defined');
  179.                 return null;
  180.             }
  181.         } elseif (is_array($config)) {
  182.             // check if it is a legacy config or a new one
  183.             if (array_key_exists('items', $config)) {
  184.                 $thumbnail = self::getByArrayConfig($config);
  185.             } else {
  186.                 $thumbnail = self::getByLegacyConfig($config);
  187.             }
  188.         } elseif ($config instanceof self) {
  189.             $thumbnail = $config;
  190.         }
  192.         return $thumbnail;
  193.     }
  195.     /**
  196.      * @param string $name
  197.      *
  198.      * @return null|Config
  199.      *
  200.      * @throws \Exception
  201.      */
  202.     public static function getByName($name)
  203.     {
  204.         $cacheKey = self::getCacheKey($name);
  206.         if ($name === self::PREVIEW_THUMBNAIL_NAME) {
  207.             return self::getPreviewConfig();
  208.         }
  210.         try {
  211.             $thumbnail = RuntimeCache::get($cacheKey);
  212.             if (!$thumbnail) {
  213.                 throw new \Exception('Thumbnail in registry is null');
  214.             }
  216.             $thumbnail->setName($name);
  217.         } catch (\Exception $e) {
  218.             try {
  219.                 $thumbnail = new self();
  220.                 /** @var Model\Asset\Image\Thumbnail\Config\Dao $dao */
  221.                 $dao = $thumbnail->getDao();
  222.                 $dao->getByName($name);
  223.                 RuntimeCache::set($cacheKey, $thumbnail);
  224.             } catch (Model\Exception\NotFoundException $e) {
  225.                 return null;
  226.             }
  227.         }
  229.         // only return clones of configs, this is necessary since we cache the configs in the registry (see above)
  230.         // sometimes, e.g. when using the cropping tools, the thumbnail configuration is modified on-the-fly, since
  231.         // pass-by-reference this modifications would then go to the cache/registry (singleton), by cloning the config
  232.         // we can bypass this problem in an elegant way without parsing the XML config again and again
  233.         $clone = clone $thumbnail;
  235.         return $clone;
  236.     }
  238.     /**
  239.      * @param string $name
  240.      *
  241.      * @return string
  242.      */
  243.     protected static function getCacheKey(string $name): string
  244.     {
  245.         return 'imagethumb_' . crc32($name);
  246.     }
  248.     /**
  249.      * @param string $name
  250.      *
  251.      * @return bool
  252.      */
  253.     public static function exists(string $name): bool
  254.     {
  255.         $cacheKey = self::getCacheKey($name);
  256.         if (RuntimeCache::isRegistered($cacheKey)) {
  257.             return true;
  258.         }
  260.         if ($name === self::PREVIEW_THUMBNAIL_NAME) {
  261.             return true;
  262.         }
  264.         return (bool) self::getByName($name);
  265.     }
  267.     /**
  268.      * @internal
  269.      *
  270.      * @return Config
  271.      */
  272.     public static function getPreviewConfig()
  273.     {
  274.         $customPreviewImageThumbnail = \Pimcore::getContainer()->getParameter('pimcore.config')['assets']['preview_image_thumbnail'];
  275.         $thumbnail = null;
  277.         if ($customPreviewImageThumbnail) {
  278.             $thumbnail = self::getByName($customPreviewImageThumbnail);
  279.         }
  281.         if (!$thumbnail) {
  282.             $thumbnail = new self();
  283.             $thumbnail->setName(self::PREVIEW_THUMBNAIL_NAME);
  284.             $thumbnail->addItem('scaleByWidth', [
  285.                 'width' => 400,
  286.             ]);
  287.             $thumbnail->addItem('setBackgroundImage', [
  288.                 'path' => '/bundles/pimcoreadmin/img/tree-preview-transparent-background.png',
  289.                 'mode' => 'asTexture',
  290.             ]);
  291.             $thumbnail->setQuality(60);
  292.             $thumbnail->setFormat('PJPEG');
  293.         }
  295.         $thumbnail->setHighResolution(2);
  297.         return $thumbnail;
  298.     }
  300.     /**
  301.      * @param string $name
  302.      */
  303.     protected function createMediaIfNotExists($name)
  304.     {
  305.         if (!array_key_exists($name, $this->medias)) {
  306.             $this->medias[$name] = [];
  307.         }
  308.     }
  310.     /**
  311.      * @internal
  312.      *
  313.      * @param string $name
  314.      * @param array $parameters
  315.      * @param string $media
  316.      *
  317.      * @return bool
  318.      */
  319.     public function addItem($name, $parameters, $media = null)
  320.     {
  321.         $item = [
  322.             'method' => $name,
  323.             'arguments' => $parameters,
  324.         ];
  326.         // default is added to $this->items for compatibility reasons
  327.         if (!$media || $media == 'default') {
  328.             $this->items[] = $item;
  329.         } else {
  330.             $this->createMediaIfNotExists($media);
  331.             $this->medias[$media][] = $item;
  332.         }
  334.         return true;
  335.     }
  337.     /**
  338.      * @internal
  339.      *
  340.      * @param int $position
  341.      * @param string $name
  342.      * @param array $parameters
  343.      * @param string $media
  344.      *
  345.      * @return bool
  346.      */
  347.     public function addItemAt($position, $name, $parameters, $media = null)
  348.     {
  349.         if (!$media || $media == 'default') {
  350.             $itemContainer = &$this->items;
  351.         } else {
  352.             $this->createMediaIfNotExists($media);
  353.             $itemContainer = &$this->medias[$media];
  354.         }
  356.         array_splice($itemContainer, $position, 0, [[
  357.             'method' => $name,
  358.             'arguments' => $parameters,
  359.         ]]);
  361.         return true;
  362.     }
  364.     /**
  365.      * @internal
  366.      */
  367.     public function resetItems()
  368.     {
  369.         $this->items = [];
  370.         $this->medias = [];
  371.     }
  373.     /**
  374.      * @param string $name
  375.      *
  376.      * @return bool
  377.      */
  378.     public function selectMedia($name)
  379.     {
  380.         if (preg_match('/^[0-9a-f]{8}$/', $name)) {
  381.             $hash = $name;
  382.         } else {
  383.             $hash = hash('crc32b', $name);
  384.         }
  386.         foreach ($this->medias as $key => $value) {
  387.             $currentHash = hash('crc32b', $key);
  388.             if ($key === $name || $currentHash === $hash) {
  389.                 $this->setItems($value);
  390.                 $this->setFilenameSuffix('media--' . $currentHash . '--query');
  392.                 return true;
  393.             }
  394.         }
  396.         return false;
  397.     }
  399.     /**
  400.      * @param string $description
  401.      *
  402.      * @return $this
  403.      */
  404.     public function setDescription($description)
  405.     {
  406.         $this->description = $description;
  408.         return $this;
  409.     }
  411.     /**
  412.      * @return string
  413.      */
  414.     public function getDescription()
  415.     {
  416.         return $this->description;
  417.     }
  419.     /**
  420.      * @param array $items
  421.      *
  422.      * @return $this
  423.      */
  424.     public function setItems($items)
  425.     {
  426.         $this->items = $items;
  428.         return $this;
  429.     }
  431.     /**
  432.      * @return array
  433.      */
  434.     public function getItems()
  435.     {
  436.         return $this->items;
  437.     }
  439.     /**
  440.      * @param string $name
  441.      *
  442.      * @return $this
  443.      */
  444.     public function setName($name)
  445.     {
  446.         $this->name = $name;
  448.         return $this;
  449.     }
  451.     /**
  452.      * @return string
  453.      */
  454.     public function getName()
  455.     {
  456.         return $this->name;
  457.     }
  459.     /**
  460.      * @param string $format
  461.      *
  462.      * @return $this
  463.      */
  464.     public function setFormat($format)
  465.     {
  466.         $this->format = $format;
  468.         return $this;
  469.     }
  471.     /**
  472.      * @return string
  473.      */
  474.     public function getFormat()
  475.     {
  476.         return $this->format;
  477.     }
  479.     /**
  480.      * @param int $quality
  481.      *
  482.      * @return $this
  483.      */
  484.     public function setQuality($quality)
  485.     {
  486.         if ($quality) {
  487.             $this->quality = (int) $quality;
  488.         }
  490.         return $this;
  491.     }
  493.     /**
  494.      * @return int
  495.      */
  496.     public function getQuality()
  497.     {
  498.         return $this->quality;
  499.     }
  501.     /**
  502.      * @param float $highResolution
  503.      */
  504.     public function setHighResolution($highResolution)
  505.     {
  506.         $this->highResolution = (float) $highResolution;
  507.     }
  509.     /**
  510.      * @return float|null
  511.      */
  512.     public function getHighResolution()
  513.     {
  514.         return $this->highResolution;
  515.     }
  517.     /**
  518.      * @param array $medias
  519.      */
  520.     public function setMedias($medias)
  521.     {
  522.         $this->medias = $medias;
  523.     }
  525.     /**
  526.      * @return array
  527.      */
  528.     public function getMedias()
  529.     {
  530.         return $this->medias;
  531.     }
  533.     /**
  534.      * @return bool
  535.      */
  536.     public function hasMedias()
  537.     {
  538.         return !empty($this->medias);
  539.     }
  541.     /**
  542.      * @param string $filenameSuffix
  543.      */
  544.     public function setFilenameSuffix($filenameSuffix)
  545.     {
  546.         $this->filenameSuffix = $filenameSuffix;
  547.     }
  549.     /**
  550.      * @return string|null
  551.      */
  552.     public function getFilenameSuffix()
  553.     {
  554.         return $this->filenameSuffix;
  555.     }
  557.     /**
  558.      * @internal
  559.      *
  560.      * @param array $config
  561.      *
  562.      * @return self
  563.      */
  564.     public static function getByArrayConfig($config)
  565.     {
  566.         $pipe = new self();
  568.         if (isset($config['format']) && $config['format']) {
  569.             $pipe->setFormat($config['format']);
  570.         }
  571.         if (isset($config['quality']) && $config['quality']) {
  572.             $pipe->setQuality($config['quality']);
  573.         }
  574.         if (isset($config['items']) && $config['items']) {
  575.             $pipe->setItems($config['items']);
  576.         }
  578.         if (isset($config['highResolution']) && $config['highResolution']) {
  579.             $pipe->setHighResolution($config['highResolution']);
  580.         }
  582.         // set name
  583.         $hash = md5(Serialize::serialize($pipe));
  584.         $pipe->setName('auto_' . $hash);
  586.         return $pipe;
  587.     }
  589.     /**
  590.      * This is mainly here for backward compatibility
  591.      *
  592.      * @internal
  593.      *
  594.      * @param array $config
  595.      *
  596.      * @return self
  597.      */
  598.     public static function getByLegacyConfig($config)
  599.     {
  600.         $pipe = new self();
  602.         if (isset($config['format'])) {
  603.             $pipe->setFormat($config['format']);
  604.         }
  606.         if (isset($config['quality'])) {
  607.             $pipe->setQuality($config['quality']);
  608.         }
  610.         if (isset($config['cover'])) {
  611.             $pipe->addItem('cover', [
  612.                 'width' => $config['width'],
  613.                 'height' => $config['height'],
  614.                 'positioning' => ((isset($config['positioning']) && !empty($config['positioning'])) ? (string)$config['positioning'] : 'center'),
  615.                 'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  616.             ]);
  617.         } elseif (isset($config['contain'])) {
  618.             $pipe->addItem('contain', [
  619.                 'width' => $config['width'],
  620.                 'height' => $config['height'],
  621.                 'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  622.             ]);
  623.         } elseif (isset($config['frame'])) {
  624.             $pipe->addItem('frame', [
  625.                 'width' => $config['width'],
  626.                 'height' => $config['height'],
  627.                 'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  628.             ]);
  629.         } elseif (isset($config['aspectratio']) && $config['aspectratio']) {
  630.             if (isset($config['height']) && isset($config['width']) && $config['height'] > 0 && $config['width'] > 0) {
  631.                 $pipe->addItem('contain', [
  632.                     'width' => $config['width'],
  633.                     'height' => $config['height'],
  634.                     'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  635.                 ]);
  636.             } elseif (isset($config['height']) && $config['height'] > 0) {
  637.                 $pipe->addItem('scaleByHeight', [
  638.                     'height' => $config['height'],
  639.                     'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  640.                 ]);
  641.             } else {
  642.                 $pipe->addItem('scaleByWidth', [
  643.                     'width' => $config['width'],
  644.                     'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  645.                 ]);
  646.             }
  647.         } else {
  648.             if (!isset($config['width']) && isset($config['height'])) {
  649.                 $pipe->addItem('scaleByHeight', [
  650.                     'height' => $config['height'],
  651.                     'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  652.                 ]);
  653.             } elseif (isset($config['width']) && !isset($config['height'])) {
  654.                 $pipe->addItem('scaleByWidth', [
  655.                     'width' => $config['width'],
  656.                     'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  657.                 ]);
  658.             } elseif (isset($config['width']) && isset($config['height'])) {
  659.                 $pipe->addItem('resize', [
  660.                     'width' => $config['width'],
  661.                     'height' => $config['height'],
  662.                 ]);
  663.             }
  664.         }
  666.         if (isset($config['highResolution'])) {
  667.             $pipe->setHighResolution($config['highResolution']);
  668.         }
  670.         $hash = md5(Serialize::serialize($pipe));
  671.         $pipe->setName('auto_' . $hash);
  673.         return $pipe;
  674.     }
  676.     /**
  677.      * @internal
  678.      *
  679.      * @param Model\Asset\Image $asset
  680.      *
  681.      * @return array
  682.      */
  683.     public function getEstimatedDimensions($asset)
  684.     {
  685.         $originalWidth = $asset->getWidth();
  686.         $originalHeight = $asset->getHeight();
  688.         $dimensions = [
  689.             'width' => $originalWidth,
  690.             'height' => $originalHeight,
  691.         ];
  693.         $transformations = $this->getItems();
  694.         if (is_array($transformations) && count($transformations) > 0) {
  695.             if ($originalWidth && $originalHeight) {
  696.                 foreach ($transformations as $transformation) {
  697.                     if (!empty($transformation)) {
  698.                         $arg = $transformation['arguments'];
  700.                         $forceResize = false;
  701.                         if (isset($arg['forceResize']) && $arg['forceResize'] === true) {
  702.                             $forceResize = true;
  703.                         }
  705.                         if (in_array($transformation['method'], ['resize', 'cover', 'frame', 'crop'])) {
  706.                             $dimensions['width'] = $arg['width'];
  707.                             $dimensions['height'] = $arg['height'];
  708.                         } elseif ($transformation['method'] == '1x1_pixel') {
  709.                             return [
  710.                                 'width' => 1,
  711.                                 'height' => 1,
  712.                             ];
  713.                         } elseif ($transformation['method'] == 'scaleByWidth') {
  714.                             if ($arg['width'] <= $dimensions['width'] || $asset->isVectorGraphic() || $forceResize) {
  715.                                 $dimensions['height'] = round(($arg['width'] / $dimensions['width']) * $dimensions['height'], 0);
  716.                                 $dimensions['width'] = $arg['width'];
  717.                             }
  718.                         } elseif ($transformation['method'] == 'scaleByHeight') {
  719.                             if ($arg['height'] < $dimensions['height'] || $asset->isVectorGraphic() || $forceResize) {
  720.                                 $dimensions['width'] = round(($arg['height'] / $dimensions['height']) * $dimensions['width'], 0);
  721.                                 $dimensions['height'] = $arg['height'];
  722.                             }
  723.                         } elseif ($transformation['method'] == 'contain') {
  724.                             $x = $dimensions['width'] / $arg['width'];
  725.                             $y = $dimensions['height'] / $arg['height'];
  727.                             if (!$forceResize && $x <= 1 && $y <= 1 && !$asset->isVectorGraphic()) {
  728.                                 continue;
  729.                             }
  731.                             if ($x > $y) {
  732.                                 $dimensions['height'] = round(($arg['width'] / $dimensions['width']) * $dimensions['height'], 0);
  733.                                 $dimensions['width'] = $arg['width'];
  734.                             } else {
  735.                                 $dimensions['width'] = round(($arg['height'] / $dimensions['height']) * $dimensions['width'], 0);
  736.                                 $dimensions['height'] = $arg['height'];
  737.                             }
  738.                         } elseif ($transformation['method'] == 'cropPercent') {
  739.                             $dimensions['width'] = ceil($dimensions['width'] * ($arg['width'] / 100));
  740.                             $dimensions['height'] = ceil($dimensions['height'] * ($arg['height'] / 100));
  741.                         } elseif (in_array($transformation['method'], ['rotate', 'trim'])) {
  742.                             // unable to calculate dimensions -> return empty
  743.                             return [];
  744.                         }
  745.                     }
  746.                 }
  747.             } else {
  748.                 // this method is only if we don't have the source dimensions
  749.                 // this doesn't necessarily return both with & height
  750.                 // and is only a very rough estimate, you should avoid falling back to this functionality
  751.                 foreach ($transformations as $transformation) {
  752.                     if (!empty($transformation)) {
  753.                         if (is_array($transformation['arguments']) && in_array($transformation['method'], ['resize', 'scaleByWidth', 'scaleByHeight', 'cover', 'frame'])) {
  754.                             foreach ($transformation['arguments'] as $key => $value) {
  755.                                 if ($key == 'width' || $key == 'height') {
  756.                                     $dimensions[$key] = $value;
  757.                                 }
  758.                             }
  759.                         }
  760.                     }
  761.                 }
  762.             }
  763.         }
  765.         // ensure we return int's, sometimes $arg[...] contain strings
  766.         $dimensions['width'] = (int) $dimensions['width'] * ($this->getHighResolution() ?: 1);
  767.         $dimensions['height'] = (int) $dimensions['height'] * ($this->getHighResolution() ?: 1);
  769.         return $dimensions;
  770.     }
  772.     /**
  773.      * @return int|null
  774.      */
  775.     public function getModificationDate()
  776.     {
  777.         return $this->modificationDate;
  778.     }
  780.     /**
  781.      * @param int $modificationDate
  782.      */
  783.     public function setModificationDate($modificationDate)
  784.     {
  785.         $this->modificationDate = $modificationDate;
  786.     }
  788.     /**
  789.      * @return int|null
  790.      */
  791.     public function getCreationDate()
  792.     {
  793.         return $this->creationDate;
  794.     }
  796.     /**
  797.      * @param int $creationDate
  798.      */
  799.     public function setCreationDate($creationDate)
  800.     {
  801.         $this->creationDate = $creationDate;
  802.     }
  804.     /**
  805.      * @return bool
  806.      */
  807.     public function isPreserveColor()
  808.     {
  809.         return $this->preserveColor;
  810.     }
  812.     /**
  813.      * @param bool $preserveColor
  814.      */
  815.     public function setPreserveColor($preserveColor)
  816.     {
  817.         $this->preserveColor = $preserveColor;
  818.     }
  820.     /**
  821.      * @return bool
  822.      */
  823.     public function isPreserveMetaData()
  824.     {
  825.         return $this->preserveMetaData;
  826.     }
  828.     /**
  829.      * @param bool $preserveMetaData
  830.      */
  831.     public function setPreserveMetaData($preserveMetaData)
  832.     {
  833.         $this->preserveMetaData = $preserveMetaData;
  834.     }
  836.     /**
  837.      * @return bool
  838.      */
  839.     public function isRasterizeSVG(): bool
  840.     {
  841.         return $this->rasterizeSVG;
  842.     }
  844.     /**
  845.      * @param bool $rasterizeSVG
  846.      */
  847.     public function setRasterizeSVG(bool $rasterizeSVG): void
  848.     {
  849.         $this->rasterizeSVG = $rasterizeSVG;
  850.     }
  852.     /**
  853.      * @return bool
  854.      */
  855.     public function isSvgTargetFormatPossible()
  856.     {
  857.         $supportedTransformations = ['resize', 'scaleByWidth', 'scaleByHeight'];
  858.         foreach ($this->getItems() as $item) {
  859.             if (!in_array($item['method'], $supportedTransformations)) {
  860.                 return false;
  861.             }
  862.         }
  864.         return true;
  865.     }
  867.     /**
  868.      * @return string
  869.      */
  870.     public function getGroup(): string
  871.     {
  872.         return $this->group;
  873.     }
  875.     /**
  876.      * @param string $group
  877.      */
  878.     public function setGroup(string $group): void
  879.     {
  880.         $this->group = $group;
  881.     }
  883.     /**
  884.      * @return bool
  885.      */
  886.     public function getPreserveAnimation(): bool
  887.     {
  888.         return $this->preserveAnimation;
  889.     }
  891.     /**
  892.      * @param bool $preserveAnimation
  893.      */
  894.     public function setPreserveAnimation(bool $preserveAnimation): void
  895.     {
  896.         $this->preserveAnimation = $preserveAnimation;
  897.     }
  899.     /**
  900.      * @return bool
  901.      */
  902.     public function isDownloadable(): bool
  903.     {
  904.         return $this->downloadable;
  905.     }
  907.     /**
  908.      * @param bool $downloadable
  909.      */
  910.     public function setDownloadable(bool $downloadable): void
  911.     {
  912.         $this->downloadable = $downloadable;
  913.     }
  915.     public function __clone()
  916.     {
  917.         if ($this->dao) {
  918.             $this->dao = clone $this->dao;
  919.             $this->dao->setModel($this);
  920.         }
  922.         //rebuild asset path for overlays
  923.         foreach ($this->items as &$item) {
  924.             if (in_array($item['method'], ['addOverlay', 'addOverlayFit'])) {
  925.                 if (isset($item['arguments']['id'])) {
  926.                     $img = Model\Asset\Image::getById($item['arguments']['id']);
  927.                     if ($img) {
  928.                         $item['arguments']['path'] = $img->getFullPath();
  929.                     }
  930.                 }
  931.             }
  932.         }
  933.     }
  935.     /**
  936.      * @internal
  937.      *
  938.      * @return array
  939.      */
  940.     public static function getAutoFormats(): array
  941.     {
  942.         return \Pimcore::getContainer()->getParameter('pimcore.config')['assets']['image']['thumbnails']['auto_formats'];
  943.     }
  945.     /**
  946.      * @internal
  947.      *
  948.      * @return Config[]
  949.      */
  950.     public function getAutoFormatThumbnailConfigs(): array
  951.     {
  952.         $autoFormatThumbnails = [];
  954.         foreach ($this->getAutoFormats() as $autoFormat => $autoFormatConfig) {
  955.             if (Model\Asset\Image\Thumbnail::supportsFormat($autoFormat) && $autoFormatConfig['enabled']) {
  956.                 $autoFormatThumbnail = clone $this;
  957.                 $autoFormatThumbnail->setFormat($autoFormat);
  958.                 if (!empty($autoFormatConfig['quality'])) {
  959.                     $autoFormatThumbnail->setQuality($autoFormatConfig['quality']);
  960.                 }
  962.                 $autoFormatThumbnails[$autoFormat] = $autoFormatThumbnail;
  963.             }
  964.         }
  966.         return $autoFormatThumbnails;
  967.     }
  968. }