vendor/pimcore/pimcore/models/Document/Editable/Image.php line 27

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\Document\Editable;
  18. use Pimcore\Model;
  19. use Pimcore\Model\Asset;
  20. use Pimcore\Model\Element;
  21. use Pimcore\Model\Element\ElementDescriptor;
  22. use Pimcore\Tool\Serialize;
  24. /**
  25.  * @method \Pimcore\Model\Document\Editable\Dao getDao()
  26.  */
  27. class Image extends Model\Document\Editable implements IdRewriterInterface, EditmodeDataInterface
  28. {
  29.     /**
  30.      * ID of the referenced image
  31.      *
  32.      * @internal
  33.      *
  34.      * @var int|null
  35.      */
  36.     protected $id;
  38.     /**
  39.      * The ALT text of the image
  40.      *
  41.      * @internal
  42.      *
  43.      * @var string|null
  44.      */
  45.     protected $alt;
  47.     /**
  48.      * Contains the imageobject itself
  49.      *
  50.      * @internal
  51.      *
  52.      * @var Asset\Image|ElementDescriptor|null
  53.      */
  54.     protected $image;
  56.     /**
  57.      * @internal
  58.      *
  59.      * @var bool
  60.      */
  61.     protected $cropPercent = false;
  63.     /**
  64.      * @internal
  65.      *
  66.      * @var float
  67.      */
  68.     protected $cropWidth;
  70.     /**
  71.      * @internal
  72.      *
  73.      * @var float
  74.      */
  75.     protected $cropHeight;
  77.     /**
  78.      * @internal
  79.      *
  80.      * @var float
  81.      */
  82.     protected $cropTop;
  84.     /**
  85.      * @internal
  86.      *
  87.      * @var float
  88.      */
  89.     protected $cropLeft;
  91.     /**
  92.      * @internal
  93.      *
  94.      * @var array
  95.      */
  96.     protected $hotspots = [];
  98.     /**
  99.      * @internal
  100.      *
  101.      * @var array
  102.      */
  103.     protected $marker = [];
  105.     /**
  106.      * The Thumbnail config of the image
  107.      *
  108.      * @internal
  109.      *
  110.      * @var string|null
  111.      */
  112.     protected $thumbnail;
  114.     /**
  115.      * {@inheritdoc}
  116.      */
  117.     public function getType()
  118.     {
  119.         return 'image';
  120.     }
  122.     /**
  123.      * {@inheritdoc}
  124.      *
  125.      * @return mixed
  126.      */
  127.     public function getData()
  128.     {
  129.         return [
  130.             'id' => $this->id,
  131.             'alt' => $this->alt,
  132.             'cropPercent' => $this->cropPercent,
  133.             'cropWidth' => $this->cropWidth,
  134.             'cropHeight' => $this->cropHeight,
  135.             'cropTop' => $this->cropTop,
  136.             'cropLeft' => $this->cropLeft,
  137.             'hotspots' => $this->hotspots,
  138.             'marker' => $this->marker,
  139.             'thumbnail' => $this->thumbnail,
  140.         ];
  141.     }
  143.     /**
  144.      * {@inheritdoc}
  145.      *
  146.      * @return array
  147.      */
  148.     public function getDataForResource()
  149.     {
  150.         return [
  151.             'id' => $this->id,
  152.             'alt' => $this->alt,
  153.             'cropPercent' => $this->cropPercent,
  154.             'cropWidth' => $this->cropWidth,
  155.             'cropHeight' => $this->cropHeight,
  156.             'cropTop' => $this->cropTop,
  157.             'cropLeft' => $this->cropLeft,
  158.             'hotspots' => $this->hotspots,
  159.             'marker' => $this->marker,
  160.             'thumbnail' => $this->thumbnail,
  161.         ];
  162.     }
  164.     /**
  165.      * {@inheritdoc}
  166.      */
  167.     public function getDataEditmode() /** : mixed */
  168.     {
  169.         $image = $this->getImage();
  171.         if ($image instanceof Asset\Image) {
  172.             $rewritePath = function ($data) {
  173.                 if (!is_array($data)) {
  174.                     return [];
  175.                 }
  177.                 foreach ($data as &$element) {
  178.                     if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  179.                         foreach ($element['data'] as &$metaData) {
  180.                             if ($metaData instanceof Element\Data\MarkerHotspotItem) {
  181.                                 $metaData = get_object_vars($metaData);
  182.                             }
  184.                             if (in_array($metaData['type'], ['object', 'asset', 'document'])
  185.                             && $el = Element\Service::getElementById($metaData['type'], $metaData['value'])) {
  186.                                 $metaData['value'] = $el;
  187.                             }
  189.                             if ($metaData['value'] instanceof Element\ElementInterface) {
  190.                                 $metaData['value'] = $metaData['value']->getRealFullPath();
  191.                             }
  192.                         }
  193.                     }
  194.                 }
  196.                 return $data;
  197.             };
  199.             $marker = $rewritePath($this->marker);
  200.             $hotspots = $rewritePath($this->hotspots);
  202.             return [
  203.                 'id' => $this->id,
  204.                 'path' => $image->getRealFullPath(),
  205.                 'alt' => $this->alt,
  206.                 'cropPercent' => $this->cropPercent,
  207.                 'cropWidth' => $this->cropWidth,
  208.                 'cropHeight' => $this->cropHeight,
  209.                 'cropTop' => $this->cropTop,
  210.                 'cropLeft' => $this->cropLeft,
  211.                 'hotspots' => $hotspots,
  212.                 'marker' => $marker,
  213.                 'thumbnail' => $this->thumbnail,
  214.                 'predefinedDataTemplates' => $this->getConfig()['predefinedDataTemplates'] ?? null,
  215.             ];
  216.         }
  218.         return null;
  219.     }
  221.     /**
  222.      * @return array
  223.      */
  224.     public function getConfig()
  225.     {
  226.         $config = parent::getConfig();
  227.         if (isset($config['thumbnail']) && !isset($config['focal_point_context_menu_item'])) {
  228.             $thumbConfig = Asset\Image\Thumbnail\Config::getByAutoDetect($config['thumbnail']);
  229.             if ($thumbConfig) {
  230.                 foreach ($thumbConfig->getItems() as $item) {
  231.                     if ($item['method'] == 'cover') {
  232.                         $config['focal_point_context_menu_item'] = true;
  233.                         $this->config['focal_point_context_menu_item'] = true;
  235.                         break;
  236.                     }
  237.                 }
  238.             }
  239.         }
  241.         return $config;
  242.     }
  244.     /**
  245.      * {@inheritdoc}
  246.      */
  247.     public function frontend()
  248.     {
  249.         if (!is_array($this->config)) {
  250.             $this->config = [];
  251.         }
  253.         $image = $this->getImage();
  255.         if ($image instanceof Asset\Image) {
  256.             $thumbnailName = $this->config['thumbnail'] ?? null;
  257.             if ($thumbnailName || $this->cropPercent) {
  258.                 // create a thumbnail first
  259.                 $autoName = false;
  261.                 $thumbConfig = $image->getThumbnailConfig($thumbnailName);
  262.                 if (!$thumbConfig && $this->cropPercent) {
  263.                     $thumbConfig = new Asset\Image\Thumbnail\Config();
  264.                 }
  266.                 if ($this->cropPercent) {
  267.                     $this->applyCustomCropping($thumbConfig);
  268.                     $autoName = true;
  269.                 }
  271.                 if (isset($this->config['highResolution']) && $this->config['highResolution'] > 1) {
  272.                     $thumbConfig->setHighResolution($this->config['highResolution']);
  273.                 }
  275.                 // autogenerate a name for the thumbnail because it's different from the original
  276.                 if ($autoName) {
  277.                     $thumbConfig->generateAutoName();
  278.                 }
  280.                 $deferred = true;
  281.                 if (isset($this->config['deferred'])) {
  282.                     $deferred = $this->config['deferred'];
  283.                 }
  285.                 $thumbnail = $image->getThumbnail($thumbConfig, $deferred);
  286.             } else {
  287.                 // we're using the thumbnail class only to generate the HTML
  288.                 $thumbnail = $image->getThumbnail();
  289.             }
  291.             $attributes = array_merge($this->config, [
  292.                 'alt' => $this->alt,
  293.                 'title' => $this->alt,
  294.             ]);
  296.             $removeAttributes = [];
  297.             if (isset($this->config['removeAttributes']) && is_array($this->config['removeAttributes'])) {
  298.                 $removeAttributes = $this->config['removeAttributes'];
  299.             }
  301.             // thumbnail's HTML is always generated by the thumbnail itself
  302.             return $thumbnail->getHtml($attributes);
  303.         }
  305.         return '';
  306.     }
  308.     /**
  309.      * {@inheritdoc}
  310.      */
  311.     public function setDataFromResource($data)
  312.     {
  313.         if (strlen($data) > 2) {
  314.             $data = Serialize::unserialize($data);
  315.         }
  317.         $rewritePath = function ($data) {
  318.             if (!is_array($data)) {
  319.                 return [];
  320.             }
  322.             foreach ($data as &$element) {
  323.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  324.                     foreach ($element['data'] as &$metaData) {
  325.                         // this is for backward compatibility (Array vs. MarkerHotspotItem)
  326.                         if (is_array($metaData)) {
  327.                             $metaData = new Element\Data\MarkerHotspotItem($metaData);
  328.                         }
  329.                     }
  330.                 }
  331.             }
  333.             return $data;
  334.         };
  336.         if (array_key_exists('marker', $data) && is_array($data['marker']) && count($data['marker']) > 0) {
  337.             $data['marker'] = $rewritePath($data['marker']);
  338.         }
  340.         if (array_key_exists('hotspots', $data) && is_array($data['hotspots']) && count($data['hotspots']) > 0) {
  341.             $data['hotspots'] = $rewritePath($data['hotspots']);
  342.         }
  344.         $this->id = $data['id'] ?? null;
  345.         $this->alt = $data['alt'] ?? null;
  346.         $this->cropPercent = $data['cropPercent'] ?? null;
  347.         $this->cropWidth = $data['cropWidth'] ?? null;
  348.         $this->cropHeight = $data['cropHeight'] ?? null;
  349.         $this->cropTop = $data['cropTop'] ?? null;
  350.         $this->cropLeft = $data['cropLeft'] ?? null;
  351.         $this->marker = $data['marker'] ?? null;
  352.         $this->hotspots = $data['hotspots'] ?? null;
  353.         $this->thumbnail = $data['thumbnail'] ?? null;
  355.         return $this;
  356.     }
  358.     /**
  359.      * {@inheritdoc}
  360.      */
  361.     public function setDataFromEditmode($data)
  362.     {
  363.         $rewritePath = function ($data) {
  364.             if (!is_array($data)) {
  365.                 return [];
  366.             }
  368.             foreach ($data as &$element) {
  369.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  370.                     foreach ($element['data'] as &$metaData) {
  371.                         $metaData = new Element\Data\MarkerHotspotItem($metaData);
  372.                         if (in_array($metaData['type'], ['object', 'asset', 'document'])) {
  373.                             $el = Element\Service::getElementByPath($metaData['type'], $metaData->getValue());
  374.                             $metaData['value'] = $el;
  375.                         }
  376.                     }
  377.                 }
  378.             }
  380.             return $data;
  381.         };
  383.         if (is_array($data)) {
  384.             if (array_key_exists('marker', $data) && is_array($data['marker']) && count($data['marker']) > 0) {
  385.                 $data['marker'] = $rewritePath($data['marker']);
  386.             }
  388.             if (array_key_exists('hotspots', $data) && is_array($data['hotspots']) && count($data['hotspots']) > 0) {
  389.                 $data['hotspots'] = $rewritePath($data['hotspots']);
  390.             }
  392.             $this->id = $data['id'] ?? null;
  393.             $this->alt = $data['alt'] ?? null;
  394.             $this->cropPercent = $data['cropPercent'] ?? null;
  395.             $this->cropWidth = $data['cropWidth'] ?? null;
  396.             $this->cropHeight = $data['cropHeight'] ?? null;
  397.             $this->cropTop = $data['cropTop'] ?? null;
  398.             $this->cropLeft = $data['cropLeft'] ?? null;
  399.             $this->marker = $data['marker'] ?? null;
  400.             $this->hotspots = $data['hotspots'] ?? null;
  401.             $this->thumbnail = $data['thumbnail'] ?? null;
  402.         }
  404.         return $this;
  405.     }
  407.     /**
  408.      * @return string
  409.      */
  410.     public function getText()
  411.     {
  412.         return $this->alt;
  413.     }
  415.     /**
  416.      * @param string $text
  417.      */
  418.     public function setText($text)
  419.     {
  420.         $this->alt = $text;
  421.     }
  423.     /**
  424.      * @return string
  425.      */
  426.     public function getAlt()
  427.     {
  428.         return $this->getText();
  429.     }
  431.     /**
  432.      * @return string|null
  433.      */
  434.     public function getThumbnailConfig()
  435.     {
  436.         return $this->thumbnail;
  437.     }
  439.     /**
  440.      * @return string
  441.      */
  442.     public function getSrc()
  443.     {
  444.         $image = $this->getImage();
  445.         if ($image instanceof Asset) {
  446.             return $image->getFullPath();
  447.         }
  449.         return '';
  450.     }
  452.     /**
  453.      * @return Asset\Image|null
  454.      */
  455.     public function getImage()
  456.     {
  457.         if (!$this->image instanceof Asset\Image) {
  458.             $this->image = $this->getId() ? Asset\Image::getById($this->getId()) : null;
  459.         }
  461.         return $this->image;
  462.     }
  464.     /**
  465.      * @param Asset\Image|ElementDescriptor|null $image
  466.      *
  467.      * @return $this
  468.      */
  469.     public function setImage($image)
  470.     {
  471.         $this->image = $image;
  473.         if ($image instanceof Asset\Image) {
  474.             $this->setId($image->getId());
  475.         }
  477.         return $this;
  478.     }
  480.     /**
  481.      * @param int|null $id
  482.      *
  483.      * @return $this
  484.      */
  485.     public function setId($id)
  486.     {
  487.         $this->id = $id ? (int)$id : null;
  489.         return $this;
  490.     }
  492.     /**
  493.      * @return int|null
  494.      */
  495.     public function getId()
  496.     {
  497.         return $this->id;
  498.     }
  500.     /**
  501.      * @param array|string|Asset\Image\Thumbnail\Config $conf
  502.      * @param bool $deferred
  503.      *
  504.      * @return Asset\Image\Thumbnail|string
  505.      */
  506.     public function getThumbnail($conf, $deferred = true)
  507.     {
  508.         $image = $this->getImage();
  509.         if ($image instanceof Asset\Image) {
  510.             $thumbConfig = $image->getThumbnailConfig($conf);
  511.             if ($thumbConfig && $this->cropPercent) {
  512.                 $this->applyCustomCropping($thumbConfig);
  513.                 $thumbConfig->generateAutoName();
  514.             }
  516.             return $image->getThumbnail($thumbConfig, $deferred);
  517.         }
  519.         return '';
  520.     }
  522.     /**
  523.      * @param Asset\Image\Thumbnail\Config $thumbConfig
  524.      *
  525.      * @return void
  526.      */
  527.     private function applyCustomCropping($thumbConfig)
  528.     {
  529.         $cropConfig = [
  530.             'width' => $this->cropWidth,
  531.             'height' => $this->cropHeight,
  532.             'y' => $this->cropTop,
  533.             'x' => $this->cropLeft,
  534.         ];
  536.         $thumbConfig->addItemAt(0, 'cropPercent', $cropConfig);
  538.         // also crop media query specific configs
  539.         if ($thumbConfig->hasMedias()) {
  540.             foreach ($thumbConfig->getMedias() as $mediaName => $mediaItems) {
  541.                 $thumbConfig->addItemAt(0, 'cropPercent', $cropConfig, $mediaName);
  542.             }
  543.         }
  544.     }
  546.     /**
  547.      * {@inheritdoc}
  548.      */
  549.     public function isEmpty()
  550.     {
  551.         $image = $this->getImage();
  552.         if ($image instanceof Asset\Image) {
  553.             return false;
  554.         }
  556.         return true;
  557.     }
  559.     /**
  560.      * {@inheritdoc}
  561.      */
  562.     public function getCacheTags(Model\Document\PageSnippet $ownerDocument, array $tags = []): array
  563.     {
  564.         $image = $this->getImage();
  566.         if ($image instanceof Asset) {
  567.             if (!array_key_exists($image->getCacheTag(), $tags)) {
  568.                 $tags = $image->getCacheTags($tags);
  569.             }
  570.         }
  572.         $getMetaDataCacheTags = function ($data, $tags) {
  573.             if (!is_array($data)) {
  574.                 return $tags;
  575.             }
  577.             foreach ($data as $element) {
  578.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  579.                     foreach ($element['data'] as $metaData) {
  580.                         if ($metaData instanceof Element\Data\MarkerHotspotItem) {
  581.                             $metaData = get_object_vars($metaData);
  582.                         }
  584.                         if ($metaData['value'] instanceof Element\ElementInterface) {
  585.                             if (!array_key_exists($metaData['value']->getCacheTag(), $tags)) {
  586.                                 $tags = $metaData['value']->getCacheTags($tags);
  587.                             }
  588.                         }
  589.                     }
  590.                 }
  591.             }
  593.             return $tags;
  594.         };
  596.         $tags = $getMetaDataCacheTags($this->marker, $tags);
  597.         $tags = $getMetaDataCacheTags($this->hotspots, $tags);
  599.         return $tags;
  600.     }
  602.     /**
  603.      * @return array
  604.      */
  605.     public function resolveDependencies()
  606.     {
  607.         $dependencies = [];
  608.         $image = $this->getImage();
  610.         if ($image instanceof Asset\Image) {
  611.             $key = 'asset_' . $image->getId();
  613.             $dependencies[$key] = [
  614.                 'id' => $image->getId(),
  615.                 'type' => 'asset',
  616.             ];
  617.         }
  619.         $getMetaDataDependencies = function ($data, $dependencies) {
  620.             if (!is_array($data)) {
  621.                 return $dependencies;
  622.             }
  624.             foreach ($data as $element) {
  625.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  626.                     foreach ($element['data'] as $metaData) {
  627.                         if ($metaData instanceof Element\Data\MarkerHotspotItem) {
  628.                             $metaData = get_object_vars($metaData);
  629.                         }
  631.                         if ($metaData['value'] instanceof Element\ElementInterface) {
  632.                             $dependencies[$metaData['type'] . '_' . $metaData['value']->getId()] = [
  633.                                 'id' => $metaData['value']->getId(),
  634.                                 'type' => $metaData['type'],
  635.                             ];
  636.                         }
  637.                     }
  638.                 }
  639.             }
  641.             return $dependencies;
  642.         };
  644.         $dependencies = $getMetaDataDependencies($this->marker, $dependencies);
  645.         $dependencies = $getMetaDataDependencies($this->hotspots, $dependencies);
  647.         return $dependencies;
  648.     }
  650.     /**
  651.      * @param float $cropHeight
  652.      *
  653.      * @return $this
  654.      */
  655.     public function setCropHeight($cropHeight)
  656.     {
  657.         $this->cropHeight = $cropHeight;
  659.         return $this;
  660.     }
  662.     /**
  663.      * @return float
  664.      */
  665.     public function getCropHeight()
  666.     {
  667.         return $this->cropHeight;
  668.     }
  670.     /**
  671.      * @param float $cropLeft
  672.      *
  673.      * @return $this
  674.      */
  675.     public function setCropLeft($cropLeft)
  676.     {
  677.         $this->cropLeft = $cropLeft;
  679.         return $this;
  680.     }
  682.     /**
  683.      * @return float
  684.      */
  685.     public function getCropLeft()
  686.     {
  687.         return $this->cropLeft;
  688.     }
  690.     /**
  691.      * @param bool $cropPercent
  692.      *
  693.      * @return $this
  694.      */
  695.     public function setCropPercent($cropPercent)
  696.     {
  697.         $this->cropPercent = $cropPercent;
  699.         return $this;
  700.     }
  702.     /**
  703.      * @return bool
  704.      */
  705.     public function getCropPercent()
  706.     {
  707.         return $this->cropPercent;
  708.     }
  710.     /**
  711.      * @param float $cropTop
  712.      *
  713.      * @return $this
  714.      */
  715.     public function setCropTop($cropTop)
  716.     {
  717.         $this->cropTop = $cropTop;
  719.         return $this;
  720.     }
  722.     /**
  723.      * @return float
  724.      */
  725.     public function getCropTop()
  726.     {
  727.         return $this->cropTop;
  728.     }
  730.     /**
  731.      * @param float $cropWidth
  732.      *
  733.      * @return $this
  734.      */
  735.     public function setCropWidth($cropWidth)
  736.     {
  737.         $this->cropWidth = $cropWidth;
  739.         return $this;
  740.     }
  742.     /**
  743.      * @return float
  744.      */
  745.     public function getCropWidth()
  746.     {
  747.         return $this->cropWidth;
  748.     }
  750.     /**
  751.      * @param array $hotspots
  752.      */
  753.     public function setHotspots($hotspots)
  754.     {
  755.         $this->hotspots = $hotspots;
  756.     }
  758.     /**
  759.      * @return array
  760.      */
  761.     public function getHotspots()
  762.     {
  763.         return $this->hotspots;
  764.     }
  766.     /**
  767.      * @param array $marker
  768.      */
  769.     public function setMarker($marker)
  770.     {
  771.         $this->marker = $marker;
  772.     }
  774.     /**
  775.      * @return array
  776.      */
  777.     public function getMarker()
  778.     {
  779.         return $this->marker;
  780.     }
  782.     /**
  783.      * {@inheritdoc}
  784.      */
  785.     public function rewriteIds($idMapping) /** : void */
  786.     {
  787.         if (array_key_exists('asset', $idMapping) && array_key_exists($this->getId(), $idMapping['asset'])) {
  788.             $this->setId($idMapping['asset'][$this->getId()]);
  790.             // reset marker & hotspot information
  791.             $this->setHotspots([]);
  792.             $this->setMarker([]);
  793.             $this->setCropPercent(false);
  794.             $this->setImage(null);
  795.         }
  796.     }
  798.     /**
  799.      * @return array
  800.      */
  801.     public function __sleep()
  802.     {
  803.         $finalVars = [];
  804.         $parentVars = parent::__sleep();
  806.         $blockedVars = ['image'];
  808.         foreach ($parentVars as $key) {
  809.             if (!in_array($key, $blockedVars)) {
  810.                 $finalVars[] = $key;
  811.             }
  812.         }
  814.         return $finalVars;
  815.     }
  816. }