vendor/pimcore/pimcore/models/Asset/Image/Thumbnail.php line 170

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;
  18. use Pimcore\Event\AssetEvents;
  19. use Pimcore\Event\FrontendEvents;
  20. use Pimcore\Logger;
  21. use Pimcore\Model\Asset;
  22. use Pimcore\Model\Asset\Image;
  23. use Pimcore\Model\Asset\Thumbnail\ImageThumbnailTrait;
  24. use Pimcore\Model\Exception\NotFoundException;
  25. use Pimcore\Tool;
  26. use Symfony\Component\EventDispatcher\GenericEvent;
  28. final class Thumbnail
  29. {
  30.     use ImageThumbnailTrait;
  32.     /**
  33.      * @internal
  34.      *
  35.      * @var bool[]
  36.      */
  37.     protected static $hasListenersCache = [];
  39.     /**
  40.      * @param Image $asset
  41.      * @param string|array|Thumbnail\Config|null $config
  42.      * @param bool $deferred
  43.      */
  44.     public function __construct($asset, $config = null, $deferred = true)
  45.     {
  46.         $this->asset = $asset;
  47.         $this->deferred = $deferred;
  48.         $this->config = $this->createConfig($config);
  49.     }
  51.     /**
  52.      * @param bool $deferredAllowed
  53.      * @param bool $cacheBuster
  54.      *
  55.      * @return string
  56.      */
  57.     public function getPath($deferredAllowed = true, $cacheBuster = false)
  58.     {
  59.         $pathReference = null;
  60.         if ($this->getConfig()) {
  61.             if ($this->useOriginalFile($this->asset->getFilename()) && $this->getConfig()->isSvgTargetFormatPossible()) {
  62.                 // we still generate the raster image, to get the final size of the thumbnail
  63.                 // we use getRealFullPath() here, to avoid double encoding (getFullPath() returns already encoded path)
  64.                 $pathReference = [
  65.                     'src' => $this->asset->getRealFullPath(),
  66.                     'type' => 'asset',
  67.                 ];
  68.             }
  69.         }
  71.         if (!$pathReference) {
  72.             $pathReference = $this->getPathReference($deferredAllowed);
  73.         }
  75.         $path = $this->convertToWebPath($pathReference);
  77.         if ($cacheBuster) {
  78.             $path = $this->addCacheBuster($path, ['cacheBuster' => true], $this->getAsset());
  79.         }
  81.         if ($this->hasListeners(FrontendEvents::ASSET_IMAGE_THUMBNAIL)) {
  82.             $event = new GenericEvent($this, [
  83.                 'pathReference' => $pathReference,
  84.                 'frontendPath' => $path,
  85.             ]);
  86.             \Pimcore::getEventDispatcher()->dispatch($event, FrontendEvents::ASSET_IMAGE_THUMBNAIL);
  87.             $path = $event->getArgument('frontendPath');
  88.         }
  90.         return $path;
  91.     }
  93.     public function getFileSize(): ?int
  94.     {
  95.         $pathReference = $this->getPathReference(false);
  96.         if ($pathReference['type'] === 'asset') {
  97.             return $this->asset->getFileSize();
  98.         } elseif (isset($pathReference['storagePath'])) {
  99.             return Tool\Storage::get('thumbnail')->fileSize($pathReference['storagePath']);
  100.         }
  102.         return null;
  103.     }
  105.     /**
  106.      * @return null|resource
  107.      */
  108.     public function getStream()
  109.     {
  110.         $pathReference = $this->getPathReference(false);
  111.         if ($pathReference['type'] === 'asset') {
  112.             return $this->asset->getStream();
  113.         } elseif (isset($pathReference['storagePath'])) {
  114.             return Tool\Storage::get('thumbnail')->readStream($pathReference['storagePath']);
  115.         }
  117.         return null;
  118.     }
  120.     /**
  121.      * @param string $eventName
  122.      *
  123.      * @return bool
  124.      */
  125.     protected function hasListeners(string $eventName): bool
  126.     {
  127.         if (!isset(self::$hasListenersCache[$eventName])) {
  128.             self::$hasListenersCache[$eventName] = \Pimcore::getEventDispatcher()->hasListeners($eventName);
  129.         }
  131.         return self::$hasListenersCache[$eventName];
  132.     }
  134.     /**
  135.      * @param string $filename
  136.      *
  137.      * @return bool
  138.      */
  139.     protected function useOriginalFile($filename)
  140.     {
  141.         if ($this->getConfig()) {
  142.             if (!$this->getConfig()->isRasterizeSVG() && preg_match("@\.svgz?$@", $filename)) {
  143.                 return true;
  144.             }
  145.         }
  147.         return false;
  148.     }
  150.     /**
  151.      * @internal
  152.      *
  153.      * @param bool $deferredAllowed
  154.      */
  155.     public function generate($deferredAllowed = true)
  156.     {
  157.         $deferred = false;
  158.         $generated = false;
  160.         if ($this->asset && empty($this->pathReference)) {
  161.             // if no correct thumbnail config is given use the original image as thumbnail
  162.             if (!$this->config) {
  163.                 $this->pathReference = [
  164.                     'type' => 'asset',
  165.                     'src' => $this->asset->getRealFullPath(),
  166.                 ];
  167.             } else {
  168.                 try {
  169.                     $deferred = $deferredAllowed && $this->deferred;
  170.                     $this->pathReference = Thumbnail\Processor::process($this->asset, $this->config, null, $deferred, $generated);
  171.                 } catch (\Exception $e) {
  172.                     Logger::error("Couldn't create thumbnail of image " . $this->asset->getRealFullPath());
  173.                     Logger::error($e->getMessage());
  174.                 }
  175.             }
  176.         }
  178.         if (empty($this->pathReference)) {
  179.             $this->pathReference = [
  180.                 'type' => 'error',
  181.                 'src' => '/bundles/pimcoreadmin/img/filetype-not-supported.svg',
  182.             ];
  183.         }
  185.         if ($this->hasListeners(AssetEvents::IMAGE_THUMBNAIL)) {
  186.             $event = new GenericEvent($this, [
  187.                 'deferred' => $deferred,
  188.                 'generated' => $generated,
  189.             ]);
  190.             \Pimcore::getEventDispatcher()->dispatch($event, AssetEvents::IMAGE_THUMBNAIL);
  191.         }
  192.     }
  194.     /**
  195.      * @return string Public path to thumbnail image.
  196.      */
  197.     public function __toString()
  198.     {
  199.         return $this->getPath(true);
  200.     }
  202.     /**
  203.      * @param string $path
  204.      * @param array $options
  205.      * @param Asset $asset
  206.      *
  207.      * @return string
  208.      */
  209.     private function addCacheBuster(string $path, array $options, Asset $asset): string
  210.     {
  211.         if (isset($options['cacheBuster']) && $options['cacheBuster']) {
  212.             if (!str_starts_with($path, 'http')) {
  213.                 $path = '/cache-buster-' . $asset->getVersionCount() . $path;
  214.             }
  215.         }
  217.         return $path;
  218.     }
  220.     private function getSourceTagHtml(Image\Thumbnail\Config $thumbConfig, string $mediaQuery, Image $image, array $options): string
  221.     {
  222.         $srcSetValues = [];
  223.         $sourceTagAttributes = [];
  225.         foreach ([1, 2] as $highRes) {
  226.             $thumbConfigRes = clone $thumbConfig;
  227.             $thumbConfigRes->selectMedia($mediaQuery);
  228.             $thumbConfigRes->setHighResolution($highRes);
  229.             $thumb = $image->getThumbnail($thumbConfigRes, true);
  231.             $descriptor = $highRes . 'x';
  232.             $srcSetValues[] = $this->addCacheBuster($thumb . ' ' . $descriptor, $options, $image);
  234.             if ($this->useOriginalFile($this->asset->getFilename()) && $this->getConfig()->isSvgTargetFormatPossible()) {
  235.                 break;
  236.             }
  237.         }
  239.         $sourceTagAttributes['srcset'] = implode(', ', $srcSetValues);
  240.         if ($mediaQuery) {
  241.             $sourceTagAttributes['media'] = $mediaQuery;
  242.             $thumb->reset();
  243.         }
  245.         if (isset($options['previewDataUri'])) {
  246.             $sourceTagAttributes['data-srcset'] = $sourceTagAttributes['srcset'];
  247.             unset($sourceTagAttributes['srcset']);
  248.         }
  250.         $sourceTagAttributes['type'] = $thumb->getMimeType();
  252.         $sourceCallback = $options['sourceCallback'] ?? null;
  253.         if ($sourceCallback) {
  254.             $sourceTagAttributes = $sourceCallback($sourceTagAttributes);
  255.         }
  257.         return '<source ' . array_to_html_attribute_string($sourceTagAttributes) . ' />';
  258.     }
  260.     /**
  261.      * Get generated HTML for displaying the thumbnail image in a HTML document.
  262.      *
  263.      * @param array $options Custom configuration
  264.      *
  265.      * @return string
  266.      */
  267.     public function getHtml($options = [])
  268.     {
  269.         /** @var Image $image */
  270.         $image = $this->getAsset();
  271.         $thumbConfig = $this->getConfig();
  273.         $pictureTagAttributes = $options['pictureAttributes'] ?? []; // this is used for the html5 <picture> element
  275.         if ((isset($options['lowQualityPlaceholder']) && $options['lowQualityPlaceholder']) && !Tool::isFrontendRequestByAdmin()) {
  276.             $previewDataUri = $image->getLowQualityPreviewDataUri();
  277.             if (!$previewDataUri) {
  278.                 // use a 1x1 transparent GIF as a fallback if no LQIP exists
  279.                 $previewDataUri = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
  280.             }
  282.             // this gets used in getImagTag() later
  283.             $options['previewDataUri'] = $previewDataUri;
  284.         }
  286.         $isAutoFormat = $thumbConfig instanceof Image\Thumbnail\Config ? strtolower($thumbConfig->getFormat()) === 'source' : false;
  288.         if ($isAutoFormat) {
  289.             // ensure the default image is not WebP
  290.             $this->pathReference = [];
  291.         }
  293.         $pictureCallback = $options['pictureCallback'] ?? null;
  294.         if ($pictureCallback) {
  295.             $pictureTagAttributes = $pictureCallback($pictureTagAttributes);
  296.         }
  298.         $html = '<picture ' . array_to_html_attribute_string($pictureTagAttributes) . '>' . "\n";
  300.         if ($thumbConfig instanceof Image\Thumbnail\Config) {
  301.             $mediaConfigs = $thumbConfig->getMedias();
  303.             // currently only max-width is supported, the key of the media is WIDTHw (eg. 400w) according to the srcset specification
  304.             ksort($mediaConfigs, SORT_NUMERIC);
  305.             array_push($mediaConfigs, $thumbConfig->getItems()); //add the default config at the end - picturePolyfill v4
  307.             foreach ($mediaConfigs as $mediaQuery => $config) {
  308.                 $sourceHtml = $this->getSourceTagHtml($thumbConfig, $mediaQuery, $image, $options);
  309.                 if (!empty($sourceHtml)) {
  310.                     if ($isAutoFormat) {
  311.                         foreach ($thumbConfig->getAutoFormatThumbnailConfigs() as $autoFormatConfig) {
  312.                             $autoFormatThumbnailHtml = $this->getSourceTagHtml($autoFormatConfig, $mediaQuery, $image, $options);
  313.                             if (!empty($autoFormatThumbnailHtml)) {
  314.                                 $html .= "\t" . $autoFormatThumbnailHtml . "\n";
  315.                             }
  316.                         }
  317.                     }
  319.                     $html .= "\t" . $sourceHtml . "\n";
  320.                 }
  321.             }
  322.         }
  324.         if (!($options['disableImgTag'] ?? null)) {
  325.             $html .= "\t" . $this->getImageTag($options) . "\n";
  326.         }
  328.         $html .= '</picture>' . "\n";
  330.         if (isset($options['useDataSrc']) && $options['useDataSrc']) {
  331.             $html = preg_replace('/ src(set)?=/i', ' data-src$1=', $html);
  332.         }
  334.         return $html;
  335.     }
  337.     /**
  338.      * @param array $options
  339.      * @param array $removeAttributes
  340.      *
  341.      * @return string
  342.      */
  343.     public function getImageTag(array $options = [], array $removeAttributes = []): string
  344.     {
  345.         /** @var Image $image */
  346.         $image = $this->getAsset();
  347.         $attributes = $options['imgAttributes'] ?? [];
  348.         $callback = $options['imgCallback'] ?? null;
  350.         if (isset($options['previewDataUri'])) {
  351.             $attributes['src'] = $options['previewDataUri'];
  352.         } else {
  353.             $path = $this->getPath(true);
  354.             $attributes['src'] = $this->addCacheBuster($path, $options, $image);
  355.         }
  357.         if (!isset($options['disableWidthHeightAttributes'])) {
  358.             if ($this->getWidth()) {
  359.                 $attributes['width'] = $this->getWidth();
  360.             }
  362.             if ($this->getHeight()) {
  363.                 $attributes['height'] = $this->getHeight();
  364.             }
  365.         }
  367.         $altText = !empty($options['alt']) ? $options['alt'] : (!empty($attributes['alt']) ? $attributes['alt'] : '');
  368.         $titleText = !empty($options['title']) ? $options['title'] : (!empty($attributes['title']) ? $attributes['title'] : '');
  370.         if (empty($titleText) && (!isset($options['disableAutoTitle']) || !$options['disableAutoTitle'])) {
  371.             if ($image->getMetadata('title')) {
  372.                 $titleText = $image->getMetadata('title');
  373.             }
  374.         }
  376.         if (empty($altText) && (!isset($options['disableAutoAlt']) || !$options['disableAutoAlt'])) {
  377.             if ($image->getMetadata('alt')) {
  378.                 $altText = $image->getMetadata('alt');
  379.             } elseif (isset($options['defaultalt'])) {
  380.                 $altText = $options['defaultalt'];
  381.             } else {
  382.                 $altText = $titleText;
  383.             }
  384.         }
  386.         // get copyright from asset
  387.         if ($image->getMetadata('copyright') && (!isset($options['disableAutoCopyright']) || !$options['disableAutoCopyright'])) {
  388.             if (!empty($altText)) {
  389.                 $altText .= ' | ';
  390.             }
  391.             if (!empty($titleText)) {
  392.                 $titleText .= ' | ';
  393.             }
  394.             $altText .= ('© ' . $image->getMetadata('copyright'));
  395.             $titleText .= ('© ' . $image->getMetadata('copyright'));
  396.         }
  398.         $attributes['alt'] = $altText;
  399.         if (!empty($titleText)) {
  400.             $attributes['title'] = $titleText;
  401.         }
  403.         if (!isset($attributes['loading'])) {
  404.             $attributes['loading'] = 'lazy';
  405.         }
  407.         foreach ($removeAttributes as $attribute) {
  408.             unset($attributes[$attribute]);
  409.         }
  411.         if ($callback) {
  412.             $attributes = $callback($attributes);
  413.         }
  415.         $htmlImgTag = '';
  416.         if (!empty($attributes)) {
  417.             $htmlImgTag = '<img ' . array_to_html_attribute_string($attributes) . ' />';
  418.         }
  420.         return $htmlImgTag;
  421.     }
  423.     /**
  424.      * @param string $name
  425.      * @param int $highRes
  426.      *
  427.      * @return Thumbnail
  428.      *
  429.      * @throws \Exception
  430.      */
  431.     public function getMedia($name, $highRes = 1)
  432.     {
  433.         $thumbConfig = $this->getConfig();
  434.         $mediaConfigs = $thumbConfig->getMedias();
  436.         if (isset($mediaConfigs[$name])) {
  437.             $thumbConfigRes = clone $thumbConfig;
  438.             $thumbConfigRes->selectMedia($name);
  439.             $thumbConfigRes->setHighResolution($highRes);
  440.             $thumbConfigRes->setMedias([]);
  441.             /** @var Image $asset */
  442.             $asset = $this->getAsset();
  443.             $thumb = $asset->getThumbnail($thumbConfigRes);
  445.             return $thumb;
  446.         } else {
  447.             throw new \Exception("Media query '" . $name . "' doesn't exist in thumbnail configuration: " . $thumbConfig->getName());
  448.         }
  449.     }
  451.     /**
  452.      * Get a thumbnail image configuration.
  453.      *
  454.      * @param string|array|Thumbnail\Config $selector Name, array or object describing a thumbnail configuration.
  455.      *
  456.      * @return Thumbnail\Config
  457.      *
  458.      * @throws NotFoundException
  459.      */
  460.     private function createConfig($selector)
  461.     {
  462.         $thumbnailConfig = Thumbnail\Config::getByAutoDetect($selector);
  464.         if (!empty($selector) && $thumbnailConfig === null) {
  465.             throw new NotFoundException('Thumbnail definition "' . (is_string($selector) ? $selector : '') . '" does not exist');
  466.         }
  468.         return $thumbnailConfig;
  469.     }
  470. }