system/modules/pct_themer/PCT/ThemeDesigner.php line 131

Open in your IDE?
  1. <?php
  3. /**
  4.  * Contao Open Source CMS
  5.  * 
  6.  * Copyright (C) 2005-2013 Leo Feyer
  7.  * 
  8.  * @copyright    Tim Gatzky 2016, Premium Contao Themes
  9.  * @author        Tim Gatzky <info@tim-gatzky.de>
  10.  * @package        pct_themer
  11.  */
  13. /**
  14.  * Namespace
  15.  */
  16. namespace PCT;
  18. /**
  19.  * Imports
  20.  */
  21. use Contao\StringUtil;
  24. /**
  25.  * Class file
  26.  * ThemerDesigner
  27.  */
  28. class ThemeDesigner
  29. {
  30.     /**
  31.      * The template file
  32.      * @var string
  33.      */
  34.     protected $strTemplate = 'themedesigner';
  35.     
  36.     /**
  37.      * The javascript template file
  38.      * @var string
  39.      */
  40.     protected $strJsTemplate = 'js_themedesigner';
  42.     /**
  43.      * The naviagtion template file
  44.      * @var string
  45.      */
  46.     protected $strNavTemplate = 'themedesigner';
  47.     
  48.     /**
  49.      * The session name
  50.      * @var string
  51.      */
  52.     protected $strSession = 'PCT_THEMEDESIGNER';
  53.     
  54.     /**
  55.      * The config array
  56.      * @var array
  57.      */
  58.     protected $arrConfig = array();
  59.     
  60.     /**
  61.      * The data array
  62.      * @param array
  63.      */
  64.     protected $arrData = array();
  65.     
  66.     /**
  67.      * The css data array
  68.      * @param array
  69.      */
  70.     protected $arrDataCSS = array();
  71.     
  72.     /**
  73.      * Modified array
  74.      * @param array
  75.      */
  76.     protected $arrModified = array();
  77.     
  78.     
  79.     /**
  80.      * Init
  81.      */
  82.     public function __construct($arrData=null)
  83.     {
  84.         if( !isset($GLOBALS['PCT_THEMEDESIGNER_CONFIG']) )
  85.         {
  86.             $GLOBALS['PCT_THEMEDESIGNER_CONFIG'] = array();
  87.         }
  89.         $this->arrConfig = $GLOBALS['PCT_THEMEDESIGNER_CONFIG'] ?: array();
  90.         
  91.         // apply data
  92.         if(is_array($arrData))
  93.         {
  94.             $this->setData($arrData);
  95.         }
  96.     }
  99. // TODO: !Config
  102.     /**
  103.      * Set constants and include the preset config
  104.      */
  105.     public function loadConfig($objPage)
  106.     {
  107.         // check if Themer loads a layout
  108.         $objRoot = \Contao\PageModel::findByPk($objPage->rootId);
  109.         $strTheme = $objRoot->pct_theme ?: 'eclipse_default';
  110.         
  111.         // define constant
  112.         if( \defined('PCT_THEME') === false )
  113.         {
  114.             define('PCT_THEME',$strTheme);
  115.         }
  117.         if(file_exists(TL_ROOT.'/'.PCT_THEMER_PATH.'/config/themedesigner_config.php'))
  118.         {
  119.             require_once TL_ROOT.'/'.PCT_THEMER_PATH.'/config/themedesigner_config.php';
  120.         }
  122.         // include from templates folder
  123.         if(file_exists(TL_ROOT.'/templates/themedesigner/themedesigner_config.php'))
  124.         {
  125.             include_once TL_ROOT.'/templates/themedesigner/themedesigner_config.php';
  126.         }
  127.         
  128.         // load presets
  129.         if(file_exists(TL_ROOT.'/'.PCT_THEMER_PATH.'/config/themedesigner_presets.php'))
  130.         {
  131.             include_once TL_ROOT.'/'.PCT_THEMER_PATH.'/config/themedesigner_presets.php';
  132.         }
  134.         // HOOK to field definitions
  135.         if(is_array($GLOBALS['PCT_THEMEDESIGNER_FIELDS']) && !empty($GLOBALS['PCT_THEMEDESIGNER_FIELDS']))
  136.         {
  137.             foreach($GLOBALS['PCT_THEMEDESIGNER_CONFIG'] as $k => $v)
  138.             {
  139.                 if( empty($v['fields']) )
  140.                 {
  141.                     continue;
  142.                 }
  143.                 
  144.                 foreach($v['fields'] as $kk => $vv)
  145.                 {
  146.                     if( !isset($GLOBALS['PCT_THEMEDESIGNER_FIELDS'][$kk]) )
  147.                     {
  148.                         continue;
  149.                     }
  150.                     $GLOBALS['PCT_THEMEDESIGNER_CONFIG'][$k]['fields'][$kk] = &$GLOBALS['PCT_THEMEDESIGNER_FIELDS'][$kk];
  151.                 }    
  152.             }
  153.         }
  155.         // load custom form templates
  156.         foreach($GLOBALS['PCT_THEMEDESIGNER_CONFIG'] as $arrConfig)
  157.         {
  158.             if(!isset($arrConfig['fields']))
  159.             {
  160.                 continue;
  161.             }
  162.             
  163.             foreach($arrConfig['fields'] as $field)
  164.             {
  165.                 if(strlen($field['template']) > 0)
  166.                 {
  167.                     $path = PCT_THEMER_PATH.'/templates/themedesigner/forms';
  168.                     if(file_exists(TL_ROOT.'/'.$path.'/'.$field['template'].'.html5'))
  169.                     {
  170.                         \Contao\TemplateLoader::addFiles(array($field['template'] => $path));
  171.                     }
  172.                 }
  173.             }
  174.         }
  175.     }
  176.     
  177.     
  178.     /**
  179.      * Observe inputs
  180.      * @param object
  181.      */
  182.     public function formListener($objPage)
  183.     {
  184.         // do a reset 
  185.         if((int)\Contao\Input::get('themedesigner_reset') === 1 && (boolean)\Contao\Config::get('pct_themedesigner_hidden') === false)
  186.         {
  187.             $this->reset();
  188.         }
  189.     }
  192.     /**
  193.      * Return the current theme demo name as string
  194.      * @return string
  195.      */
  196.     public function getTheme()
  197.     {
  198.         if(defined('PCT_THEME'))
  199.         {
  200.             return PCT_THEME;
  201.         }
  202.         
  203.         global $objPage;
  204.         // check if Themer loads a layout
  205.         $objRoot = \Contao\PageModel::findByPk($objPage->rootId);
  206.         return $objRoot->pct_theme ?: 'eclipse_default';
  207.     }
  208.     
  209.     
  210.     /**
  211.      * Set the current data array
  212.      * @param array
  213.      * @param boolean
  214.      */
  215.     public function setData($arrData,$blnForCSS=false)
  216.     {
  217.         if($blnForCSS)
  218.         {
  219.             $this->arrDataCSS = $arrData;
  220.             $this->markAsModified('arrDataCSS');
  221.         }
  222.         else
  223.         {
  224.             $this->arrData = $arrData;
  225.             $this->markAsModified('arrData');
  226.         }
  227.     }
  228.     
  229.     
  230.     /**
  231.      * Mark a variable as being modified
  232.      * @param string 
  233.      */
  234.     public function markAsModified($strKey)
  235.     {
  236.         $this->arrModified[$strKey] = true;
  237.     }
  238.     
  239.     
  240.     /**
  241.      * Check if a variable is modified
  242.      * @param string 
  243.      */
  244.     public function isModified($strKey)
  245.     {
  246.         if(array_key_exists($strKey, $this->arrModified))
  247.         {
  248.             return true;
  249.         }
  250.         return false;
  251.     }
  252.     
  253.     
  254. // !Ajax    
  255.     
  256.     /**
  257.      * Catch ajax requests
  258.      * @param object
  259.      * @param object
  260.      * @param object
  261.      * called from: generatePage Hook
  262.      */
  263.     public function ajaxListener()
  264.     {
  265.         if( !\Contao\Environment::get('isAjaxRequest') )
  266.         {
  267.             return ;
  268.         }
  269.         
  270.         $strAction = '';
  271.         $varValue = null;
  272.         $strField = '';
  273.         
  274.         // POST listener
  275.         if(\Contao\Input::post('themedesigner'))
  276.         {
  277.             $strAction = \Contao\Input::post('action');
  278.             $varValue = \Contao\Input::post('value');
  279.             $strField = \Contao\Input::post('field');
  280.             
  281.             if($strAction == 'upload')
  282.             {
  283.                 $this->addUpload($strField,$_FILES[$strField]);
  284.             }
  285.         }
  286.         
  287.         // GET listener
  288.         else if(\Contao\Input::get('themedesigner'))
  289.         {
  290.             $strAction = \Contao\Input::get('action');
  291.             $varValue = \Contao\Input::get('value');
  292.             $strField = \Contao\Input::get('field');
  293.         }
  294.         
  295.         // store value in the session
  296.         if(strlen($strField) > 0)
  297.         {
  298.             // @var object \Session
  299.             $objSession = \Contao\System::getContainer()->get('session');;
  300.         
  301.             $arrSession = $objSession->get( $this->strSession );
  302.             $arrSession['VALUES'][$strField] = $varValue;
  303.             $objSession->set( $this->strSession,$arrSession );
  304.         }
  305.         
  306.         // multiple fields and values
  307.         if( \Contao\Input::get('fields') && \Contao\Input::get('values') )
  308.         {
  309.             
  310.         }
  311.     }
  312.     
  313.     
  314.     /**
  315.      * Validate a value and return its proper converted value for CSS usage
  316.      * @param string||mixed        The value by the form field
  317.      * @param string            The field name
  318.      * @param array                The field definition
  319.      * @return string            The value proper for CSS usage
  320.      */
  321.     public function validateValueForCSS($varValue, $strField='', $arrField=array())
  322.     {
  323.         // decode any html entities coming from ajax
  324.         $varReturn = html_entity_decode($varValue);
  325.         
  326.         // font family
  327.         if( isset($arrField['config']['isFontPicker']) )
  328.         {
  329.             // font family is set
  330.             $arrFont = $this->getFonts($varValue);
  331.             if( isset($arrFont['family']) )
  332.             {
  333.                 $varReturn = $arrFont['family'];
  334.             }
  335.         }
  337.         return $varReturn;
  338.     }
  341. // !Field and value management    
  342.     
  343.     /**
  344.      * Find a value by a field name
  345.      * @param string
  346.      * @return mixed||null
  347.      */
  348.     public function findValueByField($strSelector, $arrField=array())
  349.     {
  350.         $arrSession = $this->getSession();
  351.         
  352.         // ident for font picker style selection
  353.         $strStyleIdent = $GLOBALS['PCT_THEMEDESIGNER']['fontPickerStyleIdent'] ?: '_style';
  354.         $strWeightIdent = $GLOBALS['PCT_THEMEDESIGNER']['fontPickerWeightIdent'] ?: '_weight';
  355.         
  356.         $blnIsFontStyle = false;
  357.         $blnIsFontWeight = false;
  358.         
  359.         if(strlen(strpos($strSelector, $strStyleIdent)) > 0)
  360.         {
  361.             $blnIsFontStyle = true;
  362.         }
  363.         else if(strlen(strpos($strSelector, $strWeightIdent)) > 0)
  364.         {
  365.             $blnIsFontWeight = true;
  366.         }
  367.         
  368.         $selector = $strSelector;
  369.         if($blnIsFontStyle === true || $blnIsFontWeight === true)
  370.         {
  371.             $tmp = explode('_', $strSelector);
  372.             $selector = $tmp[0];
  373.             unset($tmp);
  374.         }
  375.         
  376.         if(count($arrField) < 1)
  377.         {
  378.             // field definition
  379.             $arrField = $this->getFieldDefinition($selector);
  380.         }
  382.         $varReturn = null;
  383.         // value from ajax
  384.         if(\Contao\Environment::get('isAjaxRequest') && \Contao\Input::get('field') == $strSelector)
  385.         {
  386.             $varReturn = \Contao\Input::get('value');
  387.         }
  388.         // value from session in Frontend
  389.         else if(isset($arrSession['VALUES'][$strSelector]) && TL_MODE == 'FE')
  390.         {
  391.             $varReturn = $arrSession['VALUES'][$strSelector];
  392.         }
  393.         // value from data array
  394.         else if( \array_key_exists($strSelector,$this->arrData) )
  395.         {
  396.             $varReturn = $this->arrData[$strSelector];
  397.         }
  398.         // fallback load default value
  399.         else if(isset($arrField['default']))
  400.         {
  401.             $varReturn = $arrField['default'];
  402.             
  403.             if( ($blnIsFontStyle === true || $blnIsFontWeight === true) && isset($arrField['default_style']) )
  404.             {
  405.                 $tmp = explode(':', $arrField['default_style']);
  406.                 if($blnIsFontStyle)
  407.                 {
  408.                     $varReturn = $tmp[0];
  409.                 }
  410.                 if($blnIsFontWeight)
  411.                 {
  412.                     $varReturn = $tmp[1];
  413.                 }
  414.                 unset($tmp);
  415.             }
  416.         }
  417.         
  418.         return $varReturn;
  419.     }
  420.     
  421.     
  422.     /**
  423.      * Get a field definition and return its array
  424.      * @param string    Field name or selector
  425.      * @param string    The config section 
  426.      * @return array
  427.      */
  428.     public function getFieldDefinition($strField)
  429.     {
  430.         if(strlen($strField) < 1)
  431.         {
  432.             return array();
  433.         }
  434.         
  435.         $arrConfig = $GLOBALS['PCT_THEMEDESIGNER_CONFIG'];
  436.         
  437.         // brute force
  438.         if($GLOBALS['PCT_THEMEDESIGNER']['useFlatSelectors'] === true)
  439.         {
  440.             foreach($arrConfig as $strSection => $arrData)
  441.             {
  442.                 if(!isset($arrData['fields']))
  443.                 {
  444.                     continue;
  445.                 }
  446.                 
  447.                 if(!is_array($arrData['fields']))
  448.                 {
  449.                     continue;
  450.                 }
  451.                 
  452.                 if(!array_key_exists($strField, $arrData['fields']))
  453.                 {
  454.                     continue;
  455.                 }
  456.                 
  457.                 foreach($arrData['fields'] as $name => $arrField)
  458.                 {
  459.                     if($name == $strField)
  460.                     {
  461.                         return $arrField;
  462.                     }
  463.                     else if( isset($arrField['name']) && $arrField['name'] == $strField)
  464.                     {
  465.                         return $arrField;
  466.                     }
  467.                 }
  468.             }
  469.         }
  470.         else
  471.         {
  472.             $tmp = explode('__', $strField);
  473.             if(count($tmp) > 1)
  474.             {
  475.                 $strSection = $tmp[0];
  476.                 $strField = $tmp[1];
  477.             }
  478.             
  479.             return isset($arrConfig[$strSection]['fields'][$strField]) ? $arrConfig[$strSection]['fields'][$strField] : array();
  480.         }
  481.     }
  482.     
  483.     
  484.     /**
  485.      * Find a field definition by a field name
  486.      * @param string
  487.      */
  488.     public static function findByName($strField)
  489.     {
  490.         $_this = new static();
  491.         return $_this->getFieldDefinition($strField);
  492.     }
  495. // !Fonts management
  496.     
  497.     
  498.     /**
  499.      * Return all field definitions by a type
  500.      * @return array
  501.      */
  502.     public static function getFontPickers()
  503.     {
  504.         $arrReturn = array();
  505.         
  506.         foreach($GLOBALS['PCT_THEMEDESIGNER_CONFIG'] as $strSection => $arrData)
  507.         {
  508.             if( empty($arrData['fields']) )
  509.             {
  510.                 continue;
  511.             }
  512.             
  513.             foreach($arrData['fields'] as $strField => $arrField)
  514.             {
  515.                 if($GLOBALS['PCT_THEMEDESIGNER']['useFlatSelectors'] === false)
  516.                 {
  517.                     $strField = $strSection.'__'.$strField;
  518.                 }
  519.                 
  520.                 if(isset($arrField['config']['isFontPicker']))
  521.                 {
  522.                     $arrReturn[$strField] = $arrField;
  523.                 }
  524.             }
  525.         }
  526.         
  527.         return $arrReturn;
  528.     }
  529.     
  530.     
  531.     /**
  532.      * Return a font definition or all fonts as array
  533.      * @param string    Font key
  534.      * @return array
  535.      */
  536.     public static function getFonts($strFont='')
  537.     {
  538.         if(strlen($strFont) < 1)
  539.         {
  540.             return $GLOBALS['PCT_THEMEDESIGNER']['fonts'] ?: array();
  541.         }
  542.         else
  543.         {
  544.             return $GLOBALS['PCT_THEMEDESIGNER']['fonts'][$strFont] ?: array();
  545.         }
  546.     }
  547.     
  548.     
  549. // !CSS    
  550.     
  551.     
  552.     /**
  553.      * Prepare the CSS
  554.      * @param array        The values array
  555.      * @return string    The css 
  556.      */
  557.     public function prepareCSS($arrData)
  558.     {
  559.         // @var object \FontendTemplate
  560.         $objTemplate = new \Contao\FrontendTemplate('stylesheet');
  561.         
  562.         if( \defined('LAYOUT_CSS_IS_ACTIVE') )
  563.         {
  564.             $objTemplate->layout_css_is_active = true;
  565.         }
  566.         
  567.         $objTemplate->PCT_THEME = PCT_THEME;
  568.         foreach($arrData as $key => $value)
  569.         {
  570.             if( empty($value) === true )
  571.             {
  572.                 continue;
  573.             }
  575.             // remove caching helpers
  576.             if( (is_object($value) || is_array($value)) && !empty($value))
  577.             {
  578.                 foreach($value as $k => $v)
  579.                 {
  580.                     // remove caching helpers
  581.                     if(strlen(strpos($v, '?')) > 0)
  582.                     {
  583.                         $tmp = explode('?', $v);
  584.                         if(is_object($value))
  585.                         {
  586.                             $value->{$k} = $tmp[0];
  587.                         }
  588.                         else if(is_array($value))
  589.                         {
  590.                             $value[$k] = $tmp[0];
  591.                         }
  592.                     }
  594.                 }
  595.             }
  596.             else if(strlen(strpos($value, '?')) > 0)
  597.             {
  598.                 $value = rtrim($value,'?');
  599.             }
  600.             
  601.             $objTemplate->{$key} = $value;
  602.         }
  603.         
  604.         // turn debug mode of so contao will not write debug information to the template
  605.         $blnDebug = $GLOBALS['TL_CONFIG']['debugMode'];
  606.         $GLOBALS['TL_CONFIG']['debugMode'] = false;
  607.         
  608.         // parse template and replace Inserttags
  609.         $strReturn = $objTemplate->parse();
  610.         
  611.         // absolute paths should be relative to CSS file
  612.         $preg = preg_match_all('/files(.*?)\)/',$strReturn,$arrPaths);
  613.         if($preg)
  614.         {
  615.             $separator = '/';
  616.             $_arrBase = array_filter(explode($separator, str_replace(basename($GLOBALS['PCT_THEMEDESIGNER_CSS_FILE']),'',$GLOBALS['PCT_THEMEDESIGNER_CSS_FILE']) ));
  617.             
  618.             foreach($arrPaths[0] as $strPath)
  619.             {
  620.                 $strPath = rtrim($strPath,')');
  621.                 
  622.                 $pathinfo = pathinfo( rtrim($strPath,')') );
  623.                 $path = $pathinfo['dirname'];
  624.                 $file = $pathinfo['basename'];
  625.                 
  626.                 $_arrPath = explode($separator,$path);
  627.                 
  628.                 $relative = '';
  629.                 foreach(array_diff($_arrPath,$_arrBase) as $a)
  630.                 {
  631.                     $relative .= '../'.$a;
  632.                 }
  633.                 $relative .= '/'.$file;
  634.                 
  635.                 $strReturn = str_replace($strPath, $relative, $strReturn);
  636.             }
  637.         }
  639.         $strReturn = preg_replace("/^\s*/m", "", $strReturn);
  640.         
  641.         // turn debug mode back on
  642.         $GLOBALS['TL_CONFIG']['debugMode'] = $blnDebug;
  643.         
  644.         return $strReturn;
  645.     }
  646.     
  647.     
  648.     /**
  649.      * Prepare the javascript CSS
  650.      * @param array        The values array
  651.      * @return string    The css 
  652.      */
  653.     public function prepareJavascriptCSS($arrData)
  654.     {
  655.         // @var object \FontendTemplate
  656.         $objTemplate = new \Contao\FrontendTemplate('js_stylesheet');
  657.         $objTemplate->arrCSS = array();
  658.         $objTemplate->arrFields = array();
  659.         
  660.         if( \defined('LAYOUT_CSS_IS_ACTIVE') )
  661.         {
  662.             $objTemplate->layout_css_is_active = true;
  663.         }
  664.         
  665.         // @var object ThemeDesigner
  666.         $objTemplate->ThemeDesigner = new \PCT\ThemeDesigner;
  667.         
  668.         // take the current stylesheet template and observe it
  669.         // @var \File
  670.         $objFile = new \Contao\File( str_replace(TL_ROOT,'',\Contao\TemplateLoader::getPath('stylesheet','html5')), true );
  671.         
  672.         $strContent = $objFile->getContent();
  673.         #$arrContent = $objFile->getContentAsArray();
  674.         
  675.         # remove everything between /* and */
  676.         $strContent = preg_replace("!/\*.*?\*/!ms", "", $strContent);
  677.         
  678.         $strContent = str_replace("\r", '', $strContent);
  679.         
  680.         # remove everything between /* and */
  681.         
  682.         $strJS = $strContent;
  683.         
  684.         // remove php comments
  685.         #$strJS = preg_match("!/<?php*?\>/!ms", "", $strJS);
  686.         
  687.         // capsule if
  688.         #$strJS = str_replace(array('):','endif;'), array(') {','}'),$strJS);
  689.         
  690.         // remove all php calls
  691.         /*
  692.         $strJS = str_replace(array('<?php','endif;','<?=','?>'), '',$strJS);
  693.         */
  694.         
  695.         $inserttag_sign = '#';
  696.         $this_replacer = 'objData';
  697.         
  698.         // replace the php $this
  699.         // capsule field calls in inserttag style
  700.         #$strJS = preg_replace("/this->(.*?);/", str_repeat($inserttag_sign, 3).'$1'.str_repeat($inserttag_sign, 3),$strJS);
  701.         
  702.         #$strJS = str_replace('$'.$inserttag_sign, $inserttag_sign, $strJS);
  703.         
  704.         # remove whitespaces after semicolons
  705.         #$strJS = preg_replace("/;\s+/m", "; ", $strJS);
  706.         
  707.         # remove whitespaces after {
  708.         #$strJS = preg_replace("/{\s+/m", "{ ", $strJS);
  709.         
  710.         # remove whitespace before {
  711.         #$strJS = preg_replace("/\s+{/m", " {", $strJS);
  712.         
  713.         # replace several newlines with one
  714.         #$strJS = preg_replace("/\n{2,}/m", "\n", $strJS);
  715.         
  716.         # Leading whitespace
  717.         $strJS = preg_replace("/^\s*/m", "", $strJS);
  718.         
  719.         // break content into single lines
  720.         $arrLines = array_map('trim',array_filter(preg_split('/$\R?^/m', $strJS),'strlen'));
  721.         
  722.         // remove php document start
  723.         $arrLines[0] = str_replace('<?php','',$arrLines[0]);
  724.         
  725.         $arrValidCssChars = array('.','@','#');
  726.         
  727.         $arrJScontent = array();
  728.         
  729.         $if_open = false;
  730.         $definitions = array();
  731.         foreach($arrLines as $i => $strLine)
  732.         {
  733.             $firstChar = substr($strLine, 0,1);
  734.             
  735.             // if start
  736.             if(strlen(strpos($strLine, '<?php if')) > 0)
  737.             {
  738.                 // start a new defintion collection
  739.                 $definitions = array("css += '");
  740.                 
  741.                 // mark as open if statement
  742.                 $if_open = true;
  743.                 
  744.                 // strip the php call
  745.                 $strLine = trim( str_replace( array('<?php',':','?>'), array('','','{'), $strLine ) );
  746.                 
  747.                 // replace the $this-> call
  748.                 
  749.                 // extract variable
  750.                 #$var = str_replace('$this->','',substr($strLine, strpos($strLine, '(') + 1, strrpos($strLine,')') - strlen($strLine) ) );
  751.                 
  752.                 $strLine = str_replace( array('$this->','->'), array($this_replacer.'.','.'), $strLine);
  753.                 
  754.                 $arrJScontent[$i] = "\n".$strLine;
  755.             }
  756.             
  757.             // endif
  758.             else if(strlen(strpos($strLine, '<?php endif')) > 0)
  759.             {
  760.                 // strip the php call
  761.                 $strLine = trim( str_replace( array('<?php','endif;','?>'), array('','','}'), $strLine ) );
  762.                 
  763.                 // if statement closes
  764.                 $if_open = false;
  765.                 
  766.                 $definition = implode("", $definitions)."';";
  768.                 // insert the definition on a line before
  769.                 $arrJScontent[$i-1] = $definition;
  770.                 
  771.                 $arrJScontent[$i] = $strLine."\n";
  772.             }
  773.             else
  774.             {
  775.                 // strip php calls
  776.                 $strLine = trim( str_replace( array('<?=','?>'), '', $strLine ) );
  777.                 
  778.                 // replace the $this-> call
  779.                 
  780.                 $preg = preg_match_all("/this->(.*?)\;/", $strLine,$arrVars);
  781.                 if($preg)
  782.                 {
  783.                     foreach($arrVars[1] as $i => $var)
  784.                     {
  785.                         $search = $arrVars[0][$i];
  786.                         
  787.                         //remove unwanted chars
  788.                         $var = trim( str_replace(array('(',')'),'',$var) );
  789.                         
  790.                         // split nested vars like $a->b->c
  791.                         $arr = array_filter(explode('->', $var));
  792.                         
  793.                         $tmp = '';
  794.                         $replace = array();
  795.                         foreach($arr as $v)
  796.                         {
  797.                             #$tmp .= '["'.$v.'"]';
  798.                             $tmp .= '.'.$v.'';
  799.                         }
  800.                         $tmp = $this_replacer.$tmp;
  801.                         $strLine = str_replace($search, "'+".trim($tmp)."+'", $strLine);
  802.                         unset($tmp);
  803.                     }
  804.                     
  805.                     $strLine = str_replace(array('$this->','$'), '', $strLine);
  806.                     // replace whitespace before units and end of call
  807.                     $strLine = str_replace(array(' px', ' %'), array('px','%'), $strLine);
  808.                 }
  809.                 
  810.                 // remove double semicolons and space and backslahes like in content: "\abc";
  811.                 $strLine = str_replace(array(';;',' ;','\\'),array(';',';','\\\\'), $strLine);
  812.                 
  813.                 // remove unexpected strings
  814.                 if(strlen(strpos($strLine, "''")) > 0)
  815.                 {
  816.                     $strLine = str_replace("''", '""', $strLine);
  817.                 }
  818.                 
  819.                 if($if_open)
  820.                 {
  821.                     $definitions[] = $strLine . ' ';
  822.                 }
  823.                 // single line style
  824.                 else
  825.                 {
  826.                     $arrJScontent[$i] = "css +='".$strLine."';";
  827.                 }
  828.                 
  829.                 continue;
  830.             }
  831.         }
  832.         
  833.         #array_insert($arrJScontent, 0, array("var css = '';"));
  834.         
  835.         $objTemplate->arrJavascript = $arrJScontent;
  836.         $objTemplate->js = implode("\n", $arrJScontent);
  837.         $objTemplate->baseVariables = 'var css = ""; var objData = {}; var PCT_THEME = "'.PCT_THEME.'"';    
  838.         
  839.         return $objTemplate->parse();
  840.     }
  841.     
  842.     
  843.     /**
  844.      * Get the current data as array
  845.      * @param boolean    For CSS use or raw data use 
  846.      * @return array
  847.      */
  848.     public function getData($blnForCSS=false)
  849.     {
  850.         if($this->isModified('arrData') && !$blnForCSS)
  851.         {
  852.             return $this->arrData;
  853.         }
  854.         
  855.         if($this->isModified('arrDataCSS') && $blnForCSS)
  856.         {
  857.             return $this->arrDataCSS;
  858.         }
  859.         
  860.         // ident for font picker style selection
  861.         $strStyleIdent = $GLOBALS['PCT_THEMEDESIGNER']['fontPickerStyleIdent'] ?: '_style';
  862.         $strWeightIdent = $GLOBALS['PCT_THEMEDESIGNER']['fontPickerWeightIdent'] ?: '_weight';
  863.         
  864.         // get session data
  865.         $arrSession = $this->getSession();
  866.         
  867.         // switches are part of the secion session
  868.         $arrSwitch = $arrSession['SWITCH'] ?? array();
  869.         
  870.         // write sections as template variables
  871.         $arrSections = $this->getMainSections();
  872.         
  873.         $arrReturn = array();
  874.         $arrCounter = array();
  875.         
  876.         foreach($this->arrConfig as $section => $data)
  877.         {
  878.             if(!$GLOBALS['PCT_THEMEDESIGNER']['useFlatSelectors'])
  879.             {
  880.                 $arrReturn[$section] = array();
  881.             }
  882.             
  883.             if(isset($data['fields']) && !empty($data['fields']))
  884.             {
  885.                 foreach($data['fields'] as $name => $arrField)
  886.                 {
  887.                     $selector = $section.'__'.$name;
  888.                     
  889.                     // if TD are unique by their name, use them
  890.                     if((boolean)$GLOBALS['PCT_THEMEDESIGNER']['useFlatSelectors'] === true)
  891.                     {
  892.                         $selector = $name;
  893.                     }
  894.                     
  895.                     if( isset($arrField['name']) )
  896.                     {
  897.                         $selector = $arrField['name'];
  898.                     }
  899.                     
  900.                     $strSwitch = $selector.(!empty($arrCounter['SWITCHES'][$selector]) ? '__'.$arrCounter['SWITCHES'][$selector] : '');
  901.                     
  902.                     if( isset($arrField['switch']) && !empty($arrField['switch']) )
  903.                     {
  904.                         $strSwitch = $arrField['switch'];
  905.                     }
  907.                     if( !isset($arrCounter['SWITCHES'][$selector]) )
  908.                     {
  909.                         $arrCounter['SWITCHES'][$selector] = 0;
  910.                     }
  911.                     
  912.                     $arrCounter['SWITCHES'][$selector]++;
  913.                     
  914.                     if(!isset($arrField['config']['notActiveByDefault']))
  915.                     {
  916.                         $arrField['config']['notActiveByDefault'] = false;
  917.                     }
  919.                     // bypass fields that are supposed to be turned off
  920.                     if( (isset($arrSwitch[$strSwitch]) && (boolean)$arrSwitch[$strSwitch] === false) || (!isset($arrSwitch[$strSwitch]) && (boolean)$arrField['config']['notActiveByDefault'] === true) )
  921.                     {
  922.                         continue;
  923.                     }
  924.                     
  925.                     // find the value
  926.                     $value = $this->findValueByField($selector,$arrField);
  927.                     
  928.                     // upload fields with array values
  929.                     if($arrField['inputType'] == 'upload' && is_array($value))
  930.                     {
  931.                         $objFile = new \Contao\File($value['file'],true);
  932.                         
  933.                         // convert to base64
  934.                         if($objFile->exists())
  935.                         {
  936.                             $value['base64'] = base64_encode( $objFile->getContent() );
  937.                         }
  938.                                                 
  939.                         $tmp = new \StdClass;
  940.                         foreach($value as $k => $v)
  941.                         {
  942.                             $tmp->{$k} = $v;
  943.                         }
  944.                         
  945.                         // set template var
  946.                         if(!$GLOBALS['PCT_THEMEDESIGNER']['useFlatSelectors'])
  947.                         {
  948.                             $arrReturn[$section][$selector] = $tmp;
  949.                         }
  950.                         else
  951.                         {
  952.                             $arrReturn[$selector] = $tmp;
  953.                         }
  954.                         
  955.                         unset($tmp);
  956.                         
  957.                         continue;
  958.                     }
  959.                     
  960.                     if(!isset($arrField['eval']['doNotValidateValue']) && $blnForCSS)
  961.                     {    
  962.                         // validate value
  963.                         $value = $this->validateValueForCSS($value, $selector, $arrField);
  964.                         
  965.                     }
  966.                     
  967.                     // skip empty values
  968.                     if(empty($value))
  969.                     {
  970.                         continue;
  971.                     }
  972.                     
  973.                     $objJson = json_decode($value);
  974.                     if(is_object($objJson))
  975.                     {
  976.                         $value = $objJson;
  977.                     }
  978.                     
  979.                     // set template var for font picker styles
  980.                     if( isset($arrField['config']['isFontPicker']) )
  981.                     {
  982.                         $arrReturn[$selector.$strStyleIdent] = $this->findValueByField($selector.$strStyleIdent);
  983.                         $arrReturn[$selector.$strWeightIdent] = $this->findValueByField($selector.$strWeightIdent);
  984.                     }
  985.                     
  986.                     // set template var
  987.                     if(!$GLOBALS['PCT_THEMEDESIGNER']['useFlatSelectors'])
  988.                     {
  989.                         $arrReturn[$section][$selector] = $value;
  990.                     }
  991.                     else
  992.                     {
  993.                         $arrReturn[$selector] = $value;
  994.                     }
  995.                 }
  996.             }
  997.         }
  998.         
  999.         $arrReturn['PCT_THEME'] = PCT_THEME;
  1000.         
  1001.         // set data
  1002.         $this->setData($arrReturn,$blnForCSS);
  1003.         
  1004.         return $arrReturn;
  1005.     }
  1006.     
  1007.     
  1008.     /**
  1009.      * Get the current data arrays formatted for CSS usage
  1010.      * @return array
  1011.      */
  1012.     public function getDataForCSS()
  1013.     {
  1014.         return $this->getData(true);
  1015.     }
  1018. // ! Frontend
  1020.     
  1021.     /**
  1022.      * Set the page layout
  1023.      * @param object
  1024.      * @param object
  1025.      * called from : getPageLayout Hook
  1026.      */
  1027.     public function setLayoutTemplate($objPage, $objLayout)
  1028.     {
  1029.         $objRoot = \Contao\PageModel::findByPk($objPage->rootId);
  1030.         
  1031.         // Render maintenance page if no backend user is logged in
  1032.         if( \version_compare(VERSION,'4.13','>=') && $objRoot->maintenanceMode )
  1033.         {
  1034.             $objTemplate = new \Contao\FrontendTemplate('fe_page');
  1035.             if( $objTemplate->hasAuthenticatedBackendUser() === false )
  1036.             {
  1037.                 return;
  1038.             }    
  1039.         }
  1041.         // Page is excluded by id or theme
  1042.         if(is_array($GLOBALS['PCT_THEMEDESIGNER']['excludes']))
  1043.         {
  1044.             if(in_array($objPage->id, $GLOBALS['PCT_THEMEDESIGNER']['excludes']) || in_array($objRoot->pct_theme, $GLOBALS['PCT_THEMEDESIGNER']['excludes']))
  1045.             {
  1046.                 return;
  1047.             }
  1048.         }
  1049.         
  1050.         $arrSession = $this->getSession();
  1051.         
  1052.         $strIframeUrl = $arrSession['IFRAME_URL'] ?? '';
  1053.         $strSessionKey = $this->strSession.'_'.$this->getTheme();
  1054.         
  1055.         $tmp = explode('?', $strIframeUrl);
  1056.         $strIframeUrl = $tmp[0];
  1057.                 
  1058.         // redirect the whole TD page when the iframe page is a root page or has a whole new root page
  1059.         if($strIframeUrl != '' && $strIframeUrl != \Contao\Environment::get('request'))
  1060.         {
  1061.             $objPages = \Contao\PageModel::findByAliases(array(str_replace(array('index.php/','.html'),'',$strIframeUrl)));
  1062.             if($objPages !== null && isset($objPages[0]) )
  1063.             {
  1064.                 $objIframePage = $objPages[0];
  1065.                 if( $objIframePage->type == 'root' || $objIframePage->rootId != $objPage->rootId)
  1066.                 {
  1067.                     unset($arrSession['IFRAME_URL']);
  1068.                     unset($_SESSION[$strSessionKey]['IFRAME_URL']);
  1069.                     $this->setSession($arrSession);
  1070.                     \Contao\Controller::redirect( $objIframePage->getFrontendUrl() );    
  1071.                 }
  1072.             }
  1073.             else
  1074.             {
  1075.                 unset($arrSession['IFRAME_URL']);
  1076.                 unset($_SESSION[$strSessionKey]['IFRAME_URL']);
  1077.                 $this->setSession($arrSession);
  1078.                 \Contao\Controller::reload();    
  1079.             }
  1080.         }
  1081.         
  1082.         // already on the same page and its not a root page
  1083.         if($strIframeUrl != '' && $strIframeUrl == \Contao\Environment::get('request'))
  1084.         {
  1085.             unset($arrSession['IFRAME_URL']);
  1086.             unset($_SESSION[$strSessionKey]['IFRAME_URL']);
  1087.             $this->setSession($arrSession);
  1088.             \Contao\Controller::reload();    
  1089.         }
  1090.         
  1091.         if((boolean)\Contao\Input::get('themedesigner_iframe') === true || (boolean)$GLOBALS['PCT_THEMEDESIGNER']['useIframe'] === false)
  1092.         {
  1093.             $objJsTemplate = new \Contao\FrontendTemplate('js_themedesigner_iframe_helper');
  1094.             $objJsTemplate->themedesigner_ident = $arrSession['IDENT'];
  1095.             $objJsTemplate->reset = \Contao\Input::get('themedesigner_reset');
  1096.             $objJsTemplate->cookie = 'THEMEDESIGNER_IFRAME_'.$this->getTheme();
  1097.             $objJsTemplate->theme = $this->getTheme();
  1098.             $GLOBALS['TL_JQUERY'][] = $objJsTemplate->parse();
  1099.             return;
  1100.         }
  1101.         
  1102.         $objLayout->template = 'fe_page_themedesigner';
  1103.     }
  1104.     
  1105.     
  1106.     /**
  1107.      * Add the Google fonts to the page layout
  1108.      * @param object
  1109.      * @param object
  1110.      * called from : getPageLayout Hook
  1111.      */
  1112.     public function addFonts($objPage, $objLayout)
  1113.     {
  1114.         //-- avoid loading fonts
  1115.         if((boolean)\Contao\Config::get('pct_themedesigner_nofonts') === true)
  1116.         {
  1117.             $objLayout->webfonts = '';
  1118.             return;
  1119.         }
  1120.         //--
  1121.         
  1122.         $objTD = new \PCT\ThemeDesigner;
  1123.         
  1124.         // @var object
  1125.         $objRoot = \Contao\PageModel::findByPk($objPage->rootId);
  1126.         
  1127.         // @var object
  1128.         $objActiveVersion = \PCT\ThemeDesigner\Model::findActiveByTheme($objRoot->pct_theme ?: 'eclipse_default');
  1129.     
  1130.         // get current TD data
  1131.         $arrData = $objTD->getData();
  1132.         
  1133.         // load last active version
  1134.         if($objActiveVersion !== null && (boolean)\Contao\Config::get('pct_themedesigner_hidden') === true)
  1135.         {
  1136.             $arrData = StringUtil::deserialize($objActiveVersion->data) ?: array();
  1137.             if( !empty($arrData['VALUES']) && is_array($arrData['VALUES']))
  1138.             {
  1139.                 $arrData = $arrData['VALUES'];
  1140.             }
  1141.         }
  1142.         
  1143.         // get all font pickers
  1144.         $arrFontPickers = $objTD->getFontPickers();
  1145.         
  1146.         // check if any font is selected
  1147.         $arrMatch = array_intersect(array_keys($arrData ?: array()), array_keys($arrFontPickers ?: array()));
  1148.         
  1149.         // no fonts selected by user but the layout comes with fontpicker information
  1150.         if(count($arrMatch) < 1 && count($arrFontPickers) > 0)
  1151.         {
  1152.             $arrMatch = array_keys($arrFontPickers);
  1153.             foreach($arrFontPickers as $font => $data)
  1154.             {
  1155.                 $font = $data['default'];
  1156.                 if( !isset($data['default_style']) )
  1157.                 {
  1158.                     $data['default_style'] = '';
  1159.                 }
  1161.                 $arrData[$font] = array
  1162.                 (
  1163.                     'label' => $data['label'],
  1164.                     'styles' => array($data['default_style']),
  1165.                     'default' => $data['default'],
  1166.                 );
  1167.             }
  1168.         }
  1169.         else if(count($arrMatch) < 1 && count($arrFontPickers) < 1)
  1170.         {
  1171.             return;
  1172.         }
  1173.         
  1174.         $arrFonts = array();
  1175.         foreach($arrMatch as $field)
  1176.         {
  1177.             if(is_array($field))
  1178.             {
  1179.                 continue;
  1180.             }
  1181.             
  1182.             if(!isset($arrData[$field]))
  1183.             {
  1184.                 continue;
  1185.             }
  1186.             
  1187.             $font = $arrData[$field];
  1188.             $weights = array();
  1189.             
  1190.             // font definition
  1191.             $arrFont = $objTD->getFonts( $font );
  1192.             if(empty($arrFont))
  1193.             {
  1194.                 continue;
  1195.             }
  1196.             
  1197.             // default weight
  1198.             if($arrFont['default'] && strlen(strpos($arrFont['default'], ':')) > 0)
  1199.             {
  1200.                 $s = explode(':', $arrFont['default']);
  1201.                 $weights[] = $s[1];
  1202.             }
  1203.             
  1204.             // style weights
  1205.             if(!empty($arrFont['styles']))
  1206.             {
  1207.                 foreach($arrFont['styles'] as $style)
  1208.                 {
  1209.                     $s = explode(':', $style);
  1210.                     if($s[1])
  1211.                     {
  1212.                         $weights[] = $s[1];
  1213.                     }
  1214.                 }
  1215.             }
  1216.             
  1217.             $arrFonts[] = $font.(count($weights) > 0 ? ':'.implode(',', array_unique($weights)) : '');
  1218.         }
  1219.         
  1220.         $arrFonts = array_unique($arrFonts);
  1221.         if(count($arrFonts) < 1)
  1222.         {
  1223.             return;
  1224.         }
  1226.         $arrFonts = array_filter( array_unique( array_merge($arrFonts, explode('|', $objLayout->webfonts) ) ) );
  1227.         
  1228.         $objLayout->webfonts = implode('|', $arrFonts);
  1229.     }
  1230.     
  1231.     
  1232.     /**
  1233.      * Add user privacy sensitive javascript to load webfonts depending on user privacy selection
  1234.      * @param object
  1235.      * @param object
  1236.      * @param object
  1237.      * called from getPageLayout Hook
  1238.      */
  1239.     public function addFontsOptin($objPage, $objLayout, $objPageRegular)
  1240.     {
  1241.         // include fonts in themedesigner iframe
  1242.         if( (int)\Contao\Input::get('themedesigner_iframe') == 1 && isset($objLayout->webfonts) && !empty($objLayout->webfonts) )
  1243.         {
  1244.             $GLOBALS['TL_HEAD'][] = '<link href="https://fonts.googleapis.com/css?family='.$objLayout->webfonts.'" rel="stylesheet">';
  1245.             return;
  1246.         }
  1247.         
  1248.         //-- avoid loading fonts
  1249.         if((boolean)\Contao\Config::get('pct_themedesigner_nofonts') === true)
  1250.         {
  1251.             $objLayout->webfonts = '';
  1252.             return;
  1253.         }
  1254.         //--
  1255.         
  1256.         // Skip optin when TD is in development mode | not in live mode
  1257.         if( (boolean)\Contao\Config::get('pct_themedesigner_hidden') === false )
  1258.         {
  1259.             return;
  1260.         }
  1261.         
  1262.         if(empty($objLayout->webfonts))
  1263.         {
  1264.             return;
  1265.         }
  1266.         
  1267.         $strWebfonts = $objLayout->webfonts;
  1268.         // clear the regular webfonts to avoid loading by Contao
  1269.         $objLayout->webfonts = '';
  1270.         
  1271.         // @var object
  1272.         $objTemplate = new \Contao\FrontendTemplate('js_themedesigner_webfonts_optin');
  1273.         $objTemplate->webfonts = $strWebfonts;
  1274.         $objTemplate->privacy_session_name = $GLOBALS['PCT_THEMEDESIGNER']['privacy_session_name'] ?: ''; 
  1275.         $strBuffer = $objTemplate->parse();
  1276.         // add to page head
  1277.         $GLOBALS['TL_HEAD'][] = $strBuffer;
  1278.         
  1279.         // add to option vairable
  1280.     #    $objPageRegular->Template->webfonts_optin = $strBuffer;
  1281.     }
  1282.         
  1283.     
  1284.     /**
  1285.      * Add theme designer to the page template
  1286.      * @param object
  1287.      * @param object
  1288.      * @param object
  1289.      * called from: parseTemplate Hook
  1290.      */
  1291.     public function addToTemplate($objTemplate)
  1292.     {    
  1293.         // ThemeDesigner is turned off
  1294.         if(\Contao\Config::get('pct_themedesigner_hidden') && \Contao\Config::get('pct_themedesigner_off'))
  1295.         {
  1296.             return;
  1297.         }
  1298.         
  1299.         // work on fe_page templates only
  1300.         if ( \strpos($objTemplate->getName(), 'fe_page') === false ) 
  1301.         {
  1302.             return;
  1303.         }
  1305.         global $objPage;
  1307.         // check if Themer loads a layout
  1308.         $objRoot = \Contao\PageModel::findByPk($objPage->rootId);
  1309.         // define constants
  1310.         if(strlen($objRoot->pct_theme) > 0)
  1311.         {
  1312.             if( \defined('LAYOUT_CSS_IS_ACTIVE') === false )
  1313.             {
  1314.                 \define('LAYOUT_CSS_IS_ACTIVE',1);
  1315.             }
  1316.             $strTheme = $objRoot->pct_theme;
  1317.         }
  1318.         else
  1319.         {
  1320.             $strTheme = 'eclipse_default';
  1321.         }
  1322.         
  1323.         // Page is excluded by id or theme
  1324.         if(is_array($GLOBALS['PCT_THEMEDESIGNER']['excludes']))
  1325.         {
  1326.             if(in_array($objPage->id, $GLOBALS['PCT_THEMEDESIGNER']['excludes']) || in_array($strTheme, $GLOBALS['PCT_THEMEDESIGNER']['excludes']))
  1327.             {
  1328.                 return;
  1329.             }
  1330.         }
  1331.         
  1332.         // load config
  1333.         $this->loadConfig($objPage);
  1334.         
  1335.         // load an active version
  1336.         // @var object 
  1337.         $objActiveVersion = \PCT\ThemeDesigner\Model::findActiveByTheme($strTheme);
  1338.         
  1339.         // regular fe_page template is being rendered
  1340.         if ( $objTemplate->getName() !== 'fe_page_themedesigner' ) 
  1341.         {
  1342.             $objTemplate->pct_layout_css = '';
  1343.             
  1344.             $strVersion = '';
  1345.             if( $objActiveVersion !== null )
  1346.             {
  1347.                 $strVersion = sprintf($GLOBALS['PCT_THEMEDESIGNER_CSS_FILENAME'],$objActiveVersion->id,$objActiveVersion->tstamp);
  1348.             }
  1349.             // layout.css by the theme designer is final
  1350.             $strLayoutCss = sprintf($GLOBALS['PCT_THEMEDESIGNER_CSS_FILE'],$strVersion);
  1351.             if(\Contao\Config::get('pct_themedesigner_hidden') && \file_exists(TL_ROOT.'/'.$strLayoutCss))
  1352.             {
  1353.                 $strFile = \trim($strLayoutCss);
  1354.                 $objTemplate->pct_layout_css = $strFile;
  1355.                 $objTemplate->pct_layout_css_uncached = $strFile.'?'.time();    
  1356.             }
  1358.             return;
  1359.         }
  1361.         // Render maintenance page if no backend user is logged in
  1362.         if( \version_compare(VERSION,'4.13','>=') && $objRoot->maintenanceMode && $objTemplate->hasAuthenticatedBackendUser() === false )
  1363.         {
  1364.             return;
  1365.         }
  1367.         // --- THEME DESIGNER 
  1369.         // get session
  1370.         $arrSession = $this->getSession();
  1372.         // mobile
  1373.         if( isset($arrSession['MOBILE']) && (boolean)$arrSession['MOBILE'])
  1374.         {
  1375.             $objTemplate->isMobileView = true;
  1376.         }
  1378.         // zoom
  1379.         if( isset($arrSession['ZOOM']) && !empty($arrSession['ZOOM']) )
  1380.         {
  1381.             $objTemplate->zoom = $arrSession['ZOOM'];
  1382.         }
  1384.         // device
  1385.         if( isset($arrSession['DEVICE']) && !empty($arrSession['DEVICE']) )
  1386.         {
  1387.             $objTemplate->device = $arrSession['DEVICE'];
  1388.         }
  1390.         // ThemeDesigner is hidden
  1391.         if(\Contao\Config::get('pct_themedesigner_hidden') || \Contao\Environment::get('isAjaxRequest') || \Contao\Input::get('themedesigner_iframe'))
  1392.         {
  1393.             return;
  1394.         }
  1395.                             
  1396.         // --- Frontend output from here
  1397.         // if session is empty and an active version exists, fill up the session and reload the page
  1398.         if($objActiveVersion !== null && !isset($arrSession['VALUES']))
  1399.         {
  1400.             $arrSession = StringUtil::deserialize($objActiveVersion->data) ?: array();
  1401.             if( !isset($arrSession['VALUES']) )
  1402.             {
  1403.                 $arrSession['VALUES'] = array();
  1404.             }
  1405.             
  1406.             // avoid applying an empty data array
  1407.             if(count($arrSession) > 0)
  1408.             {
  1409.                 $this->setSession( $arrSession );
  1410.                 \Contao\Controller::reload();
  1411.             }
  1412.         }
  1413.         
  1414.         // load language file
  1415.         \Contao\System::loadLanguageFile('themedesigner');
  1416.         
  1417.         // @var object \PCT\ThemeDesigner\Navigation
  1418.         $objNavi = new \PCT\ThemeDesigner\Navigation;
  1419.         $strNavi = $objNavi->render( $this->strNavTemplate );
  1420.         
  1421.         // add to page template
  1422.         $objTemplate->pct_themedesigner_navigation = $strNavi;
  1423.         
  1424.         // @var object \PCT\ThemeDesigner\Versions
  1425.         $objVersions = new \PCT\ThemeDesigner\Versions;
  1426.         $strVersions = $objVersions->render();
  1427.         
  1428.         // add to page template
  1429.         $objTemplate->pct_themedesigner_versions = $strVersions;
  1430.         
  1431.         // @var object \PCT\ThemeDesigner
  1432.         $objTD = new \PCT\ThemeDesigner;
  1433.         $strTD = $objTD->render( $this->strTemplate );
  1434.         
  1435.         // add to page template
  1436.         $objTemplate->pct_themedesigner = $strTD;
  1437.     
  1438.         // minify button toggler
  1439.         $objTemplate->pct_themedesigner_toggler = '<a id="themedesigner_toggler" title="'.$GLOBALS['TL_LANG']['pct_themedesigner']['toggler_title'].'" class="'.($arrSession['MINIFIED'] ? 'active' : '').'" data-state="'.(!$arrSession['MINIFIED'] ? 1 : 0).'" class="themedesigner_minify"></a>';
  1440.         
  1441.         // reset button
  1442.         $objTemplate->pct_themedesigner_reset = '<a id="themedesigner_reset" title="'.$GLOBALS['TL_LANG']['pct_themedesigner']['reset_title'].'" class="themedesigner_reset_button" href="'.$objPage->getFrontendUrl().'?themedesigner_reset=1'.'" title="ThemeDesigner reset"></a>';
  1443.         
  1444.         // mobile button
  1445.         $objTemplate->pct_themedesigner_mobile = '<a id="themedesigner_mobile" title="'.$GLOBALS['TL_LANG']['pct_themedesigner']['mobile_title'].'" class="themedesigner_mobile_button"></a>';
  1446.         
  1447.         // quick info
  1448.         $objQuickinfo = new \PCT\ThemeDesigner\Quickinfo;
  1449.         $strQuickinfo = $objQuickinfo->render();
  1450.         
  1451.         $objTemplate->pct_themedesigner_quickinfo = $strQuickinfo;
  1452.         
  1453.         // no save info
  1454.         $objVersions = \PCT\ThemeDesigner\Model::findByTheme(PCT_THEME);
  1455.         if($objVersions === null)
  1456.         {
  1457.             $objTemplate->pct_themedesigner_nosave = $GLOBALS['TL_LANG']['pct_themedesigner']['nosave_info'] ?: 'No save data yet';
  1458.         }    
  1459.     }
  1462.     /**
  1463.      * Add theme designer to the page layout and include scripts via GLOBALS
  1464.      * @param object
  1465.      * @param object
  1466.      * called from: getPageLayout Hook
  1467.      */
  1468.     public function addToLayout($objPage, $objLayout)
  1469.     {    
  1470.         // ThemeDesigner is turned off
  1471.         if(\Contao\Config::get('pct_themedesigner_hidden') && \Contao\Config::get('pct_themedesigner_off'))
  1472.         {
  1473.             return;
  1474.         }
  1475.         
  1476.         // load config
  1477.         $this->loadConfig($objPage);
  1478.         
  1479.         // check if Themer loads a layout
  1480.         $objRoot = \Contao\PageModel::findByPk($objPage->rootId);
  1481.         // define constants
  1482.         if(strlen($objRoot->pct_theme) > 0)
  1483.         {
  1484.             \define('LAYOUT_CSS_IS_ACTIVE',1);
  1485.             $strTheme = $objRoot->pct_theme;
  1486.         }
  1487.         else
  1488.         {
  1489.             $strTheme = 'eclipse_default';
  1490.         }
  1492.         // Page is excluded by id or theme
  1493.         if(is_array($GLOBALS['PCT_THEMEDESIGNER']['excludes']))
  1494.         {
  1495.             if(in_array($objPage->id, $GLOBALS['PCT_THEMEDESIGNER']['excludes']) || in_array($strTheme, $GLOBALS['PCT_THEMEDESIGNER']['excludes']))
  1496.             {
  1497.                 return;
  1498.             }
  1499.         }
  1501.         // @var object
  1502.         $objActiveVersion = \PCT\ThemeDesigner\Model::findActiveByTheme($strTheme);
  1503.         $strVersion = '';
  1504.         if( $objActiveVersion !== null )
  1505.         {
  1506.             $strVersion = sprintf($GLOBALS['PCT_THEMEDESIGNER_CSS_FILENAME'],$objActiveVersion->id,$objActiveVersion->tstamp);
  1507.         }
  1508.         // layout.css by the theme designer is final
  1509.         $strLayoutCss = sprintf($GLOBALS['PCT_THEMEDESIGNER_CSS_FILE'],$strVersion);
  1510.         $strFile = '';
  1511.         if(\Contao\Config::get('pct_themedesigner_hidden') && \file_exists(TL_ROOT.'/'.$strLayoutCss))
  1512.         {
  1513.             $strFile = trim($strLayoutCss);
  1514.             return;
  1515.         }
  1516.         
  1517.         // get session
  1518.         $arrSession = $this->getSession();
  1519.         
  1520.         // add body classes
  1521.         $arrClasses = array('themedesigner_active');
  1522.         if(\Contao\Config::get('pct_themedesigner_hidden'))
  1523.         {
  1524.             $arrClasses[] = 'themedesigner_hidden';
  1525.         }
  1526.         
  1527.         // minified
  1528.         if(isset($arrSession['MINIFIED']) && (boolean)$arrSession['MINIFIED'] )
  1529.         {
  1530.             $arrClasses[] = 'themedesigner_minified';
  1531.         }
  1532.         
  1533.         // mobile
  1534.         if(isset($arrSession['MOBILE']) && (boolean)$arrSession['MOBILE'] )
  1535.         {
  1536.             $arrClasses[] = 'themedesigner_mobile';
  1537.             
  1538.             if(\Contao\Input::get('themedesigner_iframe'))
  1539.             {
  1540.                 $arrClasses[] = 'mobile';
  1541.             }
  1542.         }
  1544.         // zoom
  1545.         $intZoom = $arrSession['ZOOM'] ?? 100;
  1546.         if($intZoom > 0)
  1547.         {
  1548.             $arrClasses[] = 'zoom_'.$intZoom;
  1549.             
  1550.             if(\Contao\Input::get('themedesigner_iframe'))
  1551.             {
  1552.                 $arrClasses[] = 'zoom_'.$intZoom;
  1553.             }
  1554.         }
  1556.         // device
  1557.         $strDevice = $arrSession['DEVICE'] ?? 'desktop';
  1558.         if($strDevice)
  1559.         {
  1560.             $arrClasses[] = 'themedesigner_'.$strDevice;
  1561.             
  1562.             if(\Contao\Input::get('themedesigner_iframe'))
  1563.             {
  1564.                 $arrClasses[] = $strDevice.' themedesigner_'.$strDevice;
  1565.             }
  1566.         }
  1568.         // add themedesigner classes to body 
  1569.         if( (boolean)\Contao\Config::get('pct_themedesigner_hidden') === false )
  1570.         {
  1571.             $objLayout->cssClass .= ' '.\implode(' ',$arrClasses);
  1572.         }
  1573.         
  1574.         // include Javascript CSS only when TD is not hidden and active or no active version exists
  1575.         if((boolean)\Contao\Config::get('pct_themedesigner_hidden') === false || $objActiveVersion === null)
  1576.         {
  1577.             $arrData = $this->getData();
  1578.             
  1579.             // load data from last active session
  1580.             if($objActiveVersion !== null && (empty($arrData) || empty($arrSession)))
  1581.             {
  1582.                 $arrData = StringUtil::deserialize($objActiveVersion->data) ?: array();
  1583.                 $this->setData($arrData);
  1584.             }
  1585.             
  1586.             // prepare the css for javascript usage
  1587.             $strCSSforJS = $this->prepareJavascriptCSS($arrData);
  1588.             
  1589.             // include the Javascript CSS
  1590.             $GLOBALS['TL_JQUERY'][] = $strCSSforJS;
  1591.         }
  1592.         
  1593.         // ThemeDesigner is hidden
  1594.         if(\Contao\Config::get('pct_themedesigner_hidden') || \Contao\Environment::get('isAjaxRequest') || \Contao\Input::get('themedesigner_iframe'))
  1595.         {
  1596.             return;
  1597.         }
  1598.                         
  1599.         // if session is empty and an active version exists, fill up the session and reload the page
  1600.         if($objActiveVersion !== null && empty($arrSession))
  1601.         {
  1602.             $arrSession = StringUtil::deserialize($objActiveVersion->data) ?: array();
  1603.             
  1604.             // avoid applying an empty data array
  1605.             if(count($arrSession) > 0)
  1606.             {
  1607.                 $this->setSession( $arrSession );
  1608.                 \Contao\Controller::reload();
  1609.             }
  1610.         }
  1611.         
  1612.         // load language file
  1613.         \Contao\System::loadLanguageFile('themedesigner');
  1614.         
  1615.         // load ThemeDesigner js class
  1616.         $objJsTemplate = new \Contao\FrontendTemplate( $this->strJsTemplate );
  1617.         $objJsTemplate->whoAmI = $this->strJsTemplate;
  1618.         $objJsTemplate->stylesheet = $strFile;
  1619.         $objJsTemplate->timestamp = time();
  1620.         $objJsTemplate->theme = $strTheme;
  1621.         $objJsTemplate->device = $strDevice;
  1622.         $objJsTemplate->zoom = $intZoom;
  1624.         // load themedesigner script
  1625.         $GLOBALS['TL_JQUERY'][] = $objJsTemplate->parse();
  1626.         
  1627.         // load styling
  1628.         $GLOBALS['TL_CSS'][] = $GLOBALS['PCT_THEMEDESIGNER']['CSS'];
  1629.         
  1630.         // no save info
  1631.         $objVersions = \PCT\ThemeDesigner\Model::findByTheme(PCT_THEME);
  1632.         if($objVersions === null)
  1633.         {
  1634.             // add body class
  1635.             $objLayout->cssClass .= ' themedesigner_unsaved';
  1636.         }
  1637.     }
  1640. //! File management, stylesheet creation
  1641.     
  1642.     
  1643.     /**
  1644.      * Create the stylesheet from the current data and return its path
  1645.      * @param string    The current theme name
  1646.      * return string
  1647.      */
  1648.     public function createStylesheet($strTheme='')
  1649.     {
  1650.         // prepare the css
  1651.         $strCSS = $this->prepareCSS( $this->getData(true) );
  1652.         
  1653.         // write the css file and set as new layout.css
  1654.         $objFile = $this->writeCSS($strCSS,$strTheme);
  1655.         
  1656.         $strFile = '';
  1657.         
  1658.         $time = time();
  1659.         if($objFile->exists())
  1660.         {
  1661.             $strFile = trim($objFile->path);
  1662.             // append timestamp to trick server caches
  1663.             if($GLOBALS['PCT_THEMEDESIGNER']['bypassServerCache'])
  1664.             {
  1665.                 $strFile .= '?'.$time;
  1666.             }
  1667.         }
  1668.         
  1669.         return $strFile;
  1670.     }
  1671.     
  1672.         
  1673.     /**
  1674.      * Public access to writeFile() method
  1675.      * @param string
  1676.      * @return object
  1677.      */
  1678.     public function writeCSS($strCSS,$strTheme='')
  1679.     {
  1680.         return $this->writeFile(sprintf($GLOBALS['PCT_THEMEDESIGNER_CSS_FILE'],$strTheme),$strCSS);
  1681.     }
  1683.     
  1684.     /**
  1685.      * Write the css file and return its path and file name
  1686.      * @param string    Path
  1687.      * @param string    Content
  1688.      * @return object
  1689.      */
  1690.     protected function writeFile($strFile,$strContent)
  1691.     {
  1692.         if(strlen($strFile) < 1)
  1693.         {
  1694.             $strFile = sprintf($GLOBALS['PCT_THEMEDESIGNER_CSS_FILE'],'');
  1695.         }
  1696.         
  1697.         $objFile = new \Contao\File($strFile);
  1698.         $strContent = str_replace( array("\t","\r"), "", $strContent);
  1699.         $strContent = preg_replace(array('/^[\t ]+/m', '/[\t ]+$/m', '/\n\n+/'), array('', '', "\n"), $strContent);
  1700.         
  1701.         if(\Contao\Config::get('gzipScripts'))
  1702.         {
  1703.             $objMinify = new \MatthiasMullie\Minify\CSS();
  1704.             $objMinify->add($strContent);
  1705.             $strContent = $objMinify->minify();
  1706.         }
  1707.         
  1708.         if( !$objFile->exists() )
  1709.         {
  1710.             \Contao\File::putContent($strFile,$strContent);
  1711.         }
  1712.         else
  1713.         {
  1714.             $objFile->write($strContent);
  1715.         }
  1716.         
  1717.         return $objFile;
  1718.     }
  1719.     
  1720. // TODO: !render
  1721.     
  1722.     /**
  1723.      * Render the ThemeDesigner and return it as html string
  1724.      * @return string
  1725.      */
  1726.     public function render($strTemplate='themedesigner')
  1727.     {
  1728.         $objTemplate = new \Contao\FrontendTemplate($strTemplate);
  1729.         $objTemplate->type = 'themedesigner';
  1730.         
  1731.         $arrSession = $this->getSession();
  1732.         $strContent = '';
  1733.         
  1734.         // devices
  1735.         $objDevicesAndZoom = new \Contao\FrontendTemplate('td_devices_and_zoom');
  1736.         $objDevicesAndZoom->device = $arrSession['DEVICE'] ?? 'desktop';
  1737.         $objDevicesAndZoom->zoom = $arrSession['ZOOM'] ?? 100;
  1738.         // render devices and zoom
  1739.         $strContent .= $objDevicesAndZoom->parse();
  1741.         // get the main sections
  1742.         $arrSections = $this->getSections();
  1743.         if(count($arrSections) < 1)
  1744.         {
  1745.             $objTemplate->empty = true;
  1746.             return $objTemplate->parse();
  1747.         }
  1748.         
  1749.         $objTemplate->sections = $arrSections;    
  1750.         
  1751.         // prepare section
  1752.         $arrItems = array();
  1753.         
  1754.         foreach($arrSections as $section)
  1755.         {
  1756.             $objSection = new \PCT\ThemeDesigner\Section($section);
  1757.             if($objSection === null)
  1758.             {
  1759.                 continue;
  1760.             }
  1761.             
  1762.             $strSection = $objSection->render();
  1763.             if(empty($strSection))
  1764.             {
  1765.                 continue;
  1766.             }
  1767.             
  1768.             $strContent .= $strSection;
  1769.             
  1770.             $class = array($section);
  1771.             
  1772.             $arrItems[] = array
  1773.             (
  1774.                 'section'     => $section,
  1775.                 'html'        => $strSection,
  1776.                 'class'        => implode(' ', $class),
  1777.             );
  1778.         }
  1779.         
  1780.         if(!empty($arrItems))
  1781.         {
  1782.             $last = count($arrItems) - 1;
  1783.             
  1784.             $arrItems[0]['class'] = trim($arrItems[0]['class']) . ' first';
  1785.             $arrItems[$last]['class'] = trim($arrItems[$last]['class']) . ' last';
  1786.         }
  1787.         
  1788.         $objTemplate->items = $arrItems;
  1789.         $objTemplate->content = $strContent;
  1790.         
  1791.         return $objTemplate->parse();
  1792.     }
  1793.     
  1794.     
  1795.     /**
  1796.      * Return the main section names as array
  1797.      * @return array
  1798.      */
  1799.     public static function getMainSections()
  1800.     {
  1801.         if(!is_array($GLOBALS['PCT_THEMEDESIGNER_CONFIG']) || empty($GLOBALS['PCT_THEMEDESIGNER_CONFIG']))
  1802.         {
  1803.             return array();
  1804.         }
  1805.         
  1806.         $arrChilds = array();
  1807.         
  1808.         // find child sections
  1809.         foreach($GLOBALS['PCT_THEMEDESIGNER_CONFIG'] as $config)
  1810.         {
  1811.             if( !empty($config['csection']) )
  1812.             {
  1813.                 $arrChilds = array_merge($arrChilds, array_filter($config['csection']) );
  1814.             }
  1815.         }
  1816.         
  1817.         return array_diff( array_keys($GLOBALS['PCT_THEMEDESIGNER_CONFIG']),$arrChilds );
  1818.     }
  1819.     
  1820.     
  1821.     /**
  1822.      * Return all section names as array
  1823.      * @return array
  1824.      */
  1825.     public function getSections()
  1826.     {
  1827.         if(!is_array($GLOBALS['PCT_THEMEDESIGNER_CONFIG']) || empty($GLOBALS['PCT_THEMEDESIGNER_CONFIG']))
  1828.         {
  1829.             return array();
  1830.         }
  1831.         
  1832.         return array_keys($GLOBALS['PCT_THEMEDESIGNER_CONFIG']);
  1833.     }
  1836. // ! Session management
  1837.         
  1838.     
  1839.     /**
  1840.      * Return the current session as array
  1841.      * @return array
  1842.      */
  1843.     public function getSession()
  1844.     {
  1845.         $objSession = \Contao\System::getContainer()->get('session');
  1846.         $strTheme = $this->getTheme();
  1847.         $strSession = $this->strSession.'_'.$strTheme;
  1848.         
  1849.         $arrReturn = $objSession->get($strSession);
  1850.         
  1851.         if(!is_array($arrReturn))
  1852.         {
  1853.             $arrReturn = array();
  1854.         }
  1856.         if( !isset($_SESSION[$strSession]) )
  1857.         {
  1858.             $_SESSION[$strSession] = array();
  1859.         }
  1860.         
  1861.         // merge with default php session. This is nessessary for upload files
  1862.         if(is_array($_SESSION[$strSession]) && count($_SESSION[$strSession]) > 0)
  1863.         {
  1864.             $arrIntersect = array_intersect_key($_SESSION[$strSession],$arrReturn);
  1865.             if(is_array($arrIntersect) && count($arrIntersect) > 0)
  1866.             {
  1867.                 foreach($arrIntersect as $k => $arr)
  1868.                 {
  1869.                     if(!is_array($arrReturn[$k]))
  1870.                     {
  1871.                         $arrReturn[$k] = array();
  1872.                     }
  1873.                     
  1874.                     if(is_array($arr))
  1875.                     {
  1876.                         $arrReturn[$k] = array_merge($arrReturn[$k],$arr);
  1877.                     }
  1878.                     else
  1879.                     {
  1880.                         $arrReturn[$k] = $arr;
  1881.                     }
  1882.                 }
  1883.             }
  1884.             
  1885.             $arrDiff = array_diff_key($_SESSION[$strSession], $arrReturn);
  1886.             if(is_array($arrDiff) && count($arrDiff) > 0)
  1887.             {
  1888.                 foreach($arrDiff as $k => $arr)
  1889.                 {
  1890.                     $arrReturn[$k] = $arr;
  1891.                 }
  1892.             }
  1893.             
  1894.             // merge complete, remove temp. php helper session
  1895.             unset($_SESSION[$strSession]);
  1896.             
  1897.             // write session
  1898.             $objSession->set($strSession,$arrReturn);
  1899.             
  1900.             return $arrReturn;
  1901.         }
  1904.         if( !isset($arrReturn['MINIFIED']) )
  1905.         {
  1906.             $arrReturn['MINIFIED'] = false;
  1907.         }
  1909.         if( !isset($arrReturn['SWITCH']) )
  1910.         {
  1911.             $arrReturn['SWITCH'] = array();
  1912.         }
  1914.         if( !isset($arrReturn['IDENT']) )
  1915.         {
  1916.             $arrReturn['IDENT'] = 0;
  1917.         }
  1918.         
  1919.         if( !isset($arrReturn['IFRAME_URL']) )
  1920.         {
  1921.             $arrReturn['IFRAME_URL'] = '';
  1922.         }
  1923.         
  1924.         return $arrReturn; 
  1925.     }
  1928.     /**
  1929.      * Set a session array
  1930.      * @param array||null
  1931.      */
  1932.     public function setSession($arrSession=null)
  1933.     {
  1934.         $objSession = \Contao\System::getContainer()->get('session');
  1935.         
  1936.         // remove the whole session
  1937.         if($arrSession === null)
  1938.         {
  1939.             $objSession->remove($this->strSession.'_'.$this->getTheme());
  1940.             unset($_SESSION[$this->strSession.'_'.$this->getTheme()]);
  1941.             return;
  1942.         }
  1943.         
  1944.         $objSession->set($this->strSession.'_'.$this->getTheme(),$arrSession);
  1945.     }
  1946.         
  1947.     
  1948.     /**
  1949.      * Reset and reload
  1950.      * @param boolean
  1951.      */
  1952.     public function reset()
  1953.     {
  1954.         global $objPage;
  1955.         
  1956.         // clear session
  1957.         $this->setSession();
  1958.         
  1959.         // reload page without parameter
  1960.         \Contao\Controller::redirect( $objPage->getFrontendUrl() );
  1961.     }
  1962.     
  1964.     /**
  1965.      * Add an uploaded file
  1966.      * @param array        Data array of the upload
  1967.      */
  1968.     public function addUpload($strField,$arrFile)
  1969.     {
  1970.         $maxSize = \Contao\System::getReadableSize( $GLOBALS['PCT_THEMEDESIGNER']['maxFileSize'] );
  1971.         
  1972.         $arrFile['name'] = \Contao\StringUtil::sanitizeFileName($arrFile['name']);
  1973.         
  1974.         if (!is_uploaded_file($arrFile['tmp_name']))
  1975.         {
  1976.             if ($arrFile['error'] == 1 || $arrFile['error'] == 2)
  1977.             {
  1978.                 \Contao\System::log('File "'.$arrFile['name'].'" exceeds the maximum file size of '.$maxSize, __METHOD__, TL_ERROR);
  1979.             }
  1980.         }
  1981.         
  1982.         $arrField = $this->getFieldDefinition($strField);
  1983.         
  1984.         $strExtension = pathinfo($arrFile['name'], PATHINFO_EXTENSION);
  1985.         
  1986.         // standardize file names
  1987.         $arrFile['name'] = str_replace(' ', '_',$arrFile['name']);
  1988.         
  1989.         $arrUploadTypes = StringUtil::trimsplit(',', $GLOBALS['PCT_THEMEDESIGNER']['allowedUploadTypes']);
  1991.         // not allowed file type
  1992.         if(!in_array($strExtension, $arrUploadTypes))
  1993.         {
  1994.             \Contao\System::log('File "'.$arrFile['name'].'" is a not allowed file type', __METHOD__, TL_ERROR);
  1995.         }
  1996.         
  1997.         $arrImageSize = @getimagesize($arrFile['tmp_name']);
  1998.         
  1999.         // svg is not an image type in php
  2000.         if($strExtension == 'svg')
  2001.         {
  2002.             $arrImageSize['mime'] = 'image/svg+xml';
  2003.         }
  2004.         
  2005.         $objFiles = \Contao\System::importStatic('Files');
  2006.         $strDest = $GLOBALS['PCT_THEMEDESIGNER']['uploadFolder'] ?: 'system/tmp/themedesigner';
  2007.         
  2008.         // is image
  2009.         if($arrImageSize)
  2010.         {
  2011.             if(!is_dir(TL_ROOT.'/'.$strDest))
  2012.             {
  2013.                 $objFiles->mkdir($strDest);
  2014.             }
  2015.             
  2016.             $strFile = $strDest.'/'.$arrFile['name'];
  2017.             
  2018.             $blnSuccess = $objFiles->move_uploaded_file($arrFile['tmp_name'], $strFile);
  2019.             
  2020.             if(!$blnSuccess)
  2021.             {
  2022.                 \Contao\System::log('File "'.$strFile.'" could not be created or moved to destination: '.$strDest, __METHOD__, TL_ERROR);
  2023.                 return;
  2024.             }
  2025.             
  2026.             $image = array
  2027.             (
  2028.                 'mime'         => $arrImageSize['mime'],
  2029.                 'extension'    => $strExtension,
  2030.                 'file'        => $strFile,
  2031.                 'name'        => $arrFile['name'],
  2032.                 #'size'        => $arrImageSize,
  2033.             );
  2034.             
  2035.             $arrSession = $this->getSession();
  2036.             $arrSession['VALUES'][$strField] = $image;
  2037.             $this->setSession($arrSession);
  2038.             
  2039.             $_SESSION[$this->strSession.'_'.$this->getTheme()]['VALUES'][$strField] = $image;
  2040.         }
  2041.     }
  2042. }