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

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|callable $name
  314.      * @param array $parameters
  315.      * @param string|null $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|callable $name
  342.      * @param array $parameters
  343.      * @param string|null $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|null $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.         $pipe->generateAutoName();
  585.         return $pipe;
  586.     }
  588.     /**
  589.      * This is mainly here for backward compatibility
  590.      *
  591.      * @internal
  592.      *
  593.      * @param array $config
  594.      *
  595.      * @return self
  596.      */
  597.     public static function getByLegacyConfig($config)
  598.     {
  599.         $pipe = new self();
  601.         if (isset($config['format'])) {
  602.             $pipe->setFormat($config['format']);
  603.         }
  605.         if (isset($config['quality'])) {
  606.             $pipe->setQuality($config['quality']);
  607.         }
  609.         if (isset($config['cover'])) {
  610.             $pipe->addItem('cover', [
  611.                 'width' => $config['width'],
  612.                 'height' => $config['height'],
  613.                 'positioning' => ((isset($config['positioning']) && !empty($config['positioning'])) ? (string)$config['positioning'] : 'center'),
  614.                 'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  615.             ]);
  616.         } elseif (isset($config['contain'])) {
  617.             $pipe->addItem('contain', [
  618.                 'width' => $config['width'],
  619.                 'height' => $config['height'],
  620.                 'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  621.             ]);
  622.         } elseif (isset($config['frame'])) {
  623.             $pipe->addItem('frame', [
  624.                 'width' => $config['width'],
  625.                 'height' => $config['height'],
  626.                 'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  627.             ]);
  628.         } elseif (isset($config['aspectratio']) && $config['aspectratio']) {
  629.             if (isset($config['height']) && isset($config['width']) && $config['height'] > 0 && $config['width'] > 0) {
  630.                 $pipe->addItem('contain', [
  631.                     'width' => $config['width'],
  632.                     'height' => $config['height'],
  633.                     'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  634.                 ]);
  635.             } elseif (isset($config['height']) && $config['height'] > 0) {
  636.                 $pipe->addItem('scaleByHeight', [
  637.                     'height' => $config['height'],
  638.                     'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  639.                 ]);
  640.             } else {
  641.                 $pipe->addItem('scaleByWidth', [
  642.                     'width' => $config['width'],
  643.                     'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  644.                 ]);
  645.             }
  646.         } else {
  647.             if (!isset($config['width']) && isset($config['height'])) {
  648.                 $pipe->addItem('scaleByHeight', [
  649.                     'height' => $config['height'],
  650.                     'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  651.                 ]);
  652.             } elseif (isset($config['width']) && !isset($config['height'])) {
  653.                 $pipe->addItem('scaleByWidth', [
  654.                     'width' => $config['width'],
  655.                     'forceResize' => (isset($config['forceResize']) ? (bool)$config['forceResize'] : false),
  656.                 ]);
  657.             } elseif (isset($config['width']) && isset($config['height'])) {
  658.                 $pipe->addItem('resize', [
  659.                     'width' => $config['width'],
  660.                     'height' => $config['height'],
  661.                 ]);
  662.             }
  663.         }
  665.         if (isset($config['highResolution'])) {
  666.             $pipe->setHighResolution($config['highResolution']);
  667.         }
  669.         $pipe->generateAutoName();
  671.         return $pipe;
  672.     }
  674.     /**
  675.      * @internal
  676.      *
  677.      * @param Model\Asset\Image $asset
  678.      *
  679.      * @return array
  680.      */
  681.     public function getEstimatedDimensions($asset)
  682.     {
  683.         $originalWidth = $asset->getWidth();
  684.         $originalHeight = $asset->getHeight();
  686.         $dimensions = [
  687.             'width' => $originalWidth,
  688.             'height' => $originalHeight,
  689.         ];
  691.         $transformations = $this->getItems();
  692.         if (is_array($transformations) && count($transformations) > 0) {
  693.             if ($originalWidth && $originalHeight) {
  694.                 foreach ($transformations as $transformation) {
  695.                     if (!empty($transformation)) {
  696.                         $arg = $transformation['arguments'];
  698.                         $forceResize = false;
  699.                         if (isset($arg['forceResize']) && $arg['forceResize'] === true) {
  700.                             $forceResize = true;
  701.                         }
  703.                         if (in_array($transformation['method'], ['resize', 'cover', 'frame', 'crop'])) {
  704.                             $dimensions['width'] = $arg['width'];
  705.                             $dimensions['height'] = $arg['height'];
  706.                         } elseif ($transformation['method'] == '1x1_pixel') {
  707.                             return [
  708.                                 'width' => 1,
  709.                                 'height' => 1,
  710.                             ];
  711.                         } elseif ($transformation['method'] == 'scaleByWidth') {
  712.                             if ($arg['width'] <= $dimensions['width'] || $asset->isVectorGraphic() || $forceResize) {
  713.                                 $dimensions['height'] = round(($arg['width'] / $dimensions['width']) * $dimensions['height'], 0);
  714.                                 $dimensions['width'] = $arg['width'];
  715.                             }
  716.                         } elseif ($transformation['method'] == 'scaleByHeight') {
  717.                             if ($arg['height'] < $dimensions['height'] || $asset->isVectorGraphic() || $forceResize) {
  718.                                 $dimensions['width'] = round(($arg['height'] / $dimensions['height']) * $dimensions['width'], 0);
  719.                                 $dimensions['height'] = $arg['height'];
  720.                             }
  721.                         } elseif ($transformation['method'] == 'contain') {
  722.                             $x = $dimensions['width'] / $arg['width'];
  723.                             $y = $dimensions['height'] / $arg['height'];
  725.                             if (!$forceResize && $x <= 1 && $y <= 1 && !$asset->isVectorGraphic()) {
  726.                                 continue;
  727.                             }
  729.                             if ($x > $y) {
  730.                                 $dimensions['height'] = round(($arg['width'] / $dimensions['width']) * $dimensions['height'], 0);
  731.                                 $dimensions['width'] = $arg['width'];
  732.                             } else {
  733.                                 $dimensions['width'] = round(($arg['height'] / $dimensions['height']) * $dimensions['width'], 0);
  734.                                 $dimensions['height'] = $arg['height'];
  735.                             }
  736.                         } elseif ($transformation['method'] == 'cropPercent') {
  737.                             $dimensions['width'] = ceil($dimensions['width'] * ($arg['width'] / 100));
  738.                             $dimensions['height'] = ceil($dimensions['height'] * ($arg['height'] / 100));
  739.                         } elseif (in_array($transformation['method'], ['rotate', 'trim'])) {
  740.                             // unable to calculate dimensions -> return empty
  741.                             return [];
  742.                         }
  743.                     }
  744.                 }
  745.             } else {
  746.                 // this method is only if we don't have the source dimensions
  747.                 // this doesn't necessarily return both with & height
  748.                 // and is only a very rough estimate, you should avoid falling back to this functionality
  749.                 foreach ($transformations as $transformation) {
  750.                     if (!empty($transformation)) {
  751.                         if (is_array($transformation['arguments']) && in_array($transformation['method'], ['resize', 'scaleByWidth', 'scaleByHeight', 'cover', 'frame'])) {
  752.                             foreach ($transformation['arguments'] as $key => $value) {
  753.                                 if ($key == 'width' || $key == 'height') {
  754.                                     $dimensions[$key] = $value;
  755.                                 }
  756.                             }
  757.                         }
  758.                     }
  759.                 }
  760.             }
  761.         }
  763.         // ensure we return int's, sometimes $arg[...] contain strings
  764.         $dimensions['width'] = (int) $dimensions['width'] * ($this->getHighResolution() ?: 1);
  765.         $dimensions['height'] = (int) $dimensions['height'] * ($this->getHighResolution() ?: 1);
  767.         return $dimensions;
  768.     }
  770.     /**
  771.      * @return int|null
  772.      */
  773.     public function getModificationDate()
  774.     {
  775.         return $this->modificationDate;
  776.     }
  778.     /**
  779.      * @param int $modificationDate
  780.      */
  781.     public function setModificationDate($modificationDate)
  782.     {
  783.         $this->modificationDate = $modificationDate;
  784.     }
  786.     /**
  787.      * @return int|null
  788.      */
  789.     public function getCreationDate()
  790.     {
  791.         return $this->creationDate;
  792.     }
  794.     /**
  795.      * @param int $creationDate
  796.      */
  797.     public function setCreationDate($creationDate)
  798.     {
  799.         $this->creationDate = $creationDate;
  800.     }
  802.     /**
  803.      * @return bool
  804.      */
  805.     public function isPreserveColor()
  806.     {
  807.         return $this->preserveColor;
  808.     }
  810.     /**
  811.      * @param bool $preserveColor
  812.      */
  813.     public function setPreserveColor($preserveColor)
  814.     {
  815.         $this->preserveColor = $preserveColor;
  816.     }
  818.     /**
  819.      * @return bool
  820.      */
  821.     public function isPreserveMetaData()
  822.     {
  823.         return $this->preserveMetaData;
  824.     }
  826.     /**
  827.      * @param bool $preserveMetaData
  828.      */
  829.     public function setPreserveMetaData($preserveMetaData)
  830.     {
  831.         $this->preserveMetaData = $preserveMetaData;
  832.     }
  834.     /**
  835.      * @return bool
  836.      */
  837.     public function isRasterizeSVG(): bool
  838.     {
  839.         return $this->rasterizeSVG;
  840.     }
  842.     /**
  843.      * @param bool $rasterizeSVG
  844.      */
  845.     public function setRasterizeSVG(bool $rasterizeSVG): void
  846.     {
  847.         $this->rasterizeSVG = $rasterizeSVG;
  848.     }
  850.     /**
  851.      * @return bool
  852.      */
  853.     public function isSvgTargetFormatPossible()
  854.     {
  855.         $supportedTransformations = ['resize', 'scaleByWidth', 'scaleByHeight'];
  856.         foreach ($this->getItems() as $item) {
  857.             if (!in_array($item['method'], $supportedTransformations)) {
  858.                 return false;
  859.             }
  860.         }
  862.         return true;
  863.     }
  865.     /**
  866.      * @return string
  867.      */
  868.     public function getGroup(): string
  869.     {
  870.         return $this->group;
  871.     }
  873.     /**
  874.      * @param string $group
  875.      */
  876.     public function setGroup(string $group): void
  877.     {
  878.         $this->group = $group;
  879.     }
  881.     /**
  882.      * @return bool
  883.      */
  884.     public function getPreserveAnimation(): bool
  885.     {
  886.         return $this->preserveAnimation;
  887.     }
  889.     /**
  890.      * @param bool $preserveAnimation
  891.      */
  892.     public function setPreserveAnimation(bool $preserveAnimation): void
  893.     {
  894.         $this->preserveAnimation = $preserveAnimation;
  895.     }
  897.     /**
  898.      * @return bool
  899.      */
  900.     public function isDownloadable(): bool
  901.     {
  902.         return $this->downloadable;
  903.     }
  905.     /**
  906.      * @param bool $downloadable
  907.      */
  908.     public function setDownloadable(bool $downloadable): void
  909.     {
  910.         $this->downloadable = $downloadable;
  911.     }
  913.     public function __clone()
  914.     {
  915.         if ($this->dao) {
  916.             $this->dao = clone $this->dao;
  917.             $this->dao->setModel($this);
  918.         }
  920.         //rebuild asset path for overlays
  921.         foreach ($this->items as &$item) {
  922.             if (in_array($item['method'], ['addOverlay', 'addOverlayFit'])) {
  923.                 if (isset($item['arguments']['id'])) {
  924.                     $img = Model\Asset\Image::getById($item['arguments']['id']);
  925.                     if ($img) {
  926.                         $item['arguments']['path'] = $img->getFullPath();
  927.                     }
  928.                 }
  929.             }
  930.         }
  931.     }
  933.     /**
  934.      * @internal
  935.      *
  936.      * @return array
  937.      */
  938.     public static function getAutoFormats(): array
  939.     {
  940.         return \Pimcore::getContainer()->getParameter('pimcore.config')['assets']['image']['thumbnails']['auto_formats'];
  941.     }
  943.     /**
  944.      * @internal
  945.      *
  946.      * @return Config[]
  947.      */
  948.     public function getAutoFormatThumbnailConfigs(): array
  949.     {
  950.         $autoFormatThumbnails = [];
  952.         foreach ($this->getAutoFormats() as $autoFormat => $autoFormatConfig) {
  953.             if ($autoFormatConfig['enabled'] && Model\Asset\Image\Thumbnail::supportsFormat($autoFormat)) {
  954.                 $autoFormatThumbnail = clone $this;
  955.                 $autoFormatThumbnail->setFormat($autoFormat);
  956.                 if (!empty($autoFormatConfig['quality'])) {
  957.                     $autoFormatThumbnail->setQuality($autoFormatConfig['quality']);
  958.                 }
  960.                 $autoFormatThumbnails[$autoFormat] = $autoFormatThumbnail;
  961.             }
  962.         }
  964.         return $autoFormatThumbnails;
  965.     }
  967.     /**
  968.      * @internal
  969.      */
  970.     public function generateAutoName(): void
  971.     {
  972.         $serialized = Serialize::serialize($this->getItems());
  974.         $this->setName($this->getName() . '_auto_' . md5($serialized));
  975.     }
  976. }