Tiny File Manager

Back Back Up Advanced Editor

<?php

defined('UNLIMITED_ELEMENTS_INC') or die('Restricted access');
class UniteCreatorOutputWork extends HtmlOutputBaseUC
{
    private static $serial = 0;
    const TEMPLATE_HTML = "html";
    const TEMPLATE_CSS = "css";
    const TEMPLATE_CSS_ITEM = "css_item";
    const TEMPLATE_JS = "js";
    const TEMPLATE_HTML_ITEM = "item";
    const TEMPLATE_HTML_ITEM2 = "item2";
    private $addon;
    private $isInited = false;
    private $objTemplate;
    private $isItemsExists = false;
    private $itemsType = null;
    private $paramsCache = null;
    private $cacheConstants = null;
    private $processType = null;
    private $generatedID = null;
    private $isModePreview = false;
    private $arrOptions;
    private $isShowDebugData = false;
    private $debugDataType = "";
    private static $arrUrlCacheCss = array();
    private static $arrHandleCacheCss = array();
    private static $arrUrlCacheJs = array();
    private static $arrHandleCacheJs = array();
    public static $isBufferingCssActive = false;
    public static $bufferBodyCss;
    public static $bufferCssIncludes;
    public function __construct()
    {
        $this->addon = new UniteCreatorAddon();
        if (GlobalsUC::$isProVersion) {
            $this->objTemplate = new UniteCreatorTemplateEnginePro();
        } else {
            $this->objTemplate = new UniteCreatorTemplateEngine();
        }
        $this->processType = UniteCreatorParamsProcessor::PROCESS_TYPE_OUTPUT;
    }
    public function setProcessType($type)
    {
        UniteCreatorParamsProcessor::validateProcessType($type);
        $this->processType = $type;
    }
    private function validateInited()
    {
        if ($this->isInited == false) {
            UniteFunctionsUC::throwError("Output error: addon not inited");
        }
    }
    private function a_________INCLUDES_______()
    {
    }
    public static function clearIncludesCache()
    {
        self::$arrHandleCacheCss = array();
        self::$arrHandleCacheJs = array();
        self::$arrUrlCacheCss = array();
        self::$arrUrlCacheJs = array();
    }
    private function cacheInclude($url, $handle, $type)
    {
        if ($type == "css") {
            self::$arrUrlCacheCss[$url] = true;
            self::$arrHandleCacheCss[$handle] = true;
        } else {
            self::$arrUrlCacheJs[$url] = true;
            self::$arrHandleCacheJs[$handle] = true;
        }
    }
    private function isIncludeInCache($url, $handle, $type)
    {
        if (empty($url) || empty($handle)) {
            return false;
        }
        if ($type == "css") {
            if (isset(self::$arrUrlCacheCss[$url])) {
                return true;
            }
            if (isset(self::$arrHandleCacheCss[$handle])) {
                return true;
            }
        } else {
            if (isset(self::$arrUrlCacheJs[$url])) {
                return true;
            }
            if (isset(self::$arrHandleCacheJs[$handle])) {
                return true;
            }
        }
        return false;
    }
    private function checkIncludeCondition($condition)
    {
        if (empty($condition)) {
            return true;
        }
        if (!is_array($condition)) {
            return true;
        }
        $name = UniteFunctionsUC::getVal($condition, "name");
        $value = UniteFunctionsUC::getVal($condition, "value");
        if (empty($name)) {
            return true;
        }
        if ($name == "never_include") {
            return false;
        }
        $params = $this->getAddonParams();
        if (array_key_exists($name, $params) == false) {
            return true;
        }
        $paramValue = $params[$name];
        if ($paramValue === $value) {
            return true;
        } else {
            return false;
        }
    }
    private function processIncludesList($arrIncludes, $type)
    {
        $arrIncludesProcessed = array();
        foreach ($arrIncludes as $handle => $include) {
            $urlInclude = $include;
            if (is_array($include)) {
                $urlInclude = UniteFunctionsUC::getVal($include, "url");
                $condition = UniteFunctionsUC::getVal($include, "condition");
                $isIncludeByCondition = $this->checkIncludeCondition($condition);
                if ($isIncludeByCondition == false) {
                    continue;
                }
            }
            if (is_numeric($handle) || empty($handle)) {
                $addonName = $this->addon->getName();
                $handle = HelperUC::getUrlHandle($urlInclude, $addonName);
            }
            $urlInclude = HelperUC::urlToSSLCheck($urlInclude);
            $deps = array();
            $params = UniteFunctionsUC::getVal($include, "params");
            if (!empty($params)) {
                $includeAfterFrontend = UniteFunctionsUC::getVal($params, "include_after_elementor_frontend");
                $includeAfterFrontend = UniteFunctionsUC::strToBool($includeAfterFrontend);
                if ($includeAfterFrontend == true) {
                    $deps[] = "elementor-frontend";
                }
            }
            $arrIncludeNew = array();
            $arrIncludeNew["url"] = $urlInclude;
            $arrIncludeNew["type"] = $type;
            if (!empty($handle)) {
                $arrIncludeNew["handle"] = $handle;
            }
            if (!empty($deps)) {
                $arrIncludeNew["deps"] = $deps;
            }
            $arrIncludesProcessed[] = $arrIncludeNew;
        }
        return $arrIncludesProcessed;
    }
    protected function excludeExistingInlcudes($arrIncludes)
    {
        return $arrIncludes;
    }
    public function getProcessedIncludes($includeLibraries = false, $processProviderLibrary = false, $includesType = "all")
    {
        $this->validateInited();
        $arrLibJs = array();
        $arrLibCss = array();
        if ($includeLibraries == true) {
            $arrLibraries = $this->addon->getArrLibraryIncludesUrls($processProviderLibrary);
        }
        $arrIncludesJS = array();
        $arrIncludesCss = array();
        if ($includesType != "css") {
            if ($includeLibraries) {
                $arrLibJs = $arrLibraries["js"];
            }
            $arrIncludesJS = $this->addon->getJSIncludes();
            $arrIncludesJS = array_merge($arrLibJs, $arrIncludesJS);
            $arrIncludesJS = $this->processIncludesList($arrIncludesJS, "js");
        }
        if ($includesType != "js") {
            if ($includeLibraries) {
                $arrLibCss = $arrLibraries["css"];
            }
            $arrIncludesCss = $this->addon->getCSSIncludes();
            $arrIncludesCss = array_merge($arrLibCss, $arrIncludesCss);
            $arrIncludesCss = $this->processIncludesList($arrIncludesCss, "css");
        }
        $arrProcessedIncludes = array_merge($arrIncludesJS, $arrIncludesCss);
        $arrProcessedIncludes = $this->excludeExistingInlcudes($arrProcessedIncludes);
        return $arrProcessedIncludes;
    }
    private function getHtmlIncludes($arrIncludes = null, $filterType = null)
    {
        $this->validateInited();
        if (empty($arrIncludes)) {
            return "";
        }
        $addonName = $this->addon->getName();
        $html = "";
        foreach ($arrIncludes as $include) {
            $type = $include["type"];
            if ($filterType == "js" && $type != "js") {
                continue;
            }
            if ($filterType == "css" && $type != "css") {
                continue;
            }
            $url = $include["url"];
            $handle = UniteFunctionsUC::getVal($include, "handle");
            if (empty($handle)) {
                $handle = HelperUC::getUrlHandle($url, $addonName);
            }
            $isInCache = $this->isIncludeInCache($url, $handle, $type);
            if ($isInCache == true) {
                continue;
            }
            $this->cacheInclude($url, $handle, $type);
            switch ($type) {
                case "js":
                    $html .= self::TAB2 . "<script type='text/javascript' src='{$url}'></script>" . self::BR;
                    break;
                case "css":
                    $cssID = "{$handle}-css";
                    $html .= self::TAB2 . "<link id='{$cssID}' href='{$url}' type='text/css' rel='stylesheet' >" . self::BR;
                    break;
                default:
                    UniteFunctionsUC::throwError("Wrong include type: {$type} ");
                    break;
            }
        }
        return $html;
    }
    public function processIncludes($includesType = "all")
    {
        $arrIncludes = $this->getProcessedIncludes(true, true, $includesType);
        $addonName = $this->addon->getName();
        $arrDep = $this->addon->getIncludesJsDependancies();
        foreach ($arrIncludes as $include) {
            $type = $include["type"];
            $url = $include["url"];
            $handle = UniteFunctionsUC::getVal($include, "handle");
            $deps = UniteFunctionsUC::getVal($include, "deps");
            if (empty($handle)) {
                $handle = HelperUC::getUrlHandle($url, $addonName);
            }
            $isInCache = $this->isIncludeInCache($url, $handle, $type);
            if ($isInCache == true) {
                continue;
            }
            $this->cacheInclude($url, $handle, $type);
            $arrIncludeDep = $arrDep;
            if (!empty($deps)) {
                $arrIncludeDep = array_merge($arrIncludeDep, $deps);
            }
            switch ($type) {
                case "js":
                    UniteProviderFunctionsUC::addScript($handle, $url, false, $arrIncludeDep);
                    break;
                case "css":
                    UniteProviderFunctionsUC::addStyle($handle, $url);
                    break;
                default:
                    UniteFunctionsUC::throwError("Wrong include type: {$type} ");
                    break;
            }
        }
    }
    private function a________PREVIEW_HTML________()
    {
    }
    protected function putPreviewHtml_headerAdd()
    {
    }
    protected function putPreviewHtml_footerAdd()
    {
    }
    protected function onPreviewHtml_scriptsAdd()
    {
    }
    protected function modifyPreviewIncludes($arrIncludes)
    {
        return $arrIncludes;
    }
    private function ______CSS_SELECTORS_______()
    {
    }
    private function processParamCSSSelector_value($param, $selector)
    {
        $value = UniteFunctionsUC::getVal($param, "value");
        $selectorValue = UniteFunctionsUC::getVal($param, "selector_value");
        $selectorValueDesktop = str_replace("{{VALUE}}", $value, $selectorValue);
        $style = $selector . "{{$selectorValueDesktop}}";
        $isResponsive = UniteFunctionsUC::getVal($param, "is_responsive");
        $isResponsive = UniteFunctionsUC::strToBool($isResponsive);
        if ($isResponsive == false) {
            return $style;
        }
        $valueTablet = UniteFunctionsUC::getVal($param, "default_value_tablet");
        $valueTablet = trim($valueTablet);
        $valueMobile = UniteFunctionsUC::getVal($param, "default_value_mobile");
        $valueMobile = trim($valueMobile);
        $isExistsTablet = true;
        $isExistsMobile = true;
        $options = UniteFunctionsUC::getVal($param, "options");
        if (!empty($options)) {
            $isExistsTablet = false;
            $isExistsMobile = false;
            foreach ($options as $optionValue) {
                if ($optionValue == $valueMobile) {
                    $isExistsMobile = true;
                }
                if ($optionValue == $valueTablet) {
                    $isExistsTablet = true;
                }
            }
        }
        if ($isExistsTablet) {
            $selectorValueTablet = str_replace("{{VALUE}}", $valueTablet, $selectorValue);
            $styleTablet = $selector . "{{$selectorValueTablet}}";
            $styleTablet = HelperHtmlUC::wrapCssMobile($styleTablet, true);
            $style .= "\n" . $styleTablet;
        }
        if ($isExistsMobile) {
            $selectorValueMobile = str_replace("{{VALUE}}", $valueMobile, $selectorValue);
            $styleMobile = $selector . "{{$selectorValueMobile}}";
            $styleMobile = HelperHtmlUC::wrapCssMobile($styleMobile, true);
            $style .= "\n" . $styleMobile;
        }
        return $style;
    }
    private function processParamCSSSelector_border_getRadiusStyle($param, $device = "desktop")
    {
        $widthTop = UniteFunctionsUC::getVal($param, "width_{$device}_top");
        $widthRight = UniteFunctionsUC::getVal($param, "width_{$device}_right");
        $widthBottom = UniteFunctionsUC::getVal($param, "width_{$device}_bottom");
        $widthLeft = UniteFunctionsUC::getVal($param, "width_{$device}_left");
        $style = "";
        if (trim($widthTop) !== "") {
            $style .= "border-top-left-radius:{$widthTop}px;";
        }
        if (trim($widthBottom) !== "") {
            $style .= "border-bottom-left-radius:{$widthBottom}px;";
        }
        if (trim($widthRight) !== "") {
            $style .= "border-top-right-radius:{$widthRight}px;";
        }
        if (trim($widthLeft) !== "") {
            $style .= "border-bottom-left-radius:{$widthLeft}px;";
        }
        return $style;
    }
    private function processParamCSSSelector_border($param, $selector)
    {
        $borderType = UniteFunctionsUC::getVal($param, "border_type");
        if (empty($borderType)) {
            return false;
        }
        if ($borderType == "none") {
            return false;
        }
        $style = "border-style: {$borderType};";
        $color = UniteFunctionsUC::getVal($param, "border_color");
        if (empty($color)) {
            $color = "#000000";
        }
        $style .= "border-color:{$color};";
        $styleWidth = $this->processParamCSSSelector_border_getRadiusStyle($param);
        $style .= $styleWidth;
        $css = "{$selector}{{$style}}";
        $styleTablet = $this->processParamCSSSelector_border_getRadiusStyle($param, "tablet");
        if (!empty($styleTablet)) {
            $styleTablet = "{$selector}{{$styleTablet}}";
            $styleTablet = HelperHtmlUC::wrapCssMobile($styleTablet, true);
            $css .= "\n" . $styleTablet;
        }
        $styleMobile = $this->processParamCSSSelector_border_getRadiusStyle($param, "mobile");
        if (!empty($styleMobile)) {
            $styleMobile = "{$selector}{{$styleMobile}}";
            $styleMobile = HelperHtmlUC::wrapCssMobile($styleMobile);
            $css .= "\n" . $styleMobile;
        }
        return $css;
    }
    private function processParamCSSSelector_textShadow($param, $selector)
    {
        $isEnable = UniteFunctionsUC::getVal($param, "enable_default_values");
        $isEnable = UniteFunctionsUC::strToBool($isEnable);
        if ($isEnable == false) {
            return false;
        }
        $color = UniteFunctionsUC::getVal($param, "color");
        $blur = UniteFunctionsUC::getVal($param, "blur");
        $horizontal = UniteFunctionsUC::getVal($param, "horizontal");
        $vertical = UniteFunctionsUC::getVal($param, "vertical");
        $shadow = "{$horizontal}px {$vertical}px {$blur}px {$color}";
        $css = "text-shadow:{$shadow}";
        $style = "{$selector}{{$css}}";
        return $style;
    }
    private function processParamCSSSelector_background($param, $selector)
    {
        $name = UniteFunctionsUC::getVal($param, "name");
        $value = UniteFunctionsUC::getVal($param, "value");
        $type = UniteFunctionsUC::getVal($value, $name . "_type");
        $css = "";
        switch ($type) {
            case "solid":
                $color = UniteFunctionsUC::getVal($value, $name . "_color_solid");
                $css = "background-color:{$color} !important;";
                $bgImage = UniteFunctionsUC::getVal($param, "solid_bg_image");
                $bgPosition = UniteFunctionsUC::getVal($param, "solid_bg_image_position");
                $bgSize = UniteFunctionsUC::getVal($param, "solid_bg_image_size");
                $bgRepeat = UniteFunctionsUC::getVal($param, "solid_bg_image_repeat");
                if (!empty($bgImage)) {
                    $bgImage = $this->addon->convertFromUrlAssets($bgImage);
                    $css .= "background-image:url('{$bgImage}');";
                    if (!empty($bgPosition)) {
                        $css .= "background-position:{$bgPosition};";
                    }
                    if (!empty($bgSize)) {
                        $css .= "background-size:{$bgSize};";
                    }
                    if (!empty($bgRepeat)) {
                        $css .= "background-repeat:{$bgRepeat};";
                    }
                }
                break;
            case "gradient":
                $color1 = UniteFunctionsUC::getVal($value, $name . "_color_gradient1");
                $color2 = UniteFunctionsUC::getVal($value, $name . "_color_gradient2");
                if (!empty($color1) && !empty($color2)) {
                    $css = "background:linear-gradient({$color1}, {$color2}) !important;";
                }
                break;
        }
        if (empty($css)) {
            return false;
        }
        $style = "{$selector}{{$css}}";
        return $style;
    }
    private function processParamCSSSelector_slider($param, $selector)
    {
        $name = UniteFunctionsUC::getVal($param, "name");
        $value = UniteFunctionsUC::getVal($param, "value");
        $selectorValue = UniteFunctionsUC::getVal($param, "selector_value");
        $units = UniteFunctionsUC::getVal($param, "units");
        if (empty($units)) {
            $units = UniteFunctionsUC::getVal($param, "unit");
        }
        $isResponsive = UniteFunctionsUC::getVal($param, "is_responsive");
        $isResponsive = UniteFunctionsUC::strToBool($isResponsive);
        $css = "";
        if (empty($selectorValue)) {
            return false;
        }
        if (empty($value)) {
            $value = "0";
        }
        if ($units == "__hide__") {
            $units = "";
        }
        if ($units == "other") {
            $units = UniteFunctionsUC::getVal($param, "unit_custom");
        }
        $units = trim($units);
        $selectorValueBase = $selectorValue;
        $selectorValue = str_replace("{{SIZE}}", $value, $selectorValue);
        $selectorValue = str_replace("{{UNIT}}", $units, $selectorValue);
        $style = $selector . "{{$selectorValue}}";
        if (empty($style)) {
            return null;
        }
        if ($isResponsive == false) {
            return $style;
        }
        $valueTablet = UniteFunctionsUC::getVal($param, "value_tablet");
        $valueTablet = trim($valueTablet);
        if ($valueTablet !== "") {
            $selectorTabletValue = $selectorValueBase;
            $selectorTabletValue = str_replace("{{SIZE}}", $valueTablet, $selectorTabletValue);
            $selectorTabletValue = str_replace("{{UNIT}}", $units, $selectorTabletValue);
            $styleTablet = $selector . "{{$selectorTabletValue}}";
            $styleTablet = HelperHtmlUC::wrapCssMobile($styleTablet, true);
            $style .= "\n" . $styleTablet;
        }
        $valueMobile = UniteFunctionsUC::getVal($param, "value_mobile");
        $valueMobile = trim($valueMobile);
        if ($valueMobile !== "") {
            $selectorMobileValue = $selectorValueBase;
            $selectorMobileValue = str_replace("{{SIZE}}", $valueMobile, $selectorMobileValue);
            $selectorMobileValue = str_replace("{{UNIT}}", $units, $selectorMobileValue);
            $styleMobile = $selector . "{{$selectorMobileValue}}";
            $styleMobile = HelperHtmlUC::wrapCssMobile($styleMobile);
            $style .= "\n" . $styleMobile;
        }
        return $style;
    }
    private function processParamCSSSelector_number($param, $selector)
    {
        $name = UniteFunctionsUC::getVal($param, "name");
        $value = UniteFunctionsUC::getVal($param, "value");
        $selectorValue = UniteFunctionsUC::getVal($param, "selector_value");
        $isResponsive = UniteFunctionsUC::getVal($param, "is_responsive");
        $isResponsive = UniteFunctionsUC::strToBool($isResponsive);
        $css = "";
        if (empty($selectorValue)) {
            return false;
        }
        if (empty($value)) {
            $value = "0";
        }
        $selectorValueBase = $selectorValue;
        $selectorValue = str_replace("{{VALUE}}", $value, $selectorValue);
        $style = $selector . "{{$selectorValue}}";
        if (empty($style)) {
            return null;
        }
        if ($isResponsive == false) {
            return $style;
        }
        $valueTablet = UniteFunctionsUC::getVal($param, "value_tablet");
        $valueTablet = trim($valueTablet);
        if ($valueTablet !== "") {
            $selectorTabletValue = $selectorValueBase;
            $selectorTabletValue = str_replace("{{VALUE}}", $valueTablet, $selectorTabletValue);
            $styleTablet = $selector . "{{$selectorTabletValue}}";
            $styleTablet = HelperHtmlUC::wrapCssMobile($styleTablet, true);
            $style .= "\n" . $styleTablet;
        }
        $valueMobile = UniteFunctionsUC::getVal($param, "value_mobile");
        $valueMobile = trim($valueMobile);
        if ($valueMobile !== "") {
            $selectorMobileValue = $selectorValueBase;
            $selectorMobileValue = str_replace("{{VALUE}}", $valueMobile, $selectorMobileValue);
            $styleMobile = $selector . "{{$selectorMobileValue}}";
            $styleMobile = HelperHtmlUC::wrapCssMobile($styleMobile);
            $style .= "\n" . $styleMobile;
        }
        return $style;
    }
    private function processParamCSSSelector_dimentions($param, $selector, $type)
    {
        $arrValues = UniteFunctionsUC::getVal($param, "value");
        if (empty($arrValues)) {
            return false;
        }
        $unit = UniteFunctionsUC::getVal($arrValues, "unit");
        if (empty($unit)) {
            return false;
        }
        $css = "";
        $arrValuesTablet = array();
        $arrValuesMobile = array();
        foreach ($arrValues as $name => $value) {
            if ($name == "unit") {
                continue;
            }
            $value = trim($value);
            if (is_numeric($value) == false) {
                continue;
            }
            if (strpos($name, "tablet_") !== false) {
                $name = str_replace("tablet_", "", $name);
                $arrValuesTablet[$name] = $value;
                continue;
            }
            if (strpos($name, "mobile_") !== false) {
                $name = str_replace("mobile_", "", $name);
                $arrValuesMobile[$name] = $value;
                continue;
            }
            $css .= "{$type}-{$name}:{$value}{$unit};";
        }
        if (!empty($arrValuesTablet)) {
            foreach ($arrValuesTablet as $name => $value) {
                $cssTablet .= "{$type}-{$name}:{$value}{$unit};";
            }
        }
        $cssMobile = "";
        if (!empty($arrValuesMobile)) {
            foreach ($arrValuesMobile as $name => $value) {
                $cssMobile .= "{$type}-{$name}:{$value}{$unit};";
            }
        }
        if (empty($css)) {
            return false;
        }
        $style = "{$selector}{{$css}}";
        if (!empty($cssTablet)) {
            $styleTablet = "{$selector}{{$cssTablet}}";
            $styleTablet = HelperHtmlUC::wrapCssMobile($styleTablet, true);
            $style .= "\n" . $styleTablet;
        }
        if (!empty($cssMobile)) {
            $styleMobile = "{$selector}{{$cssMobile}}";
            $styleMobile = HelperHtmlUC::wrapCssMobile($styleMobile);
            $style .= "\n" . $styleMobile;
        }
        return $style;
    }
    private function processParamCSSSelector($param)
    {
        $selector = UniteFunctionsUC::getVal($param, "selector");
        $type = UniteFunctionsUC::getVal($param, "type");
        $selector = trim($selector);
        if (empty($selector)) {
            return false;
        }
        switch ($type) {
            case UniteCreatorDialogParam::PARAM_NUMBER:
                $style = $this->processParamCSSSelector_number($param, $selector);
                break;
            case UniteCreatorDialogParam::PARAM_PADDING:
                $style = $this->processParamCSSSelector_dimentions($param, $selector, "padding");
                break;
            case UniteCreatorDialogParam::PARAM_MARGINS:
                $style = $this->processParamCSSSelector_dimentions($param, $selector, "margin");
                break;
            case UniteCreatorDialogParam::PARAM_BORDER_DIMENTIONS:
                $style = $this->processParamCSSSelector_dimentions($param, $selector, "border-radius");
                break;
            case UniteCreatorDialogParam::PARAM_BACKGROUND:
                $style = $this->processParamCSSSelector_background($param, $selector);
                break;
            case UniteCreatorDialogParam::PARAM_SLIDER:
                $style = $this->processParamCSSSelector_slider($param, $selector);
                break;
            case UniteCreatorDialogParam::PARAM_COLORPICKER:
                $style = $this->processParamCSSSelector_value($param, $selector);
                break;
            case UniteCreatorDialogParam::PARAM_BORDER:
                $style = $this->processParamCSSSelector_border($param, $selector);
                break;
            case UniteCreatorDialogParam::PARAM_DROPDOWN:
                $style = $this->processParamCSSSelector_value($param, $selector);
                break;
            case UniteCreatorDialogParam::PARAM_TEXTSHADOW:
                $style = $this->processParamCSSSelector_textShadow($param, $selector);
                break;
        }
        if (empty($style)) {
            return false;
        }
        UniteProviderFunctionsUC::printCustomStyle($style);
    }
    private function processPreviewParamsSelectors()
    {
        $mainParams = $this->addon->getParams();
        if (empty($mainParams)) {
            return false;
        }
        foreach ($mainParams as $param) {
            $this->processParamCSSSelector($param);
        }
    }
    public function getPreviewHtml()
    {
        $this->validateInited();
        $outputs = "";
        $title = $this->addon->getTitle();
        $title .= " " . esc_html__("Preview", "unlimited-elements-for-elementor");
        $title = htmlspecialchars($title);
        $htmlBody = $this->getHtmlBody(false);
        $arrIncludes = $this->getProcessedIncludes(true, false);
        $arrIncludes = $this->modifyPreviewIncludes($arrIncludes);
        $htmlInlcudesCss = $this->getHtmlIncludes($arrIncludes, "css");
        $htmlInlcudesJS = $this->getHtmlIncludes($arrIncludes, "js");
        $this->processPreviewParamsSelectors();
        $arrCssCustomStyles = UniteProviderFunctionsUC::getCustomStyles();
        $htmlCustomCssStyles = HelperHtmlUC::getHtmlCustomStyles($arrCssCustomStyles);
        $arrJsCustomScripts = UniteProviderFunctionsUC::getCustomScripts();
        $htmlJSScripts = HelperHtmlUC::getHtmlCustomScripts($arrJsCustomScripts);
        $options = $this->addon->getOptions();
        $bgCol = $this->addon->getOption("preview_bgcol");
        $previewSize = $this->addon->getOption("preview_size");
        $previewWidth = "100%";
        switch ($previewSize) {
            case "column":
                $previewWidth = "300px";
                break;
            case "custom":
                $previewWidth = $this->addon->getOption("preview_custom_width");
                if (!empty($previewWidth)) {
                    $previewWidth = (int) $previewWidth;
                    $previewWidth .= "px";
                }
                break;
        }
        $style = "";
        $style .= "max-width:{$previewWidth};";
        $style .= "background-color:{$bgCol};";
        $urlPreviewCss = GlobalsUC::$urlPlugin . "css/unitecreator_preview.css";
        $html = "";
        $htmlHead = "";
        $htmlHead = "<!DOCTYPE html>" . self::BR;
        $htmlHead .= "<html>" . self::BR;
        $htmlHead .= self::TAB . "<head>" . self::BR;
        $html .= $htmlHead;
        $htmlHead .= self::TAB2 . "<title>{$title}</title>" . self::BR;
        $htmlHead .= self::TAB2 . "<link rel='stylesheet' href='{$urlPreviewCss}' type='text/css'>" . self::BR;
        $htmlHead .= $htmlInlcudesCss;
        if (!empty($htmlCustomCssStyles)) {
            $htmlHead .= self::BR . $htmlCustomCssStyles;
        }
        $html .= $htmlHead;
        $output["head"] = $htmlHead;
        $htmlAfterHead = "";
        $htmlAfterHead .= self::TAB . "</head>" . self::BR;
        $htmlAfterHead .= self::TAB . "<body>" . self::BR;
        $htmlAfterHead .= self::BR . self::TAB2 . "<div class='uc-preview-wrapper' style='{$style}'>";
        $htmlAfterHead .= self::BR . $htmlBody;
        $htmlAfterHead .= self::BR . self::TAB2 . "</div>";
        $html .= $htmlAfterHead;
        $output["after_head"] = $htmlAfterHead;
        $htmlEnd = "";
        $htmlEnd .= $htmlInlcudesJS . self::BR;
        $htmlEnd .= $htmlJSScripts . self::BR;
        $htmlEnd .= self::BR . self::TAB . "</body>" . self::BR;
        $htmlEnd .= "</html>";
        $html .= $htmlEnd;
        $output["end"] = $htmlEnd;
        $output["full_html"] = $html;
        return $output;
    }
    public function putPreviewHtml()
    {
        $output = $this->getPreviewHtml();
        echo UniteProviderFunctionsUC::escCombinedHtml($output["head"]);
        echo UniteProviderFunctionsUC::escCombinedHtml($output["after_head"]);
        $this->putPreviewHtml_footerAdd();
        echo UniteProviderFunctionsUC::escCombinedHtml($output["end"]);
    }
    private function a________DYNAMIC___________()
    {
    }
    protected function initDynamicParams()
    {
        $isDynamicAddon = UniteFunctionsUC::getVal($this->arrOptions, "dynamic_addon");
        $isDynamicAddon = UniteFunctionsUC::strToBool($isDynamicAddon);
        if ($isDynamicAddon == false) {
            return false;
        }
        $postID = $this->getDynamicPostID();
        if (!empty($postID)) {
            $arrPostAdditions = HelperProviderUC::getPostAdditionsArray_fromAddonOptions($this->arrOptions);
            $this->addPostParamToAddon($postID, $arrPostAdditions);
        }
    }
    protected function getDynamicPostID()
    {
        $postID = "";
        if ($this->isModePreview) {
            $postID = UniteFunctionsUC::getVal($this->arrOptions, "dynamic_post");
            return $postID;
        }
        $post = get_post();
        if (!empty($post)) {
            $postID = $post->ID;
        }
        return $postID;
    }
    private function addPostParamToAddon($postID, $arrPostAdditions)
    {
        $arrParam = array();
        $arrParam["type"] = UniteCreatorDialogParam::PARAM_POST;
        $arrParam["name"] = "current_post";
        $arrParam["default_value"] = $postID;
        $arrParam["post_additions"] = $arrPostAdditions;
        $this->addon->addParam($arrParam);
    }
    private function a________GENERAL___________()
    {
    }
    private function modifyItemsDataForShow($arrItemData)
    {
        if (is_array($arrItemData) == false) {
            return null;
        }
        $arrItemsForShow = array();
        foreach ($arrItemData as $item) {
            if (is_array($item) == false) {
                $arrItemsForShow[] = $item;
                continue;
            }
            $item = UniteFunctionsUC::getVal($item, "item");
            $itemFirstValue = UniteFunctionsUC::getArrFirstValue($item);
            if (is_array($itemFirstValue)) {
                $item = UniteFunctionsUC::modifyDataArrayForShow($itemFirstValue);
            } else {
                $item = UniteFunctionsUC::modifyDataArrayForShow($item);
            }
            $arrItemsForShow[] = $item;
        }
        return $arrItemsForShow;
    }
    private function ___________DEBUG_DATA___________()
    {
    }
    private function putDebugDataHtml_default($arrData, $arrItemData)
    {
        $isShowData = $this->debugDataType != "items_only";
        if ($isShowData == true) {
            $arrData = UniteFunctionsUC::modifyDataArrayForShow($arrData);
            dmp($arrData);
        }
        dmp("<b>Widget Items Data</b>");
        if (empty($arrItemData)) {
            dmp("no items found");
            return false;
        }
        $arrItemData = $this->modifyItemsDataForShow($arrItemData);
        dmp($arrItemData);
    }
    private function putDebugDataHtml_posts($arrItemData)
    {
        $numPosts = count($arrItemData);
        dmp("Found {$numPosts} posts.");
        if (empty($arrItemData)) {
            return false;
        }
        $isShowMeta = $this->debugDataType == "post_meta";
        foreach ($arrItemData as $index => $item) {
            $isPost = false;
            if ($item instanceof WP_Post) {
                $isPost = true;
            }
            if ($isPost == false) {
                $item = UniteFunctionsUC::getVal($item, "item");
                $postData = UniteFunctionsUC::getArrFirstValue($item);
                $title = UniteFunctionsUC::getVal($postData, "title");
                $alias = UniteFunctionsUC::getVal($postData, "alias");
                $id = UniteFunctionsUC::getVal($postData, "id");
                $post = get_post($id);
            } else {
                $post = $item;
                $title = $post->post_title;
                $id = $post->ID;
                $alias = $post->post_name;
            }
            $num = $index + 1;
            $status = $post->post_status;
            $arrTermsNames = UniteFunctionsWPUC::getPostTermsTitles($post);
            $strTerms = implode(",", $arrTermsNames);
            $htmlAfterAlias = "";
            if ($status != "publish") {
                $htmlAfterAlias = ", [{$status} post]";
            }
            $text = "{$num}. <b>{$title}</b> (<i style='font-size:13px;'>{$alias}{$htmlAfterAlias}, {$id} | {$strTerms} </i>)";
            dmp($text);
            if ($isShowMeta == false) {
                continue;
            }
            $postMeta = get_post_meta($id, "", false);
            $postMeta = UniteFunctionsUC::modifyDataArrayForShow($postMeta, true);
            dmp($postMeta);
        }
    }
    private function putDebugDataHtml_getItemsFromListing($paramListing, $arrData)
    {
        $name = UniteFunctionsUC::getVal($paramListing, "name");
        $source = UniteFunctionsUC::getVal($arrData, $name . "_source");
        $arrItemsRaw = UniteFunctionsUC::getVal($arrData, $name . "_items");
        if (empty($arrItemsRaw)) {
            $arrItemsRaw = array();
        }
        $useFor = UniteFunctionsUC::getVal($paramListing, "use_for");
        $useForGallery = $useFor == "gallery";
        $arrItems = array();
        foreach ($arrItemsRaw as $item) {
            if ($useForGallery == true && isset($item["postid"])) {
                $post = get_post($item["postid"]);
                $arrItems[] = $post;
                continue;
            }
            $object = UniteFunctionsUC::getVal($item, "object");
            $arrItems[] = $object;
        }
        return $arrItems;
    }
    private function putDebugDataHtml($arrData, $arrItemData)
    {
        echo "<div style='font-size:16px;color:black;text-decoration:none;background-color:white;'>";
        dmp("<b>Widget Debug Data</b> (turned on by setting in widget advanced section)<br>");
        $paramListing = $this->addon->getParamByType(UniteCreatorDialogParam::PARAM_LISTING);
        if (!empty($paramListing)) {
            $arrItemData = $this->putDebugDataHtml_getItemsFromListing($paramListing, $arrData);
        }
        switch ($this->debugDataType) {
            case "post_titles":
            case "post_meta":
                $this->putDebugDataHtml_posts($arrItemData);
                break;
            default:
                $this->putDebugDataHtml_default($arrData, $arrItemData);
                break;
        }
        echo "</div>";
    }
    protected function processHtml($html)
    {
        return $html;
    }
    public function showDebugData($isShow = true, $dataType = null)
    {
        $this->isShowDebugData = $isShow;
        $this->debugDataType = $dataType;
    }
    public function getProcessedHtmlTemplate()
    {
        $html = $this->objTemplate->getRenderedHtml(self::TEMPLATE_HTML);
        $html = $this->processHtml($html);
        return $html;
    }
    public function getHtmlBody($scriptHardCoded = true, $putCssIncludes = false, $putCssInline = true, $params = null)
    {
        $this->validateInited();
        $title = $this->addon->getTitle(true);
        $isOutputComments = HelperProviderCoreUC_EL::getGeneralSetting("output_wrapping_comments");
        $settings = HelperProviderCoreUC_EL::getGeneralSettingsValues();
        $isOutputComments = UniteFunctionsUC::strToBool($isOutputComments);
        try {
            $html = $this->objTemplate->getRenderedHtml(self::TEMPLATE_HTML);
            $html = $this->processHtml($html);
            $css = $this->objTemplate->getRenderedHtml(self::TEMPLATE_CSS);
            $js = $this->objTemplate->getRenderedHtml(self::TEMPLATE_JS);
            $arrCssIncludes = array();
            if ($putCssIncludes == true) {
                $arrCssIncludes = $this->getProcessedIncludes(true, true, "css");
            }
            if ($isOutputComments == true) {
                $output = "";
            } else {
                $output = "";
            }
            if (!empty($arrCssIncludes)) {
                $htmlIncludes = $this->getHtmlIncludes($arrCssIncludes);
                if (self::$isBufferingCssActive == true) {
                    self::$bufferCssIncludes .= self::BR . $htmlIncludes;
                } else {
                    $output .= "\n" . $htmlIncludes;
                }
            }
            if (!empty($css)) {
                $css = "/* widget: {$title} */" . self::BR2 . $css . self::BR2;
                if (self::$isBufferingCssActive == true) {
                    if (!empty(self::$bufferBodyCss)) {
                        self::$bufferBodyCss .= self::BR2;
                    }
                    self::$bufferBodyCss .= $css;
                } else {
                    if ($putCssInline == true) {
                        $output .= "\n\t\t\t<style type=\"text/css\">{$css}</style>";
                    } else {
                        HelperUC::putInlineStyle($css);
                    }
                }
            }
            $output .= "\n\n\t\t\t" . $html;
            $isOutputJs = false;
            if (!empty($js)) {
                $isOutputJs = true;
            }
            if (isset($params["wrap_js_start"]) || isset($params["wrap_js_timeout"])) {
                $isOutputJs = true;
            }
            if ($isOutputJs == true) {
                $title = $this->addon->getTitle();
                if ($scriptHardCoded == false) {
                    $js = "// {$title} scripts: \n" . $js;
                }
                if ($scriptHardCoded == false) {
                    UniteProviderFunctionsUC::printCustomScript($js);
                } else {
                    $wrapInTimeout = UniteFunctionsUC::getVal($params, "wrap_js_timeout");
                    $wrapInTimeout = UniteFunctionsUC::strToBool($wrapInTimeout);
                    $wrapStart = UniteFunctionsUC::getVal($params, "wrap_js_start");
                    $wrapEnd = UniteFunctionsUC::getVal($params, "wrap_js_end");
                    $output .= "\n\n\t\t\t<script type=\"text/javascript\">";
                    if (!empty($wrapStart)) {
                        $output .= "\n\t\t" . $wrapStart;
                    }
                    if ($wrapInTimeout == true) {
                        $output .= "\n\t\t\tsetTimeout(function(){";
                    }
                    $output .= "\n\t\t\t" . $js;
                    if ($wrapInTimeout == true) {
                        $output .= "\n\t\t\t},300);";
                    }
                    if (!empty($wrapEnd)) {
                        $output .= "\n\t\t" . $wrapEnd;
                    }
                    $output .= "\n\t\t\t</script>";
                }
            }
            if ($isOutputComments == true) {
                $output .= "\n\t\t\t";
            }
        } catch (Exception $e) {
            $message = $e->getMessage();
            $message = "Error in widget {$title}, " . $message;
            UniteFunctionsUC::throwError($message);
        }
        return $output;
    }
    public function getConstantData()
    {
        $this->validateInited();
        if (!empty($this->cacheConstants)) {
            return $this->cacheConstants;
        }
        $data = array();
        $prefix = "ucid";
        if ($this->isInited) {
            $prefix = "uc_" . $this->addon->getName();
        }
        self::$serial++;
        $generatedSerial = self::$serial . UniteFunctionsUC::getRandomString(4, true);
        $this->generatedID = $prefix . $generatedSerial;
        $data["uc_serial"] = $generatedSerial;
        $data["uc_id"] = $this->generatedID;
        $urlAssets = $this->addon->getUrlAssets();
        if (!empty($urlAssets)) {
            $data["uc_assets_url"] = $urlAssets;
        }
        $isInsideEditor = false;
        if ($this->processType == UniteCreatorParamsProcessor::PROCESS_TYPE_OUTPUT_BACK) {
            $isInsideEditor = true;
        }
        $data = UniteProviderFunctionsUC::addSystemConstantData($data);
        $data = UniteProviderFunctionsUC::applyFilters(UniteCreatorFilters::FILTER_ADD_ADDON_OUTPUT_CONSTANT_DATA, $data);
        $this->cacheConstants = $data;
        return $data;
    }
    public function getItemConstantDataKeys()
    {
        $arrKeys = array("item_id", "item_index", "item_repeater_class");
        return $arrKeys;
    }
    public function getConstantDataKeys($filterPlatformKeys = false)
    {
        $constantData = $this->getConstantData();
        if ($filterPlatformKeys == true) {
            unset($constantData["uc_platform"]);
            unset($constantData["uc_platform_title"]);
        }
        $arrKeys = array_keys($constantData);
        return $arrKeys;
    }
    private function getAddonParams()
    {
        if (!empty($this->paramsCache)) {
            return $this->paramsCache;
        }
        $this->paramsCache = $this->addon->getProcessedMainParamsValues($this->processType);
        return $this->paramsCache;
    }
    protected function normalizeItemsData($arrItems, $extraKey = null)
    {
        if (empty($arrItems)) {
            return array();
        }
        foreach ($arrItems as $key => $item) {
            if (!empty($extraKey)) {
                $arrItems[$key] = array("item" => array($extraKey => $item));
            } else {
                $arrItems[$key] = array("item" => $item);
            }
        }
        return $arrItems;
    }
    private function getItemsSpecial_Instagram($arrData)
    {
        $paramInstagram = $this->addon->getParamByType(UniteCreatorDialogParam::PARAM_INSTAGRAM);
        $instaName = UniteFunctionsUC::getVal($paramInstagram, "name");
        $dataInsta = $arrData[$instaName];
        $instaMain = UniteFunctionsUC::getVal($dataInsta, "main");
        $instaItems = UniteFunctionsUC::getVal($dataInsta, "items");
        $error = UniteFunctionsUC::getVal($dataInsta, "error");
        if (empty($instaMain)) {
            $instaMain = array();
        }
        $instaMain["hasitems"] = !empty($instaItems);
        if (!empty($error)) {
            $instaMain["error"] = $error;
        }
        $arrItemData = $this->normalizeItemsData($instaItems, $instaName);
        $arrData[$instaName] = $instaMain;
        $output = array();
        $output["main"] = $arrData;
        $output["items"] = $arrItemData;
        return $output;
    }
    private function initTemplate()
    {
        $this->validateInited();
        $arrData = $this->getConstantData();
        $arrParams = $this->getAddonParams();
        $arrData = array_merge($arrData, $arrParams);
        $html = $this->addon->getHtml();
        $css = $this->addon->getCss();
        $cssItem = $this->addon->getCssItem();
        $cssItem = trim($cssItem);
        if (!empty($cssItem)) {
            $css .= "\n{{put_css_items()}}";
        }
        $js = $this->addon->getJs();
        $this->objTemplate->setAddon($this->addon);
        $this->objTemplate->addTemplate(self::TEMPLATE_HTML, $html);
        $this->objTemplate->addTemplate(self::TEMPLATE_CSS, $css);
        $this->objTemplate->addTemplate(self::TEMPLATE_JS, $js);
        $arrItemData = null;
        $paramPostsList = null;
        if ($this->isItemsExists == false) {
            $this->objTemplate->setParams($arrData);
        } else {
            if ($this->processType == UniteCreatorParamsProcessor::PROCESS_TYPE_CONFIG) {
                $arrItemData = array();
            } else {
                switch ($this->itemsType) {
                    case "instagram":
                        $response = $this->getItemsSpecial_Instagram($arrData);
                        $arrData = $response["main"];
                        $arrItemData = $response["items"];
                        break;
                    case "post":
                        $paramPostsList = $this->addon->getParamByType(UniteCreatorDialogParam::PARAM_POSTS_LIST);
                        if (empty($paramPostsList)) {
                            UniteFunctionsUC::throwError("Some posts list param should be found");
                        }
                        $postsListName = UniteFunctionsUC::getVal($paramPostsList, "name");
                        $arrItemData = $this->normalizeItemsData($arrData[$postsListName], $postsListName);
                        $arrData[$postsListName] = !empty($arrItemData);
                        break;
                    case UniteCreatorAddon::ITEMS_TYPE_DATASET:
                        $paramDataset = $this->addon->getParamByType(UniteCreatorDialogParam::PARAM_DATASET);
                        if (empty($paramDataset)) {
                            UniteFunctionsUC::throwError("Dataset param not found");
                        }
                        $datasetType = UniteFunctionsUC::getVal($paramDataset, "dataset_type");
                        $datasetQuery = UniteFunctionsUC::getVal($paramDataset, "dataset_{$datasetType}_query");
                        $arrRecords = array();
                        $arrItemData = UniteProviderFunctionsUC::applyFilters(UniteCreatorFilters::FILTER_GET_DATASET_RECORDS, $arrRecords, $datasetType, $datasetQuery);
                        if (!empty($arrItemData)) {
                            $paramName = $paramDataset["name"];
                            $arrItemData = $this->normalizeItemsData($arrItemData, $paramName);
                        }
                        break;
                    default:
                        $arrItemData = $this->addon->getProcessedItemsData($this->processType);
                        break;
                }
            }
            $itemIndex = 0;
            foreach ($arrItemData as $key => $item) {
                $arrItem = $item["item"];
                $itemIndex++;
                $arrItem["item_index"] = $itemIndex;
                $arrItem["item_id"] = $this->generatedID . "_item" . $itemIndex;
                $arrItemData[$key]["item"] = $arrItem;
            }
            $this->objTemplate->setParams($arrData);
            $this->objTemplate->setArrItems($arrItemData);
            $htmlItem = $this->addon->getHtmlItem();
            $this->objTemplate->addTemplate(self::TEMPLATE_HTML_ITEM, $htmlItem);
            $htmlItem2 = $this->addon->getHtmlItem2();
            $this->objTemplate->addTemplate(self::TEMPLATE_HTML_ITEM2, $htmlItem2);
            $this->objTemplate->addTemplate(self::TEMPLATE_CSS_ITEM, $cssItem);
        }
        if (!empty($paramPostsList)) {
            $postListValue = UniteFunctionsUC::getVal($paramPostsList, "value");
            if (!empty($paramPostsList) && is_array($paramPostsList)) {
                $arrData = array_merge($arrData, $postListValue);
            }
        }
        if ($this->isShowDebugData == true) {
            $this->putDebugDataHtml($arrData, $arrItemData);
        }
    }
    public function setPreviewAddonMode()
    {
        $this->isModePreview = true;
    }
    public function initByAddon(UniteCreatorAddon $addon)
    {
        if (empty($addon)) {
            UniteFunctionsUC::throwError("Wrong addon given");
        }
        HelperUC::clearDebug();
        $this->isInited = true;
        $this->addon = $addon;
        $this->isItemsExists = $this->addon->isHasItems();
        $this->itemsType = $this->addon->getItemsType();
        $this->arrOptions = $this->addon->getOptions();
        switch ($this->itemsType) {
            case "instagram":
            case "post":
                $this->isItemsExists = true;
                break;
        }
        $this->initDynamicParams();
        $this->initTemplate();
    }
}