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

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\Tool\Serialize;
  23. /**
  24.  * @method \Pimcore\Model\Document\Editable\Dao getDao()
  25.  */
  26. class Image extends Model\Document\Editable implements IdRewriterInterface, EditmodeDataInterface
  27. {
  28.     /**
  29.      * ID of the referenced image
  30.      *
  31.      * @internal
  32.      *
  33.      * @var int
  34.      */
  35.     protected $id;
  37.     /**
  38.      * The ALT text of the image
  39.      *
  40.      * @internal
  41.      *
  42.      * @var string
  43.      */
  44.     protected $alt;
  46.     /**
  47.      * Contains the imageobject itself
  48.      *
  49.      * @internal
  50.      *
  51.      * @var Asset\Image|null
  52.      */
  53.     protected $image;
  55.     /**
  56.      * @internal
  57.      *
  58.      * @var bool
  59.      */
  60.     protected $cropPercent = false;
  62.     /**
  63.      * @internal
  64.      *
  65.      * @var float
  66.      */
  67.     protected $cropWidth;
  69.     /**
  70.      * @internal
  71.      *
  72.      * @var float
  73.      */
  74.     protected $cropHeight;
  76.     /**
  77.      * @internal
  78.      *
  79.      * @var float
  80.      */
  81.     protected $cropTop;
  83.     /**
  84.      * @internal
  85.      *
  86.      * @var float
  87.      */
  88.     protected $cropLeft;
  90.     /**
  91.      * @internal
  92.      *
  93.      * @var array
  94.      */
  95.     protected $hotspots = [];
  97.     /**
  98.      * @internal
  99.      *
  100.      * @var array
  101.      */
  102.     protected $marker = [];
  104.     /**
  105.      * {@inheritdoc}
  106.      */
  107.     public function getType()
  108.     {
  109.         return 'image';
  110.     }
  112.     /**
  113.      * {@inheritdoc}
  114.      */
  115.     public function getData()
  116.     {
  117.         return [
  118.             'id' => $this->id,
  119.             'alt' => $this->alt,
  120.             'cropPercent' => $this->cropPercent,
  121.             'cropWidth' => $this->cropWidth,
  122.             'cropHeight' => $this->cropHeight,
  123.             'cropTop' => $this->cropTop,
  124.             'cropLeft' => $this->cropLeft,
  125.             'hotspots' => $this->hotspots,
  126.             'marker' => $this->marker,
  127.         ];
  128.     }
  130.     /**
  131.      * {@inheritdoc}
  132.      */
  133.     public function getDataForResource()
  134.     {
  135.         return [
  136.             'id' => $this->id,
  137.             'alt' => $this->alt,
  138.             'cropPercent' => $this->cropPercent,
  139.             'cropWidth' => $this->cropWidth,
  140.             'cropHeight' => $this->cropHeight,
  141.             'cropTop' => $this->cropTop,
  142.             'cropLeft' => $this->cropLeft,
  143.             'hotspots' => $this->hotspots,
  144.             'marker' => $this->marker,
  145.         ];
  146.     }
  148.     /**
  149.      * {@inheritdoc}
  150.      */
  151.     public function getDataEditmode() /** : mixed */
  152.     {
  153.         $image = $this->getImage();
  155.         if ($image instanceof Asset\Image) {
  156.             $rewritePath = function ($data) {
  157.                 if (!is_array($data)) {
  158.                     return [];
  159.                 }
  161.                 foreach ($data as &$element) {
  162.                     if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  163.                         foreach ($element['data'] as &$metaData) {
  164.                             if ($metaData['value'] instanceof Element\ElementInterface) {
  165.                                 $metaData['value'] = $metaData['value']->getRealFullPath();
  166.                             }
  167.                         }
  168.                     }
  169.                 }
  171.                 return $data;
  172.             };
  174.             $marker = $rewritePath($this->marker);
  175.             $hotspots = $rewritePath($this->hotspots);
  177.             $marker = object2array($marker);
  178.             $hotspots = object2array($hotspots);
  180.             return [
  181.                 'id' => $this->id,
  182.                 'path' => $image->getRealFullPath(),
  183.                 'alt' => $this->alt,
  184.                 'cropPercent' => $this->cropPercent,
  185.                 'cropWidth' => $this->cropWidth,
  186.                 'cropHeight' => $this->cropHeight,
  187.                 'cropTop' => $this->cropTop,
  188.                 'cropLeft' => $this->cropLeft,
  189.                 'hotspots' => $hotspots,
  190.                 'marker' => $marker,
  191.                 'predefinedDataTemplates' => $this->getConfig()['predefinedDataTemplates'] ?? null,
  192.             ];
  193.         }
  195.         return null;
  196.     }
  198.     /**
  199.      * {@inheritdoc}
  200.      */
  201.     public function getConfig()
  202.     {
  203.         $config = parent::getConfig();
  204.         if (isset($config['thumbnail']) && !isset($config['focal_point_context_menu_item'])) {
  205.             $thumbConfig = Asset\Image\Thumbnail\Config::getByAutoDetect($config['thumbnail']);
  206.             if ($thumbConfig) {
  207.                 foreach ($thumbConfig->getItems() as $item) {
  208.                     if ($item['method'] == 'cover') {
  209.                         $config['focal_point_context_menu_item'] = true;
  210.                         $this->config['focal_point_context_menu_item'] = true;
  212.                         break;
  213.                     }
  214.                 }
  215.             }
  216.         }
  218.         return $config;
  219.     }
  221.     /**
  222.      * {@inheritdoc}
  223.      */
  224.     public function frontend()
  225.     {
  226.         if (!is_array($this->config)) {
  227.             $this->config = [];
  228.         }
  230.         $image = $this->getImage();
  232.         if ($image instanceof Asset) {
  233.             $thumbnailName = $this->config['thumbnail'] ?? null;
  234.             if ($thumbnailName || $this->cropPercent) {
  235.                 // create a thumbnail first
  236.                 $autoName = false;
  238.                 $thumbConfig = $image->getThumbnailConfig($thumbnailName);
  239.                 if (!$thumbConfig && $this->cropPercent) {
  240.                     $thumbConfig = new Asset\Image\Thumbnail\Config();
  241.                 }
  243.                 if ($this->cropPercent) {
  244.                     $this->applyCustomCropping($thumbConfig);
  245.                     $autoName = true;
  246.                 }
  248.                 if (isset($this->config['highResolution']) && $this->config['highResolution'] > 1) {
  249.                     $thumbConfig->setHighResolution($this->config['highResolution']);
  250.                 }
  252.                 // autogenerate a name for the thumbnail because it's different from the original
  253.                 if ($autoName) {
  254.                     $hash = md5(Serialize::serialize($thumbConfig->getItems()));
  255.                     $thumbConfig->setName($thumbConfig->getName() . '_auto_' . $hash);
  256.                 }
  258.                 $deferred = true;
  259.                 if (isset($this->config['deferred'])) {
  260.                     $deferred = $this->config['deferred'];
  261.                 }
  263.                 $thumbnail = $image->getThumbnail($thumbConfig, $deferred);
  264.             } else {
  265.                 // we're using the thumbnail class only to generate the HTML
  266.                 $thumbnail = $image->getThumbnail();
  267.             }
  269.             $attributes = array_merge($this->config, [
  270.                 'alt' => $this->alt,
  271.                 'title' => $this->alt,
  272.             ]);
  274.             $removeAttributes = [];
  275.             if (isset($this->config['removeAttributes']) && is_array($this->config['removeAttributes'])) {
  276.                 $removeAttributes = $this->config['removeAttributes'];
  277.             }
  279.             // thumbnail's HTML is always generated by the thumbnail itself
  280.             return $thumbnail->getHtml($attributes);
  281.         }
  283.         return '';
  284.     }
  286.     /**
  287.      * {@inheritdoc}
  288.      */
  289.     public function setDataFromResource($data)
  290.     {
  291.         if (strlen($data) > 2) {
  292.             $data = Serialize::unserialize($data);
  293.         }
  295.         $rewritePath = function ($data) {
  296.             if (!is_array($data)) {
  297.                 return [];
  298.             }
  300.             foreach ($data as &$element) {
  301.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  302.                     foreach ($element['data'] as &$metaData) {
  303.                         // this is for backward compatibility (Array vs. MarkerHotspotItem)
  304.                         if (is_array($metaData)) {
  305.                             $metaData = new Element\Data\MarkerHotspotItem($metaData);
  306.                         }
  307.                     }
  308.                 }
  309.             }
  311.             return $data;
  312.         };
  314.         if (array_key_exists('marker', $data) && is_array($data['marker']) && count($data['marker']) > 0) {
  315.             $data['marker'] = $rewritePath($data['marker']);
  316.         }
  318.         if (array_key_exists('hotspots', $data) && is_array($data['hotspots']) && count($data['hotspots']) > 0) {
  319.             $data['hotspots'] = $rewritePath($data['hotspots']);
  320.         }
  322.         $this->id = $data['id'] ?? null;
  323.         $this->alt = $data['alt'] ?? null;
  324.         $this->cropPercent = $data['cropPercent'] ?? null;
  325.         $this->cropWidth = $data['cropWidth'] ?? null;
  326.         $this->cropHeight = $data['cropHeight'] ?? null;
  327.         $this->cropTop = $data['cropTop'] ?? null;
  328.         $this->cropLeft = $data['cropLeft'] ?? null;
  329.         $this->marker = $data['marker'] ?? null;
  330.         $this->hotspots = $data['hotspots'] ?? null;
  332.         return $this;
  333.     }
  335.     /**
  336.      * {@inheritdoc}
  337.      */
  338.     public function setDataFromEditmode($data)
  339.     {
  340.         $rewritePath = function ($data) {
  341.             if (!is_array($data)) {
  342.                 return [];
  343.             }
  345.             foreach ($data as &$element) {
  346.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  347.                     foreach ($element['data'] as &$metaData) {
  348.                         $metaData = new Element\Data\MarkerHotspotItem($metaData);
  349.                         if (in_array($metaData['type'], ['object', 'asset', 'document'])) {
  350.                             $el = Element\Service::getElementByPath($metaData['type'], $metaData->getValue());
  351.                             $metaData['value'] = $el;
  352.                         }
  353.                     }
  354.                 }
  355.             }
  357.             return $data;
  358.         };
  360.         if (is_array($data)) {
  361.             if (array_key_exists('marker', $data) && is_array($data['marker']) && count($data['marker']) > 0) {
  362.                 $data['marker'] = $rewritePath($data['marker']);
  363.             }
  365.             if (array_key_exists('hotspots', $data) && is_array($data['hotspots']) && count($data['hotspots']) > 0) {
  366.                 $data['hotspots'] = $rewritePath($data['hotspots']);
  367.             }
  369.             $this->id = $data['id'] ?? null;
  370.             $this->alt = $data['alt'] ?? null;
  371.             $this->cropPercent = $data['cropPercent'] ?? null;
  372.             $this->cropWidth = $data['cropWidth'] ?? null;
  373.             $this->cropHeight = $data['cropHeight'] ?? null;
  374.             $this->cropTop = $data['cropTop'] ?? null;
  375.             $this->cropLeft = $data['cropLeft'] ?? null;
  376.             $this->marker = $data['marker'] ?? null;
  377.             $this->hotspots = $data['hotspots'] ?? null;
  378.         }
  380.         return $this;
  381.     }
  383.     /**
  384.      * @return string
  385.      */
  386.     public function getText()
  387.     {
  388.         return $this->alt;
  389.     }
  391.     /**
  392.      * @param string $text
  393.      */
  394.     public function setText($text)
  395.     {
  396.         $this->alt = $text;
  397.     }
  399.     /**
  400.      * @return string
  401.      */
  402.     public function getAlt()
  403.     {
  404.         return $this->getText();
  405.     }
  407.     /**
  408.      * @return string
  409.      */
  410.     public function getSrc()
  411.     {
  412.         $image = $this->getImage();
  413.         if ($image instanceof Asset) {
  414.             return $image->getFullPath();
  415.         }
  417.         return '';
  418.     }
  420.     /**
  421.      * @return Asset\Image|null
  422.      */
  423.     public function getImage()
  424.     {
  425.         if (!$this->image) {
  426.             $this->image = Asset\Image::getById($this->getId());
  427.         }
  429.         return $this->image;
  430.     }
  432.     /**
  433.      * @param Asset\Image|null $image
  434.      *
  435.      * @return Model\Document\Editable\Image
  436.      */
  437.     public function setImage($image)
  438.     {
  439.         $this->image = $image;
  441.         if ($image instanceof Asset) {
  442.             $this->setId($image->getId());
  443.         }
  445.         return $this;
  446.     }
  448.     /**
  449.      * @param int $id
  450.      *
  451.      * @return Model\Document\Editable\Image
  452.      */
  453.     public function setId($id)
  454.     {
  455.         $this->id = $id;
  457.         return $this;
  458.     }
  460.     /**
  461.      * @return int
  462.      */
  463.     public function getId()
  464.     {
  465.         return (int) $this->id;
  466.     }
  468.     /**
  469.      * @param string|array|Asset\Image\Thumbnail\Config $conf
  470.      * @param bool $deferred
  471.      *
  472.      * @return Asset\Image\Thumbnail|string
  473.      */
  474.     public function getThumbnail($conf, $deferred = true)
  475.     {
  476.         $image = $this->getImage();
  477.         if ($image instanceof Asset) {
  478.             $thumbConfig = $image->getThumbnailConfig($conf);
  479.             if ($thumbConfig && $this->cropPercent) {
  480.                 $this->applyCustomCropping($thumbConfig);
  481.                 $hash = md5(Serialize::serialize($thumbConfig->getItems()));
  482.                 $thumbConfig->setName($thumbConfig->getName() . '_auto_' . $hash);
  483.             }
  485.             return $image->getThumbnail($thumbConfig, $deferred);
  486.         }
  488.         return '';
  489.     }
  491.     /**
  492.      * @param Asset\Image\Thumbnail\Config $thumbConfig
  493.      */
  494.     private function applyCustomCropping($thumbConfig)
  495.     {
  496.         $cropConfig = [
  497.             'width' => $this->cropWidth,
  498.             'height' => $this->cropHeight,
  499.             'y' => $this->cropTop,
  500.             'x' => $this->cropLeft,
  501.         ];
  503.         $thumbConfig->addItemAt(0, 'cropPercent', $cropConfig);
  505.         // also crop media query specific configs
  506.         if ($thumbConfig->hasMedias()) {
  507.             foreach ($thumbConfig->getMedias() as $mediaName => $mediaItems) {
  508.                 $thumbConfig->addItemAt(0, 'cropPercent', $cropConfig, $mediaName);
  509.             }
  510.         }
  511.     }
  513.     /**
  514.      * {@inheritdoc}
  515.      */
  516.     public function isEmpty()
  517.     {
  518.         $image = $this->getImage();
  519.         if ($image instanceof Asset\Image) {
  520.             return false;
  521.         }
  523.         return true;
  524.     }
  526.     /**
  527.      * {@inheritdoc}
  528.      */
  529.     public function getCacheTags(Model\Document\PageSnippet $ownerDocument, array $tags = []): array
  530.     {
  531.         $image = $this->getImage();
  533.         if ($image instanceof Asset) {
  534.             if (!array_key_exists($image->getCacheTag(), $tags)) {
  535.                 $tags = $image->getCacheTags($tags);
  536.             }
  537.         }
  539.         $getMetaDataCacheTags = function ($data, $tags) {
  540.             if (!is_array($data)) {
  541.                 return $tags;
  542.             }
  544.             foreach ($data as $element) {
  545.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  546.                     foreach ($element['data'] as $metaData) {
  547.                         if ($metaData['value'] instanceof Element\ElementInterface) {
  548.                             if (!array_key_exists($metaData['value']->getCacheTag(), $tags)) {
  549.                                 $tags = $metaData['value']->getCacheTags($tags);
  550.                             }
  551.                         }
  552.                     }
  553.                 }
  554.             }
  556.             return $tags;
  557.         };
  559.         $tags = $getMetaDataCacheTags($this->marker, $tags);
  560.         $tags = $getMetaDataCacheTags($this->hotspots, $tags);
  562.         return $tags;
  563.     }
  565.     /**
  566.      * {@inheritdoc}
  567.      */
  568.     public function resolveDependencies()
  569.     {
  570.         $dependencies = [];
  571.         $image = $this->getImage();
  573.         if ($image instanceof Asset\Image) {
  574.             $key = 'asset_' . $image->getId();
  576.             $dependencies[$key] = [
  577.                 'id' => $image->getId(),
  578.                 'type' => 'asset',
  579.             ];
  580.         }
  582.         $getMetaDataDependencies = function ($data, $dependencies) {
  583.             if (!is_array($data)) {
  584.                 return $dependencies;
  585.             }
  587.             foreach ($data as $element) {
  588.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  589.                     foreach ($element['data'] as $metaData) {
  590.                         if ($metaData['value'] instanceof Element\ElementInterface) {
  591.                             $dependencies[$metaData['type'] . '_' . $metaData['value']->getId()] = [
  592.                                 'id' => $metaData['value']->getId(),
  593.                                 'type' => $metaData['type'],
  594.                             ];
  595.                         }
  596.                     }
  597.                 }
  598.             }
  600.             return $dependencies;
  601.         };
  603.         $dependencies = $getMetaDataDependencies($this->marker, $dependencies);
  604.         $dependencies = $getMetaDataDependencies($this->hotspots, $dependencies);
  606.         return $dependencies;
  607.     }
  609.     /**
  610.      * @param float $cropHeight
  611.      *
  612.      * @return $this
  613.      */
  614.     public function setCropHeight($cropHeight)
  615.     {
  616.         $this->cropHeight = $cropHeight;
  618.         return $this;
  619.     }
  621.     /**
  622.      * @return float
  623.      */
  624.     public function getCropHeight()
  625.     {
  626.         return $this->cropHeight;
  627.     }
  629.     /**
  630.      * @param float $cropLeft
  631.      *
  632.      * @return $this
  633.      */
  634.     public function setCropLeft($cropLeft)
  635.     {
  636.         $this->cropLeft = $cropLeft;
  638.         return $this;
  639.     }
  641.     /**
  642.      * @return float
  643.      */
  644.     public function getCropLeft()
  645.     {
  646.         return $this->cropLeft;
  647.     }
  649.     /**
  650.      * @param bool $cropPercent
  651.      *
  652.      * @return $this
  653.      */
  654.     public function setCropPercent($cropPercent)
  655.     {
  656.         $this->cropPercent = $cropPercent;
  658.         return $this;
  659.     }
  661.     /**
  662.      * @return bool
  663.      */
  664.     public function getCropPercent()
  665.     {
  666.         return $this->cropPercent;
  667.     }
  669.     /**
  670.      * @param float $cropTop
  671.      *
  672.      * @return $this
  673.      */
  674.     public function setCropTop($cropTop)
  675.     {
  676.         $this->cropTop = $cropTop;
  678.         return $this;
  679.     }
  681.     /**
  682.      * @return float
  683.      */
  684.     public function getCropTop()
  685.     {
  686.         return $this->cropTop;
  687.     }
  689.     /**
  690.      * @param float $cropWidth
  691.      *
  692.      * @return $this
  693.      */
  694.     public function setCropWidth($cropWidth)
  695.     {
  696.         $this->cropWidth = $cropWidth;
  698.         return $this;
  699.     }
  701.     /**
  702.      * @return float
  703.      */
  704.     public function getCropWidth()
  705.     {
  706.         return $this->cropWidth;
  707.     }
  709.     /**
  710.      * @param array $hotspots
  711.      */
  712.     public function setHotspots($hotspots)
  713.     {
  714.         $this->hotspots = $hotspots;
  715.     }
  717.     /**
  718.      * @return array
  719.      */
  720.     public function getHotspots()
  721.     {
  722.         return $this->hotspots;
  723.     }
  725.     /**
  726.      * @param array $marker
  727.      */
  728.     public function setMarker($marker)
  729.     {
  730.         $this->marker = $marker;
  731.     }
  733.     /**
  734.      * @return array
  735.      */
  736.     public function getMarker()
  737.     {
  738.         return $this->marker;
  739.     }
  741.     /**
  742.      * { @inheritdoc }
  743.      */
  744.     public function rewriteIds($idMapping) /** : void */
  745.     {
  746.         if (array_key_exists('asset', $idMapping) && array_key_exists($this->getId(), $idMapping['asset'])) {
  747.             $this->setId($idMapping['asset'][$this->getId()]);
  749.             // reset marker & hotspot information
  750.             $this->setHotspots([]);
  751.             $this->setMarker([]);
  752.             $this->setCropPercent(false);
  753.             $this->setImage(null);
  754.         }
  755.     }
  757.     public function __sleep()
  758.     {
  759.         $finalVars = [];
  760.         $parentVars = parent::__sleep();
  762.         $blockedVars = ['image'];
  764.         foreach ($parentVars as $key) {
  765.             if (!in_array($key, $blockedVars)) {
  766.                 $finalVars[] = $key;
  767.             }
  768.         }
  770.         return $finalVars;
  771.     }
  772. }