vendor/isotope/isotope-core/system/modules/isotope/library/Isotope/Model/Gallery/Standard.php line 339

Open in your IDE?
  1. <?php
  3. /*
  4.  * Isotope eCommerce for Contao Open Source CMS
  5.  *
  6.  * Copyright (C) 2009 - 2019 terminal42 gmbh & Isotope eCommerce Workgroup
  7.  *
  8.  * @link       https://isotopeecommerce.org
  9.  * @license    https://opensource.org/licenses/lgpl-3.0.html
  10.  */
  12. namespace Isotope\Model\Gallery;
  14. use Contao\Environment;
  15. use Contao\File;
  16. use Contao\FilesModel;
  17. use Contao\Picture;
  18. use Contao\StringUtil;
  19. use Contao\System;
  20. use Haste\Image\Image;
  21. use Isotope\Interfaces\IsotopeGallery;
  22. use Isotope\Model\Gallery;
  23. use Isotope\Template;
  25. /**
  26.  * Standard implements a lightbox gallery
  27.  *
  28.  * @property string $lightbox_size
  29.  * @property string $lightbox_watermark_image
  30.  * @property string $lightbox_watermark_position
  31.  * @property string $lightbox_template
  32.  */
  33. class Standard extends Gallery implements IsotopeGallery
  34. {
  36.     /**
  37.      * Template
  38.      * @var string
  39.      */
  40.     protected $strTemplate = 'iso_gallery_standard';
  42.     /**
  43.      * Attribute name
  44.      * @var string
  45.      */
  46.     protected $strName;
  48.     /**
  49.      * Files
  50.      * @var array
  51.      */
  52.     protected $arrFiles = array();
  54.     /**
  55.      * Images cache
  56.      * @var array
  57.      */
  58.     private $arrImages = array();
  60.     /**
  61.      * Override template if available in record
  62.      *
  63.      * @param array $arrData The data record
  64.      *
  65.      * @return $this The model object
  66.      */
  67.     public function setRow(array $arrData)
  68.     {
  69.         if ($arrData['customTpl'] != '' && 'FE' === TL_MODE) {
  70.             $this->strTemplate = $arrData['customTpl'];
  71.         }
  73.         return parent::setRow($arrData);
  74.     }
  77.     /**
  78.      * Set gallery attribute name
  79.      *
  80.      * @param string $strName
  81.      */
  82.     public function setName($strName)
  83.     {
  84.         $this->strName = $strName;
  85.     }
  87.     /**
  88.      * Get gallery attribute name
  89.      *
  90.      * @return string
  91.      */
  92.     public function getName()
  93.     {
  94.         return $this->strName;
  95.     }
  97.     /**
  98.      * Set gallery template
  99.      *
  100.      * @param string $strTemplate
  101.      */
  102.     public function setTemplate($strTemplate)
  103.     {
  104.         $this->strTemplate = $strTemplate;
  105.     }
  107.     /**
  108.      * Get gallery template
  109.      *
  110.      * @return string
  111.      */
  112.     public function getTemplate()
  113.     {
  114.         return $this->strTemplate;
  115.     }
  117.     /**
  118.      * Set image files
  119.      *
  120.      * @param array $arrFiles
  121.      */
  122.     public function setFiles(array $arrFiles)
  123.     {
  124.         $this->arrFiles = array_values($arrFiles);
  125.     }
  127.     /**
  128.      * Get image files
  129.      *
  130.      * @return array
  131.      */
  132.     public function getFiles()
  133.     {
  134.         return $this->arrFiles;
  135.     }
  138.     /**
  139.      * Get the number of images
  140.      *
  141.      * @return int
  142.      */
  143.     public function size()
  144.     {
  145.         return \count($this->arrFiles);
  146.     }
  149.     /**
  150.      * Returns whether the gallery object has an image do display or not
  151.      *
  152.      * @return bool
  153.      */
  154.     public function hasImages()
  155.     {
  156.         // Check files array here because we don't need to generate an image just to know if there are images
  157.         return \count($this->arrFiles) > 0;
  158.     }
  160.     /**
  161.      * Checks if a placeholder image is defined
  162.      *
  163.      * @return bool
  164.      */
  165.     protected function hasPlaceholderImage()
  166.     {
  167.         return ($this->placeholder && null !== FilesModel::findByPk($this->placeholder));
  168.     }
  170.     /**
  171.      * Generate main image and return it as HTML string
  172.      *
  173.      * @return string
  174.      */
  175.     public function generateMainImage()
  176.     {
  177.         $hasImages = $this->hasImages();
  179.         if (!$hasImages && !$this->hasPlaceholderImage()) {
  180.             return '';
  181.         }
  183.         /** @var Template|object $objTemplate */
  184.         $objTemplate = new Template($this->strTemplate);
  186.         $this->addImageToTemplate(
  187.             $objTemplate,
  188.             'main',
  189.             ($hasImages ? $this->arrFiles[0] : $this->getPlaceholderImage()),
  190.             $hasImages
  191.         );
  193.         $objTemplate->javascript = '';
  195.         if (Environment::get('isAjaxRequest')) {
  196.             $strScripts = '';
  197.             $arrTemplates = StringUtil::deserialize($this->lightbox_template, true);
  199.             if (!empty($arrTemplates)) {
  200.                 foreach ($arrTemplates as $strTemplate) {
  201.                     $objScript = new Template($strTemplate);
  202.                     $strScripts .= $objScript->parse();
  203.                 }
  204.             }
  206.             $objTemplate->javascript = $strScripts;
  207.         }
  209.         return $objTemplate->parse();
  210.     }
  212.     /**
  213.      * Generate gallery and return it as HTML string
  214.      *
  215.      * @param int $intSkip
  216.      *
  217.      * @return string
  218.      */
  219.     public function generateGallery($intSkip = 1)
  220.     {
  221.         // If we skip one or more images or no placeholder image is available there's no gallery
  222.         if (!$this->hasImages() && ($intSkip >= 1 || !$this->hasPlaceholderImage())) {
  223.             return '';
  224.         }
  226.         $strGallery = '';
  227.         $watermark  = true;
  228.         $arrFiles   = \array_slice($this->arrFiles, $intSkip);
  230.         // Add placeholder for the gallery
  231.         if (0 === \count($arrFiles) && $intSkip < 1) {
  232.             $arrFiles[] = $this->getPlaceholderImage();
  233.             $watermark  = false;
  234.         }
  236.         foreach ($arrFiles as $arrFile) {
  237.             $objTemplate = new Template($this->strTemplate);
  239.             $this->addImageToTemplate($objTemplate, 'gallery', $arrFile, $watermark);
  241.             $strGallery .= $objTemplate->parse();
  242.         }
  244.         return $strGallery;
  245.     }
  247.     /**
  248.      * If the class is echoed, return the main image
  249.      *
  250.      * @return string
  251.      */
  252.     public function __toString()
  253.     {
  254.         return $this->generateMainImage();
  255.     }
  257.     /**
  258.      * Generate template with given file
  259.      *
  260.      * @param Template|object $objTemplate
  261.      * @param string          $strType
  262.      * @param array           $arrFile
  263.      * @param bool            $blnWatermark
  264.      *
  265.      * @return string
  266.      */
  267.     protected function addImageToTemplate(Template $objTemplate, $strType, array $arrFile, $blnWatermark = true)
  268.     {
  269.         $arrFile = $this->getImageForType($strType, $arrFile, $blnWatermark);
  271.         $objTemplate->setData($this->arrData);
  272.         $objTemplate->type       = $strType;
  273.         $objTemplate->name       = $this->getName();
  274.         $objTemplate->product_id = $this->product_id;
  275.         $objTemplate->file       = $arrFile;
  276.         $objTemplate->src        = $arrFile[$strType];
  277.         $objTemplate->size       = $arrFile[$strType . '_size'];
  278.         $objTemplate->alt        = $arrFile['alt'];
  279.         $objTemplate->title      = $arrFile['desc'];
  280.         $objTemplate->class      = trim(($this->arrData['class'] ?? '') . ' ' . ($arrFile['class'] ?? ''));
  282.         // Add the missing data to the picture
  283.         $arrFile['picture']['alt']   = $objTemplate->alt;
  284.         $arrFile['picture']['title'] = $objTemplate->title;
  285.         $arrFile['picture']['class'] = $objTemplate->class;
  287.         $objTemplate->picture = $arrFile['picture'];
  289.         switch ($this->anchor) {
  290.             case 'reader':
  291.                 $objTemplate->hasLink = ($this->href != '');
  292.                 $objTemplate->link    = $this->href;
  293.                 break;
  295.             case 'lightbox':
  296.                 $arrFile = $this->getImageForType('lightbox', $arrFile, $blnWatermark);
  297.                 [$link, $rel] = explode('|', $arrFile['link'], 2) + [null, null];
  298.                 $attributes = ($rel ? ' data-lightbox="' . $rel . '"' : ' target="_blank"');
  300.                 $objTemplate->hasLink    = true;
  301.                 $objTemplate->link       = $link ?: $arrFile['lightbox'];
  302.                 $objTemplate->attributes = ($link ? $attributes : ' data-lightbox="product' . $this->product_id . '"');
  303.                 break;
  305.             default:
  306.                 $objTemplate->hasLink = false;
  307.                 break;
  308.         }
  309.     }
  311.     /**
  312.      * Gets the placeholder image
  313.      *
  314.      * @return array
  315.      *
  316.      * @throws \UnderflowException If no placeholder image is found
  317.      */
  318.     protected function getPlaceholderImage()
  319.     {
  320.         $objPlaceholder = FilesModel::findByPk($this->placeholder);
  322.         if (null === $objPlaceholder) {
  323.             throw new \UnderflowException('Placeholder image requested but not defined!');
  324.         }
  326.         return array('src' => $objPlaceholder->path);
  327.     }
  329.     /**
  330.      * Gets the image for a given file and given type and optionally adds a watermark to it
  331.      *
  332.      * @param   string $strType
  333.      * @param   array $arrFile
  334.      * @param   bool  $blnWatermark
  335.      *
  336.      * @return  array
  337.      * @throws  \InvalidArgumentException
  338.      */
  339.     protected function getImageForType($strType, array $arrFile, $blnWatermark = true)
  340.     {
  341.         // Check cache
  342.         $strCacheKey = md5($strType . '-' . json_encode($arrFile) . '-' . (int) $blnWatermark);
  344.         if (isset($this->arrImages[$strCacheKey])) {
  345.             return $this->arrImages[$strCacheKey];
  346.         }
  348.         $strFile = $arrFile['src'];
  350.         // File without path must be located in the isotope root folder
  351.         if (strpos($strFile, '/') === false) {
  352.             $strFile = 'isotope/' . strtolower(substr($strFile, 0, 1)) . '/' . $strFile;
  353.         }
  355.         $objFile = new File($strFile);
  357.         if (!$objFile->exists()) {
  358.             return [];
  359.         }
  361.         $size = StringUtil::deserialize($this->{$strType . '_size'}, true);
  363.         try {
  364.             $strImage = \Contao\Image::create($strFile, $size)->executeResize()->getResizedPath();
  365.             $picture = Picture::create($strFile, $size)->getTemplateData();
  366.         } catch (\Exception $e) {
  367.             System::log('Image "' . $strFile . '" could not be processed: ' . $e->getMessage(), __METHOD__, TL_ERROR);
  369.             $strImage = '';
  370.             $picture = array('img'=>array('src'=>'', 'srcset'=>''), 'sources'=>array());
  371.         }
  373.         // Watermark
  374.         if ($blnWatermark
  375.             && $this->{$strType . '_watermark_image'} != ''
  376.             && ($objWatermark = FilesModel::findByUuid($this->{$strType . '_watermark_image'})) !== null
  377.         ) {
  378.             if (method_exists(File::class, 'createIfDeferred')) {
  379.                 (new File(rawurldecode($strImage)))->createIfDeferred();
  380.             }
  382.             $strImage = Image::addWatermark($strImage, $objWatermark->path, $this->{$strType . '_watermark_position'});
  384.             // Apply watermark to the picture image source
  385.             if ($picture['img']['src']) {
  386.                 $picture['img']['src'] = Image::addWatermark($picture['img']['src'], $objWatermark->path, $this->{$strType . '_watermark_position'});
  387.             }
  389.             // Apply watermark to the picture sources
  390.             foreach ($picture['sources'] as $k => $v) {
  391.                 $picture['sources'][$k]['src'] = Image::addWatermark($v['src'], $objWatermark->path, $this->{$strType . '_watermark_position'});
  392.             }
  393.         }
  395.         $arrSize = (new File(rawurldecode($strImage)))->imageSize;
  397.         if (\is_array($arrSize) && $arrSize[3] !== '') {
  398.             $arrFile[$strType . '_size']      = $arrSize[3];
  399.             $arrFile[$strType . '_imageSize'] = $arrSize;
  400.         }
  402.         $arrFile['alt']     = StringUtil::specialchars($arrFile['alt'] ?? '', true);
  403.         $arrFile['desc']    = StringUtil::specialchars($arrFile['desc'] ?? '', true);
  404.         $arrFile['picture'] = $picture;
  406.         $arrFile[$strType] = TL_ASSETS_URL . $strImage;
  408.         $this->arrImages[$strCacheKey] = $arrFile;
  410.         return $arrFile;
  411.     }
  412. }