Tiny File Manager

Back Back Up Advanced Editor

<?php

defined('UNLIMITED_ELEMENTS_INC') or die('Restricted access');
class UniteCreatorLayoutWork extends UniteElementsBaseUC
{
    protected $id;
    protected $title, $name, $data, $gridData, $ordering, $gridDataFull, $record, $params, $arrAddonNames;
    protected static $arrCacheAddons = array();
    protected $addonType = null, $arrAllOptionsCache = null;
    protected $extraParams = array();
    protected $objShapes, $layoutType, $isTemplate = false, $objLayouts;
    protected $objLayoutType;
    const KEY_SETTINGS_ADDDATA = "uc_settings_adddata";
    const EXPORT_CAT_TYPE_PREFIX = "uc_addontype_";
    const FIELDS_LAYOUTS = "title,ordering,layout_data,catid,name,layout_type,parent_id,relate_id,params";
    const LAYOUTS_GLOBAL_SETTINGS_OPTION = "unitecreator_layouts_general_settings";
    public function __construct()
    {
        $this->objShapes = new UniteShapeManagerUC();
        $this->objLayouts = new UniteCreatorLayouts();
        parent::__construct();
    }
    public function setLayoutType($type)
    {
        $this->layoutType = $type;
        $this->objLayoutType = UniteCreatorAddonType::getAddonTypeObject($type, true);
        $this->isTemplate = $this->objLayoutType->isTemplate;
    }
    public function validateInited()
    {
        if (empty($this->id)) {
            UniteFunctionsUC::throwError("The layout is not inited");
        }
    }
    public function isInited()
    {
        if (!empty($this->id)) {
            return true;
        }
        return false;
    }
    private function validateTitle($title)
    {
        UniteFunctionsUC::validateNotEmpty($title, "Title");
    }
    private function validateNameNotExists($name, $layoutType)
    {
        $isExists = $this->isLayoutExistsByName($name, $layoutType);
        if ($isExists == true) {
            UniteFunctionsUC::throwError("The layout with name: {$name} already exists");
        }
    }
    private function validateName($name)
    {
        $fieldName = $this->objLayoutType->textSingle . esc_html__(" Name", "unlimited-elements-for-elementor");
        UniteFunctionsUC::validateNotEmpty($name, $fieldName);
        UniteFunctionsUC::validateUrlAlias($name, $fieldName);
        $this->validateNameNotExists($name, $this->layoutType);
    }
    private function validateLayoutNotExistsByTitle($title, $layoutType)
    {
        $isExists = $this->isLayoutExistsByTitle($title, $layoutType);
        if ($isExists == true) {
            UniteFunctionsUC::throwError("The layout with title: {$title} already exists");
        }
    }
    private function a_________STATIC_FUNCTIONS________()
    {
    }
    public static function getGridGlobalStoredValues()
    {
        $arrValues = UniteProviderFunctionsUC::getOption(self::LAYOUTS_GLOBAL_SETTINGS_OPTION, array());
        return $arrValues;
    }
    public static function getGlobalSettingsObject($includeGlobalOptions = true)
    {
        $filepathSettings = GlobalsUC::$pathSettings . "layouts_global_settings.xml";
        $objSettings = new UniteCreatorSettings();
        $objSettings->loadXMLFile($filepathSettings);
        if ($includeGlobalOptions == true) {
            $arrValues = self::getGridGlobalStoredValues();
            if (!empty($arrValues)) {
                $objSettings->setStoredValues($arrValues);
            }
        }
        return $objSettings;
    }
    public static function getLayoutGlobalSettingsValues()
    {
        $objSettings = self::getGlobalSettingsObject(true);
        $arrValues = $objSettings->getArrValues();
        return $arrValues;
    }
    public static function getGridSettingsObject()
    {
        $filepathSettings = GlobalsUC::$pathSettings . "layouts_grid_settings.xml";
        $objSettings = new UniteCreatorSettings();
        $objSettings->loadXMLFile($filepathSettings);
        return $objSettings;
    }
    public function getPageParamsSettingsObject()
    {
        switch ($this->objLayoutType->paramsSettingsType) {
            case UniteCreatorAddonType_Layout::LAYOUT_PARAMS_TYPE_SCREENSHOT:
                $filepathSettings = GlobalsUC::$pathSettings . "layout_grid_settings_screenshot.xml";
                break;
            default:
                UniteFunctionsUC::throwError("Wrong page params type: " . $this->objLayoutType->paramsSettingsType);
                break;
        }
        $objSettings = new UniteCreatorSettings();
        $objSettings->loadXMLFile($filepathSettings);
        $objSettings = UniteProviderFunctionsUC::applyFilters(UniteCreatorFilters::FILTER_LAYOUT_PROPERTIES_SETTINGS, $objSettings);
        $objSettings->setStoredValues($this->params);
        return $objSettings;
    }
    public function getPageParamsValuesWithDefaults()
    {
        $this->validateInited();
        $paramsType = $this->objLayoutType->paramsSettingsType;
        if (empty($paramsType)) {
            return $this->params;
        }
        $objSettings = $this->getPageParamsSettingsObject();
        $arrValues = $objSettings->getArrValues();
        if (is_array($this->params)) {
            $arrValues = array_merge($arrValues, $this->params);
        }
        return $arrValues;
    }
    public static function updateLayoutGlobalSettingsFromData($data)
    {
        $arrValues = UniteFunctionsUC::getVal($data, "settings_values");
        UniteProviderFunctionsUC::updateOption(self::LAYOUTS_GLOBAL_SETTINGS_OPTION, $arrValues);
    }
    public function initByName($name, $type)
    {
        $objType = UniteCreatorAddonType::getAddonTypeObject($type, true);
        $name = $this->db->escape($name);
        $sqlAddonType = $this->db->getSqlAddonType($type, "layout_type");
        $where = "name='{$name}' and {$sqlAddonType}";
        try {
            $record = $this->db->fetchSingle(GlobalsUC::$table_layouts, $where);
        } catch (Exception $e) {
            UniteFunctionsUC::throwError("Layout with name: {$name} not found");
        }
        UniteFunctionsUC::validateNotEmpty($record, "layout record");
        $this->initByRecord($record);
    }
    public function initByID($id)
    {
        $id = (int) $id;
        if (empty($id)) {
            UniteFunctionsUC::throwError("Empty layout ID");
        }
        $options = array();
        $options["tableName"] = GlobalsUC::$table_layouts;
        $options["where"] = "id=" . $id;
        $options["errorEmpty"] = "layout with id: {$id} not found";
        $record = $this->db->fetchSingle($options);
        $this->id = $id;
        $this->initByRecord($record);
    }
    private function a____________GET_OPTIONS_____________()
    {
    }
    public static function getGridGlobalOptions()
    {
        $settings = self::getGlobalSettingsObject();
        $arrValues = $settings->getArrValues();
        return $arrValues;
    }
    public static function getGridSettingsOptions($arrInitValues = array())
    {
        $objSettings = self::getGridSettingsObject();
        if (!empty($arrInitValues)) {
            $objSettings->setStoredValues($arrInitValues);
        }
        $arrValues = $objSettings->getArrValues();
        return $arrValues;
    }
    public static function getGridDefaultOptions()
    {
        $objGlobalSettings = self::getGlobalSettingsObject(false);
        $arrValuesGrid = self::getGridSettingsOptions();
        $arrValuesGlobal = $objGlobalSettings->getArrValues();
        $arrMerged = array_merge($arrValuesGlobal, $arrValuesGrid);
        return $arrMerged;
    }
    public function getAllGridOptions()
    {
        $this->validateInited();
        if (!empty($this->arrAllOptionsCache)) {
            return $this->arrAllOptionsCache;
        }
        $globalOptions = self::getGridGlobalOptions();
        $layoutOptions = UniteFunctionsUC::getVal($this->gridData, "options", array());
        if (empty($layoutOptions) || is_array($layoutOptions) == false) {
            $layoutOptions = array();
        }
        $allOptions = array_merge($globalOptions, $layoutOptions);
        $this->arrAllOptionsCache = $allOptions;
        return $allOptions;
    }
    public function getExtraParams()
    {
        return $this->extraParams;
    }
    private function a______________DATA_RELATED_______________()
    {
    }
    protected function modifyInitLayoutData($gridData)
    {
        if (empty($gridData)) {
            return $gridData;
        }
        $rows = UniteFunctionsUC::getVal($gridData, "rows");
        if (empty($rows)) {
            return $gridData;
        }
        foreach ($rows as $keyRow => $row) {
            $cols = UniteFunctionsUC::getVal($row, "cols");
            if (empty($cols)) {
                continue;
            }
            $arrContainer = array();
            $arrContainer["cols"] = $cols;
            $row["containers"] = array($arrContainer);
            unset($row["cols"]);
            $gridData["rows"][$keyRow] = $row;
        }
        return $gridData;
    }
    protected function generateName($title = "", $layoutType = null, $baseName = null)
    {
        if (empty($title)) {
            $title = $this->title;
        }
        UniteFunctionsUC::validateNotEmpty($title);
        if (empty($layoutType)) {
            $this->objLayouts->validateLayoutType($this->layoutType);
            $layoutType = $this->layoutType;
        }
        $alias = HelperUC::convertTitleToAlias($title);
        if (!empty($baseName)) {
            $alias = $baseName . "-" . $alias;
        }
        $isExists = $this->isLayoutExistsByName($alias, $layoutType);
        if ($isExists == true) {
            $alias .= "-" . UniteFunctionsUC::getRandomString(5);
        }
        return $alias;
    }
    public function initByRecord($record)
    {
        $this->title = UniteFunctionsUC::getVal($record, "title");
        $this->name = UniteFunctionsUC::getVal($record, "name");
        if (empty($this->id)) {
            $this->id = UniteFunctionsUC::getVal($record, "id");
        }
        $this->ordering = UniteFunctionsUC::getVal($record, "ordering");
        $this->layoutType = UniteFunctionsUC::getVal($record, "layout_type");
        if (empty($this->name)) {
            $this->name = $this->generateName(null, $this->layoutType);
        }
        $this->objLayoutType = UniteCreatorAddonType::getAddonTypeObject($this->layoutType, true);
        $this->isTemplate = $this->objLayoutType->isTemplate;
        $data = UniteFunctionsUC::getVal($record, "layout_data");
        $data = UniteFunctionsUC::maybeUnserialize($data);
        $this->record = $record;
        $this->data = $data;
        $params = UniteFunctionsUC::getVal($record, "params");
        if (!empty($params)) {
            $this->params = UniteFunctionsUC::jsonDecode($params);
        }
        if (empty($this->params)) {
            $this->params = array();
        }
        $gridData = UniteFunctionsUC::getVal($data, "grid_data");
        $gridData = $this->modifyInitLayoutData($gridData);
        $this->gridData = $gridData;
    }
    private function getAddonObject($name, $addontype = null)
    {
        if (empty($addontype)) {
            $addontype = $this->addonType;
        }
        $cacheName = $name;
        if (!empty($addontype)) {
            $cacheName = $name . "_" . $addontype;
        }
        if (isset(self::$arrCacheAddons[$cacheName])) {
            return self::$arrCacheAddons[$cacheName];
        }
        try {
            $addon = new UniteCreatorAddon();
            if (empty($addontype)) {
                $addon->initByName($name);
            } else {
                $addon->initByAlias($name, $addontype);
            }
            self::$arrCacheAddons[$cacheName] = $addon;
            return $addon;
        } catch (Exception $e) {
            return null;
        }
    }
    private function getAddonExtraData($name, $addon = null, $addontype = "")
    {
        if (empty($addon)) {
            $addon = $this->getAddonObject($name, $addontype);
        }
        if (empty($addon)) {
            return null;
        }
        $arrExtraData = array();
        $arrExtraData["id"] = $addon->getID();
        $arrExtraData["title"] = $addon->getTitle();
        $arrExtraData["url_icon"] = $addon->getUrlIcon();
        $arrExtraData["admin_labels"] = $addon->getAdminLabels();
        return $arrExtraData;
    }
    private function modifyAddonDataForEditor($addonData)
    {
        try {
            $objAddons = new UniteCreatorAddons();
            $objAddon = $objAddons->prepareAddonByData($addonData);
            $arrConfig = $objAddon->getProcessedMainParamsValues(UniteCreatorParamsProcessor::PROCESS_TYPE_CONFIG);
            $origConfig = UniteFunctionsUC::getVal($addonData, "config");
            if (empty($origConfig)) {
                $origConfig = array();
            }
            $addonData["config"] = array_merge($origConfig, $arrConfig);
            if ($objAddon->isHasItems()) {
                $arrItems = $objAddon->getProcessedItemsData(UniteCreatorParamsProcessor::PROCESS_TYPE_CONFIG, false);
                $addonData["items"] = $arrItems;
            }
            return $addonData;
        } catch (Exception $e) {
            return $addonData;
        }
    }
    protected function createGridDataFull_modifySettingsImage($settings, $key)
    {
        $value = UniteFunctionsUC::getVal($settings, $key);
        if (empty($value)) {
            return $settings;
        }
        if (is_numeric($value) == false) {
            return $settings;
        }
        $urlImage = UniteProviderFunctionsUC::getImageUrlFromImageID($value);
        if (empty($urlImage)) {
            return $settings;
        }
        $settings[$key] = $urlImage;
        $settings[$key . "_imageid"] = $value;
        return $settings;
    }
    private function createGridDataFull_modifySettingsShapes($settings)
    {
        if (empty($settings)) {
            return $settings;
        }
        $arr = array("top", "bottom");
        foreach ($arr as $pos) {
            if (array_key_exists("enable_shape_devider_{$pos}", $settings) == false) {
                continue;
            }
            if ($settings["enable_shape_devider_{$pos}"] === true) {
                continue;
            }
            unset($settings["enable_shape_devider_{$pos}"]);
            foreach ($settings as $key => $value) {
                if (strpos($key, "shape_devider_{$pos}_") === 0) {
                    unset($settings[$key]);
                }
            }
        }
        return $settings;
    }
    protected function createGridDataFull_modifySettingsBGAddons($settings, $addParams)
    {
        $settingsKey = "bg_addon_single";
        $bgAddonName = UniteFunctionsUC::getVal($settings, $settingsKey);
        if (empty($bgAddonName)) {
            return $settings;
        }
        $addonData = UniteFunctionsUC::getVal($settings, $settingsKey . "_data");
        if (empty($addonData)) {
            $addonData = array();
            $addonData["name"] = $bgAddonName;
            $addonData["addontype"] = GlobalsUC::ADDON_TYPE_BGADDON;
        }
        $addonData = $this->createGridDataFull_modifyAddonData($addonData, $addParams);
        $settings[$settingsKey . "_data"] = $addonData;
        return $settings;
    }
    protected function createGridDataFull_modifySettings($settings, $name, $addParams = null)
    {
        $settings = $this->createGridDataFull_modifySettingsImage($settings, "bg_image_url");
        $settings = $this->createGridDataFull_modifySettingsShapes($settings);
        $settings = $this->createGridDataFull_modifySettingsBGAddons($settings, $addParams);
        return $settings;
    }
    private function createGridDataFull_modifyAddonData($addonData, $addParams = null)
    {
        if (empty($addonData)) {
            return $addonData;
        }
        $addonData = $this->modifyAddonDataForEditor($addonData);
        $addonName = UniteFunctionsUC::getVal($addonData, "name");
        $addonType = UniteFunctionsUC::getVal($addonData, "addontype");
        if (empty($addonName)) {
            return $addonData;
        }
        $addonExtraData = $this->getAddonExtraData($addonName, null, $addonType);
        if (empty($addonExtraData)) {
            $addonExtraData = array();
            $addonExtraData["missing"] = true;
        }
        $addonData["extra"] = $addonExtraData;
        $isAddContent = UniteFunctionsUC::getVal($addParams, "add_addon_content");
        $isAddContent = UniteFunctionsUC::strToBool($isAddContent);
        if ($isAddContent == true) {
            $addons = new UniteCreatorAddons();
            $addonData["output"] = $addons->getLayoutAddonOutputData($addonData);
        }
        return $addonData;
    }
    private function createGridDataFull($addAddonContent = false)
    {
        if (!empty($this->gridDataFull)) {
            return $this->gridDataFull;
        }
        $addParams = array();
        $addParams["add_addon_content"] = $addAddonContent;
        $this->gridDataFull = $this->mapModifyLayoutDataAddons($this->gridData, "createGridDataFull_modifyAddonData", $addParams);
        $this->gridDataFull = $this->mapModifyLayoutDataSettings($this->gridDataFull, array($this, "createGridDataFull_modifySettings"), $addParams);
        return $this->gridDataFull;
    }
    public function modifyAddonDataForSave($data)
    {
        $name = UniteFunctionsUC::getVal($data, "name");
        $addonType = UniteFunctionsUC::getVal($data, "addontype");
        try {
            unset($data["url_icon"]);
            unset($data["title"]);
            unset($data["extra"]);
            unset($data["output"]);
            $config = UniteFunctionsUC::getVal($data, "config");
            $items = UniteFunctionsUC::getVal($data, "items");
            $addon = new UniteCreatorAddon();
            if (empty($addonType)) {
                $addon->initByName($name);
            } else {
                $addon->initByAlias($name, $addonType);
            }
            $addon->setParamsValues($config);
            if (!empty($items)) {
                $addon->setArrItems($items);
            }
            if (!empty($config)) {
                $arrImages = $addon->getProcessedMainParamsImages();
                if (!empty($arrImages)) {
                    $arrImages = $addon->modifyDataConvertToUrlAssets($arrImages);
                    $data["config"] = array_merge($config, $arrImages);
                }
            }
            if (!empty($items) && is_array($items)) {
                $arrItemsImages = $addon->getProcessedItemsData(UniteCreatorParamsProcessor::PROCESS_TYPE_SAVE, false, "uc_image");
                foreach ($arrItemsImages as $key => $itemImage) {
                    $itemImage = $addon->modifyDataConvertToUrlAssets($itemImage);
                    if (!empty($itemImage)) {
                        $items[$key] = array_merge($items[$key], $itemImage);
                    }
                }
                $data["items"] = $items;
            }
        } catch (Exception $e) {
            return $data;
        }
        return $data;
    }
    private function prepareDataForSave($gridData)
    {
        $data = array();
        if (is_string($gridData)) {
            $gridData = UniteFunctionsUC::decodeContent($gridData);
            $gridData = $this->modifyGridDataForSave($gridData);
            $data["grid_data"] = $gridData;
        } else {
            $data["grid_data"] = $gridData;
        }
        $data = serialize($data);
        return $data;
    }
    private function a______MAPPING_______()
    {
    }
    private function mapModifyLayoutDataSettings_columns($parent, $modifyFunc, $addParams = null)
    {
        $cols = UniteFunctionsUC::getVal($parent, "cols");
        if (empty($cols)) {
            return $parent;
        }
        foreach ($cols as $colIndex => $col) {
            $colSettings = UniteFunctionsUC::getVal($col, "settings");
            if (!empty($colSettings)) {
                $parent["cols"][$colIndex]["settings"] = call_user_func($modifyFunc, $colSettings, "col", $addParams);
            }
            $addonData = UniteFunctionsUC::getVal($col, "addon_data");
            if (empty($addonData)) {
                continue;
            }
            foreach ($addonData as $addonIndex => $addon) {
                $addonOptions = UniteFunctionsUC::getVal($addon, "options");
                if (empty($addonOptions)) {
                    continue;
                }
                $parent["cols"][$colIndex]["addon_data"][$addonIndex]["options"] = call_user_func($modifyFunc, $addonOptions, "addon", $addParams);
            }
        }
        return $parent;
    }
    private function checkSettingsAddData($arrElement, $keyOptions)
    {
        return $arrElement;
    }
    public function mapModifyLayoutDataSettings($arrData, $modifyFunc, $addParams = null)
    {
        $gridSettings = UniteFunctionsUC::getVal($arrData, "options");
        if (!empty($gridSettings)) {
            $arrData["options"] = call_user_func($modifyFunc, $gridSettings, "grid", $addParams);
        }
        $rows = UniteFunctionsUC::getVal($arrData, "rows");
        if (empty($rows)) {
            return false;
        }
        foreach ($rows as $rowIndex => $row) {
            $rowSettings = UniteFunctionsUC::getVal($row, "settings");
            if (!empty($rowSettings)) {
                $arrData["rows"][$rowIndex]["settings"] = call_user_func($modifyFunc, $rowSettings, "row", $addParams);
            }
            $arrContainers = UniteFunctionsUC::getVal($row, "containers");
            if (!empty($arrContainers)) {
                foreach ($arrContainers as $containerIndex => $container) {
                    $containerSettings = UniteFunctionsUC::getVal($container, "settings");
                    if (!empty($containerSettings)) {
                        $arrContainer = $arrData["rows"][$rowIndex]["containers"][$containerIndex];
                        $arrContainer["settings"] = call_user_func($modifyFunc, $containerSettings, "container", $addParams);
                        $arrData["rows"][$rowIndex]["containers"][$containerIndex] = $arrContainer;
                    }
                    $arrData["rows"][$rowIndex]["containers"][$containerIndex] = $this->mapModifyLayoutDataSettings_columns($container, $modifyFunc, $addParams);
                }
            } else {
                $arrData["rows"][$rowIndex] = $this->mapModifyLayoutDataSettings_columns($row, $modifyFunc, $addParams);
            }
        }
        return $arrData;
    }
    private function mapModifyLayoutDataAddons_columns($arrParent, $modifyFunc, $addParams = null)
    {
        $cols = UniteFunctionsUC::getVal($arrParent, "cols");
        if (empty($cols)) {
            return $arrParent;
        }
        foreach ($cols as $keyCol => $col) {
            $addonData = UniteFunctionsUC::getVal($col, "addon_data");
            if (isset($addonData["config"])) {
                $addonData = array($addonData);
            }
            if (empty($addonData)) {
                $addonData = array();
            }
            foreach ($addonData as $keyAddon => $addon) {
                if (is_array($modifyFunc)) {
                    $addon = call_user_func($modifyFunc, $addon);
                } else {
                    $addon = call_user_func(array($this, $modifyFunc), $addon, $addParams);
                }
                if (!empty($addon)) {
                    $addonData[$keyAddon] = $addon;
                } else {
                    unset($addonData[$keyAddon]);
                }
            }
            $col["addon_data"] = $addonData;
            $cols[$keyCol] = $col;
        }
        $arrParent["cols"] = $cols;
        return $arrParent;
    }
    public function mapModifyLayoutDataAddons($arrData, $modifyFunc, $addParams = null)
    {
        $rows = UniteFunctionsUC::getVal($arrData, "rows");
        if (empty($rows)) {
            return $arrData;
        }
        foreach ($rows as $keyRow => $row) {
            $containers = UniteFunctionsUC::getVal($row, "containers");
            if (!empty($containers)) {
                foreach ($containers as $keyContainer => $container) {
                    $row["containers"][$keyContainer] = $this->mapModifyLayoutDataAddons_columns($container, $modifyFunc, $addParams);
                }
            } else {
                $row = $this->mapModifyLayoutDataAddons_columns($row, $modifyFunc, $addParams);
            }
            $rows[$keyRow] = $row;
        }
        $arrData["rows"] = $rows;
        return $arrData;
    }
    public function mapModifyLayoutDataAll($arrData, $modifyFunc)
    {
        if (is_array($arrData)) {
            $arrData = call_user_func($modifyFunc, $arrData);
            foreach ($arrData as $index => $item) {
                if (is_array($item)) {
                    $item = call_user_func($modifyFunc, $item);
                    $arrData[$index] = $this->mapModifyLayoutDataAll($item, $modifyFunc);
                }
            }
        }
        return $arrData;
    }
    public function modifyParams($modifyFunc)
    {
        $this->params = call_user_func($modifyFunc, $this->params);
    }
    private function a_____________EXTERNAL_GETTERS____________()
    {
    }
    public function getGridDataForEditor($addAddonContent = false)
    {
        $this->validateInited();
        try {
            if (empty($this->gridDataFull)) {
                $this->createGridDataFull($addAddonContent);
            }
        } catch (Exception $e) {
            HelperHtmlUC::outputException($e);
            return $this->gridData;
        }
        return $this->gridDataFull;
    }
    public function getRowsFront()
    {
        $this->validateInited();
        $rows = UniteFunctionsUC::getVal($this->gridData, "rows");
        if (empty($rows)) {
            $rows = array();
        }
        return $rows;
    }
    public function getGridOptionsDiff()
    {
        $defaultOptions = self::getGridDefaultOptions();
        $allOptions = $this->getAllGridOptions();
        $arrDiffOptions = UniteFunctionsUC::getDiffArrItems($allOptions, $defaultOptions);
        return $arrDiffOptions;
    }
    public function getTitle($specialChars = false)
    {
        if ($specialChars == true) {
            return htmlspecialchars($this->title);
        } else {
            return $this->title;
        }
    }
    public function getName()
    {
        $this->validateInited();
        return $this->name;
    }
    public function getDescription($specialChars = false)
    {
        $this->validateInited();
        $description = UniteFunctionsUC::getVal($this->params, "description");
        if ($specialChars == true) {
            $description = htmlspecialchars($description);
        }
        return $description;
    }
    public function getIcon()
    {
        $this->validateInited();
        $icon = UniteFunctionsUC::getVal($this->params, "page_icon");
        return $icon;
    }
    public function getPreviewImage($getThumb = false)
    {
        $this->validateInited();
        $params = $this->getPageParamsValuesWithDefaults();
        $arrImageKeys = array("preview_image", "custom_preview_image", "page_image");
        foreach ($arrImageKeys as $key) {
            $urlPreview = UniteFunctionsUC::getVal($params, $key);
            $urlPreview = trim($urlPreview);
            if (empty($urlPreview)) {
                continue;
            }
            if (is_numeric($urlPreview)) {
                $urlPreview = UniteProviderFunctionsUC::getImageUrlFromImageID($urlPreview);
            }
            $urlPreview = HelperUC::URLtoFull($urlPreview);
            return $urlPreview;
        }
        return $urlPreview;
    }
    public function getPreviewImageFilepath()
    {
        $urlPreview = $this->getPreviewImage();
        if (empty($urlPreview)) {
            return null;
        }
        $pathImage = HelperUC::urlToPath($urlPreview);
        if (empty($pathImage)) {
            return null;
        }
        return $pathImage;
    }
    public function getID()
    {
        $this->validateInited();
        return $this->id;
    }
    public function getParentID()
    {
        dmp("getParentID - function for override");
        exit;
    }
    public function getLayoutType()
    {
        return $this->layoutType;
    }
    public function getObjLayoutType()
    {
        if (!empty($this->objLayoutType)) {
            return $this->objLayoutType;
        }
        if ($this->isInited() == true) {
            UniteFunctionsUC::throwError("The layout type should be inited");
        }
        $this->objLayoutType = UniteCreatorAddonType::getAddonTypeObject(GlobalsUC::ADDON_TYPE_REGULAR_LAYOUT, true);
        return $this->objLayoutType;
    }
    public function getCatNameForExport()
    {
        $arrCat = $this->getCategory();
        $catName = UniteFunctionsUC::getVal($arrCat, "name");
        if (empty($catName)) {
            return false;
        }
        $objLayoutType = $this->getObjLayoutType();
        $typeName = $objLayoutType->typeNameDistinct;
        $prefix = "";
        if ($typeName != GlobalsUC::ADDON_TYPE_REGULAR_LAYOUT) {
            $prefix = self::EXPORT_CAT_TYPE_PREFIX . $typeName . "___";
        }
        if (!empty($prefix)) {
            $catName = $prefix . $catName;
        }
        return $catName;
    }
    public function getCategory()
    {
        $this->validateInited();
        $category_info = array("layoutid" => $this->getID());
        $objCats = new UniteCreatorCategories();
        $catID = UniteFunctionsUC::getVal($this->record, "catid");
        if (empty($catID)) {
            $category_info["name"] = "Uncategorized";
            $category_info["id"] = 0;
        } else {
            $cat = $objCats->getCat($catID);
            $category_info["name"] = $cat["title"];
            $category_info["id"] = $cat["id"];
        }
        return $category_info;
    }
    public function getCategoryName()
    {
        $objCat = $this->getCategory();
        $catName = $objCat["name"];
        return $catName;
    }
    public function getRecord()
    {
        return $this->record;
    }
    public function getShortcode($shortcodeName = "")
    {
        $title = $this->getTitle(true);
        $id = $this->id;
        if (empty($shortcodeName)) {
            $shortcodeName = GlobalsUC::$layoutShortcodeName;
        }
        $shortcode = $shortcodeName . " id={$id} title=\"{$title}\"";
        $shortcode = UniteProviderFunctionsUC::wrapShortcode($shortcode);
        return $shortcode;
    }
    public function getAddonType()
    {
        return $this->addonType;
    }
    public function getRawLayoutData()
    {
        $this->validateInited();
        $strLayoutData = $this->record["layout_data"];
        return $strLayoutData;
    }
    public function getShortData()
    {
        $this->validateInited();
        $data = array();
        $data["title"] = $this->getTitle();
        $data["name"] = $this->getName();
        $data["description"] = $this->getDescription();
        $data["url_icon"] = $this->getIcon();
        $data["preview"] = $this->getPreviewImage();
        $data["id"] = $this->getID();
        $data["is_active"] = true;
        return $data;
    }
    protected function isLayoutExistsByTitle($title, $layoutType)
    {
        $title = $this->db->escape($title);
        $sqlType = $this->db->getSqlAddonType($layoutType, "layout_type");
        $response = $this->db->fetch(GlobalsUC::$table_layouts, "title='{$title}' and {$sqlType}");
        $isExists = !empty($response);
        return $isExists;
    }
    protected function isLayoutExistsByName($name, $layoutType)
    {
        $title = $this->db->escape($name);
        $sqlType = $this->db->getSqlAddonType($layoutType, "layout_type");
        $where = "name='{$name}' and {$sqlType}";
        if (!empty($this->id)) {
            $where .= " and id <> " . $this->id;
        }
        $response = $this->db->fetch(GlobalsUC::$table_layouts, $where);
        $isExists = !empty($response);
        return $isExists;
    }
    public function getNewLayoutTitle()
    {
        $titleBase = $this->objLayoutType->textSingle;
        $counter = 1;
        do {
            $title = $titleBase . $counter;
            $found = $this->isLayoutExistsByTitle($title, $this->layoutType);
            $counter++;
        } while ($found == true);
        return $title;
    }
    private function collectAddonSpecialAddons_params($paramsShapes, $config, $addonType)
    {
        foreach ($paramsShapes as $param) {
            $paramName = UniteFunctionsUC::getVal($param, "name");
            $shapeName = UniteFunctionsUC::getVal($config, $paramName);
            if (empty($shapeName)) {
                continue;
            }
            $shapeAddonName = $shapeName . "_" . $addonType;
            $this->arrAddonNames[$shapeAddonName] = null;
        }
    }
    private function getParamsShapesFromAddon($objAddon, $isItems = false)
    {
        if ($isItems == false) {
            $paramsShapes = $objAddon->getParams(UniteCreatorDialogParam::PARAM_SHAPE);
        } else {
            $paramsShapes = $objAddon->getParamsItems(UniteCreatorDialogParam::PARAM_SHAPE);
        }
        if (empty($paramsShapes)) {
            $paramsShapes = array();
        }
        if ($isItems == false) {
            $paramsAddonPickers = $objAddon->getParams(UniteCreatorDialogParam::PARAM_ADDONPICKER);
        } else {
            $paramsAddonPickers = $objAddon->getParamsItems(UniteCreatorDialogParam::PARAM_ADDONPICKER);
        }
        if (empty($paramsAddonPickers)) {
            return $paramsShapes;
        }
        foreach ($paramsAddonPickers as $param) {
            $addonType = UniteFunctionsUC::getVal($param, "addon_type");
            if ($addonType == GlobalsUC::ADDON_TYPE_SHAPES) {
                $paramsShapes[] = $param;
            }
        }
        return $paramsShapes;
    }
    private function collectAddonSpecialAddons($addonName, $addonData)
    {
        $objAddon = new UniteCreatorAddon();
        $objAddon->initByName($addonName);
        $paramsShapes = $this->getParamsShapesFromAddon($objAddon);
        if (!empty($paramsShapes)) {
            $config = UniteFunctionsUC::getVal($addonData, "config");
            $this->collectAddonSpecialAddons_params($paramsShapes, $config, GlobalsUC::ADDON_TYPE_SHAPES);
        }
        $hasItems = $objAddon->isHasItems();
        if ($hasItems == false) {
            return false;
        }
        $paramsItemsShapes = $this->getParamsShapesFromAddon($objAddon);
        if (empty($paramsItemsShapes)) {
            return false;
        }
        $arrItems = UniteFunctionsUC::getVal($addonData, "items");
        if (empty($arrItems) || is_array($arrItems) == false) {
            return false;
        }
        foreach ($arrItems as $item) {
            $this->collectAddonSpecialAddons_params($paramsItemsShapes, $item, GlobalsUC::ADDON_TYPE_SHAPES);
        }
    }
    private function modifyAddons_collectAddonNames($addonData)
    {
        $name = UniteFunctionsUC::getVal($addonData, "name");
        $this->arrAddonNames[$name] = null;
        $this->collectAddonSpecialAddons($name, $addonData);
        return null;
    }
    public function getRowSettingsCombined($row)
    {
        $settings = UniteFunctionsUC::getVal($row, "settings");
        $allOptions = $this->getAllGridOptions();
        if (empty($allOptions)) {
            return $settings;
        }
        if (empty($settings)) {
            return $allOptions;
        }
        foreach ($settings as $key => $value) {
            if ($value !== "") {
                continue;
            }
            $globalValue = UniteFunctionsUC::getVal($allOptions, $key);
            if ($globalValue !== "") {
                $settings[$key] = $globalValue;
            }
        }
        foreach ($allOptions as $key => $value) {
            $localValue = UniteFunctionsUC::getVal($settings, $key);
            if ($localValue !== "") {
                $value = $localValue;
            }
            $settings[$key] = $value;
        }
        return $settings;
    }
    public function getInfoText()
    {
        $textEmpty = esc_html__("empty layout", "unlimited-elements-for-elementor");
        if (empty($this->id)) {
            return $textEmpty;
        }
        $rows = UniteFunctionsUC::getVal($this->gridData, "rows");
        if (empty($rows)) {
            return $textEmpty;
        }
        if (is_array($rows) == false) {
            return $textEmpty;
        }
        $numRows = count($rows);
        $text = esc_html__("layout with", "unlimited-elements-for-elementor") . " " . $numRows . " " . __("sections", "unlimited-elements-for-elementor");
        return $text;
    }
    public function getRows()
    {
        $this->validateInited();
        $rows = UniteFunctionsUC::getVal($this->gridData, "rows");
        if (empty($rows)) {
            $rows = array();
        }
        return $rows;
    }
    public function getParams()
    {
        return $this->params;
    }
    public function getParam($paramName)
    {
        $value = UniteFunctionsUC::getVal($this->params, $paramName);
        return $value;
    }
    public function getUrlEditPost()
    {
        dmp("getUrlEditPost function for override");
        exit;
    }
    public function getUrlViewPost()
    {
        dmp("getUrlViewPost function for override");
        exit;
    }
    private function a_______________EXPORT_RELATED_____________()
    {
    }
    public function modifyLayoutElementsSettings($modifyFunc)
    {
        $this->validateInited();
        if (is_array($modifyFunc) == false) {
            UniteFunctionsUC::throwError("Wrong modify func");
        }
        $this->gridData = $this->mapModifyLayoutDataSettings($this->gridData, $modifyFunc);
    }
    public function modifyGridDataAddons($modifyFunc)
    {
        $this->validateInited();
        if (is_array($modifyFunc) == false) {
            UniteFunctionsUC::throwError("Wrong modify func");
        }
        $this->gridData = $this->mapModifyLayoutDataAddons($this->gridData, $modifyFunc);
    }
    private function getBGAddonNameFromSettings($settings)
    {
        $enableBackground = UniteFunctionsUC::getVal($settings, "bg_enable");
        $enableBackground = UniteFunctionsUC::strToBool($enableBackground);
        if ($enableBackground == false) {
            return null;
        }
        $bgAddonKey = "bg_addon_single";
        $bgAddonEnableKey = $bgAddonKey . "_enable";
        $enableBGAddon = UniteFunctionsUC::getVal($settings, $bgAddonEnableKey);
        $enableBGAddon = UniteFunctionsUC::strToBool($enableBGAddon);
        if ($enableBGAddon == false) {
            return null;
        }
        $bgAddonName = UniteFunctionsUC::getVal($settings, $bgAddonKey);
        if (empty($bgAddonName)) {
            return null;
        }
        return $bgAddonName;
    }
    public function modifySettings_collectSpecialAddonNames($settings, $elementType)
    {
        $nameTop = $this->objShapes->getShapeDividerNameFromSettings($settings, "top");
        if (!empty($nameTop)) {
            $this->arrAddonNames[$nameTop . "_" . GlobalsUC::ADDON_TYPE_SHAPE_DEVIDER] = GlobalsUC::ADDON_TYPE_SHAPE_DEVIDER;
        }
        $nameBottom = $this->objShapes->getShapeDividerNameFromSettings($settings, "bottom");
        if (!empty($nameBottom)) {
            $this->arrAddonNames[$nameBottom . "_" . GlobalsUC::ADDON_TYPE_SHAPE_DEVIDER] = GlobalsUC::ADDON_TYPE_SHAPE_DEVIDER;
        }
        $bgAddonName = $this->getBGAddonNameFromSettings($settings);
        if (!empty($bgAddonName)) {
            $this->arrAddonNames[$bgAddonName] = GlobalsUC::ADDON_TYPE_BGADDON;
        }
    }
    private function getErrorMessagePrefix()
    {
        $title = $this->getTitle(true);
        $prefix = esc_html__("Error in ", "unlimited-elements-for-elementor") . $title . " :";
        return $prefix;
    }
    public function getArrAddons()
    {
        $this->validateInited();
        $this->arrAddonNames = array();
        $this->mapModifyLayoutDataAddons($this->gridData, "modifyAddons_collectAddonNames");
        $this->mapModifyLayoutDataSettings($this->gridData, array($this, "modifySettings_collectSpecialAddonNames"));
        $arrAddons = array();
        foreach ($this->arrAddonNames as $name => $type) {
            try {
                $objAddon = new UniteCreatorAddon();
                switch ($type) {
                    case GlobalsUC::ADDON_TYPE_BGADDON:
                        $objAddon->initByAlias($name, $type);
                        break;
                    default:
                        $objAddon->initByMixed($name, $this->addonType);
                        break;
                }
                $arrAddons[] = $objAddon;
            } catch (Exception $e) {
                if ($type != GlobalsUC::ADDON_TYPE_SHAPE_DEVIDER) {
                    $message = $this->getErrorMessagePrefix();
                    $message .= $e->getMessage();
                    dmp($message);
                    UniteFunctionsUC::throwError($message);
                }
            }
        }
        return $arrAddons;
    }
    public function cleanLayoutDataBeforeExport($arrData)
    {
        if (is_array($arrData) == false) {
            return $arrData;
        }
        $arrDataNew = array();
        foreach ($arrData as $key => $item) {
            if (strpos($key, "_unite_selected_text") !== false) {
                continue;
            }
            $arrDataNew[$key] = $item;
        }
        return $arrDataNew;
    }
    public function cleanLayoutSettingsBeforeExport()
    {
        $cleanFunc = array($this, "cleanLayoutDataBeforeExport");
        $this->gridData = $this->mapModifyLayoutDataAll($this->gridData, $cleanFunc);
        $this->modifyParams($cleanFunc);
    }
    public function getRecordForExport()
    {
        $this->validateInited();
        $record = array();
        $record["title"] = $this->title;
        $record["name"] = $this->name;
        $record["type"] = $this->layoutType;
        $catName = $this->getCategoryName();
        if (!empty($catName)) {
            $record["catname"] = $catName;
        }
        $gridData = $this->modifyGridDataForSave($this->gridData);
        $record["params"] = $this->modifyParamsForSave($this->params);
        $this->data["grid_data"] = $gridData;
        $layoutData = serialize($this->data);
        $record["layout_data"] = $layoutData;
        return $record;
    }
    private function a________________MODIFY_FOR_SAVE____________()
    {
    }
    public function modifyGridDataForSave_containers($gridData)
    {
        $arrRows = UniteFunctionsUC::getVal($gridData, "rows");
        if (empty($arrRows)) {
            return $gridData;
        }
        foreach ($arrRows as $index => $row) {
            $arrContainers = UniteFunctionsUC::getVal($row, "containers");
            if (empty($arrContainers)) {
                continue;
            }
            if (count($arrContainers) > 1) {
                continue;
            }
            $container = $arrContainers[0];
            $settings = UniteFunctionsUC::getVal($container, "settings");
            if (!empty($settings)) {
                continue;
            }
            $cols = UniteFunctionsUC::getVal($container, "cols");
            $row["cols"] = $cols;
            unset($row["containers"]);
            $arrRows[$index] = $row;
        }
        $gridData["rows"] = $arrRows;
        return $gridData;
    }
    public function modifyLayoutDataForSave($arrSettings, $type)
    {
        if (isset($arrSettings["bg_image_url_url"])) {
            unset($arrSettings["bg_image_url_url"]);
        }
        $bgAddonSingleData = UniteFunctionsUC::getVal($arrSettings, "bg_addon_single_data");
        if (!empty($bgAddonSingleData)) {
            $arrSettings["bg_addon_single_data"] = $this->modifyAddonDataForSave($bgAddonSingleData);
        }
        return $arrSettings;
    }
    public function modifyGridDataForSave($gridData)
    {
        $gridData = $this->mapModifyLayoutDataSettings($gridData, array($this, "modifyLayoutDataForSave"));
        $gridData = $this->mapModifyLayoutDataAddons($gridData, "modifyAddonDataForSave");
        $gridData = $this->modifyGridDataForSave_containers($gridData);
        return $gridData;
    }
    protected function modifyParamsImagesForSave($params, $arrImageNames)
    {
        foreach ($arrImageNames as $name) {
            $unsetName = $name . "_url";
            if (isset($params[$unsetName])) {
                unset($params[$unsetName]);
            }
        }
        return $params;
    }
    public function modifyParamsForSave($params)
    {
        $arrImagesNames = array("preview_image", "custom_preview_image", "page_image");
        $params = $this->modifyParamsImagesForSave($params, $arrImagesNames);
        return $params;
    }
    private function a_____________EXTERNAL_SETTERS_____________()
    {
    }
    public function createLayoutInDB($arrInsert, $arrParams = array())
    {
        $objLayouts = new UniteCreatorLayouts();
        $maxOrder = $objLayouts->getMaxOrder();
        $arrInsert["ordering"] = $maxOrder + 1;
        if (!isset($arrInsert["catid"])) {
            $arrInsert["catid"] = '0';
        }
        if (!isset($arrInsert["parent_id"])) {
            $arrInsert["parent_id"] = '0';
        }
        if (!isset($arrInsert["relate_id"])) {
            $arrInsert["relate_id"] = '0';
        }
        if (!isset($arrInsert["params"])) {
            $arrInsert["params"] = '';
        }
        $id = $this->db->insert(GlobalsUC::$table_layouts, $arrInsert);
        return $id;
    }
    protected function getNewLayoutName($title, $importParams)
    {
        $name = $this->generateName($title);
        return $name;
    }
    public function createSmall($title, $name, $description, $catID, $importParams = array())
    {
        $arrInsert = array();
        $this->validateTitle($title);
        $this->objLayouts->validateLayoutType($this->layoutType);
        $name = $this->getNewLayoutName($title, $importParams);
        $name = HelperUC::convertTitleToAlias($name);
        $this->validateName($name);
        if (!is_numeric($catID)) {
            $catID = 0;
        }
        if (empty($catID)) {
            $catID = 0;
        }
        $arrInsert["title"] = $title;
        $arrInsert["layout_type"] = $this->layoutType;
        $arrInsert["name"] = $name;
        $arrInsert["catid"] = $catID;
        $arrParams = array();
        $description = $this->db->escape($description);
        $arrParams["description"] = $description;
        $arrInsert["params"] = json_encode($arrParams);
        $isNameExists = $this->isLayoutExistsByName($name, $this->layoutType);
        if ($isNameExists == true) {
            $objLayoutExisting = new UniteCreatorLayout();
            $objLayoutExisting->initByName($name, $this->layoutType);
            $objLayoutExisting->updateLayoutInDB($arrInsert);
            $this->id = $objLayoutExisting->getID();
            $this->initByID($this->id);
        } else {
            $this->id = $this->createLayoutInDB($arrInsert, $importParams);
            $this->initByID($this->id);
        }
        return $this->id;
    }
    public function create($data)
    {
        $title = UniteFunctionsUC::getVal($data, "title");
        unset($data["title"]);
        unset($data["layoutid"]);
        UniteFunctionsUC::validateNotEmpty($title, HelperUC::getText("layout_title"));
        $layoutType = UniteFunctionsUC::getVal($data, "layout_type");
        $objLayoutType = UniteCreatorAddonType::getAddonTypeObject($layoutType, true);
        $this->objLayoutType = $objLayoutType;
        $pageName = UniteFunctionsUC::getVal($data, "name");
        if (!empty($pageName)) {
            $pageName = HelperUC::convertTitleToAlias($pageName);
            $isExists = $this->isLayoutExistsByName($pageName, $layoutType);
            if ($isExists) {
                $pageName = null;
            }
        }
        if (empty($pageName)) {
            $pageName = $this->generateName($title);
        }
        $arrInsert = array();
        $arrInsert["title"] = $title;
        $arrInsert["name"] = $pageName;
        $gridData = UniteFunctionsUC::getVal($data, "grid_data");
        $arrInsert["layout_data"] = $this->prepareDataForSave($gridData);
        $params = UniteFunctionsUC::getVal($data, "params");
        if (!empty($params)) {
            $arrInsert["params"] = json_encode($params);
        }
        $catID = UniteFunctionsUC::getVal($data, "catid");
        if (!empty($catID)) {
            $objCategories = new UniteCreatorCategories();
            $objCategories->validateCatExist($catID);
            $arrInsert["catid"] = $catID;
        }
        if ($objLayoutType->allowDuplicateTitle == false) {
            $this->validateLayoutNotExistsByTitle($title, $layoutType);
        }
        if (!empty($layoutType)) {
            $arrInsert["layout_type"] = $layoutType;
        }
        $id = $this->createLayoutInDB($arrInsert);
        $arrResponse = array();
        $arrResponse["id"] = $id;
        $arrResponse["name"] = $pageName;
        return $arrResponse;
    }
    public function updateLayoutInDB($arrUpdate)
    {
        $this->validateInited();
        unset($arrUpdate["import_title"]);
        if (isset($arrUpdate["name"])) {
            $this->validateName($arrUpdate["name"]);
        }
        $where = "id={$this->id}";
        $this->db->update(GlobalsUC::$table_layouts, $arrUpdate, $where);
    }
    public function updateCategory($catID)
    {
        $this->validateInited();
        $catID = (int) $catID;
        $arrUpdate = array();
        $arrUpdate['catid'] = $catID;
        $this->updateLayoutInDB($arrUpdate);
    }
    public function updateTitle($title, $name = null)
    {
        $this->validateInited();
        $this->validateTitle($title);
        $arrUpdate = array();
        $arrUpdate["title"] = $title;
        if ($name !== null) {
            $this->validateName($name);
            $arrUpdate["name"] = $name;
        }
        $this->updateLayoutInDB($arrUpdate);
    }
    public function updateInternalParamsInDB()
    {
        $jsonParams = json_encode($this->params);
        $arrUpdate = array();
        $arrUpdate["params"] = $jsonParams;
        $this->updateLayoutInDB($arrUpdate);
    }
    public function updateParam($paramName, $paramValue)
    {
        $this->validateInited();
        $this->params[$paramName] = $paramValue;
        $this->updateInternalParamsInDB();
    }
    public function updateParams($arrParams, $isRewrite = false)
    {
        $this->validateInited();
        if (empty($arrParams)) {
            return false;
        }
        if (is_array($arrParams) == false) {
            return false;
        }
        if ($isRewrite == true) {
            $this->params = $arrParams;
        } else {
            $this->params = array_merge($this->params, $arrParams);
        }
        $this->updateInternalParamsInDB();
    }
    public function update($data)
    {
        $this->validateInited();
        $title = UniteFunctionsUC::getVal($data, "title");
        $this->validateTitle($title);
        $gridData = UniteFunctionsUC::getVal($data, "grid_data");
        $arrUpdate = array();
        $arrUpdate["title"] = $title;
        $arrUpdate["layout_data"] = $this->prepareDataForSave($gridData);
        if (isset($data["name"])) {
            $pageName = $data["name"];
            $arrUpdate["name"] = $pageName;
        }
        $this->updateLayoutInDB($arrUpdate);
        $params = UniteFunctionsUC::getVal($data, "params");
        if (!empty($params)) {
            $this->updateParams($params);
        }
    }
    public function updateGridData($gridData = null)
    {
        if ($gridData !== null) {
            if (is_string($gridData)) {
                $gridData = UniteFunctionsUC::decodeContent($gridData);
            }
            $this->gridData = $gridData;
        }
        $arrUpdate = array();
        $arrUpdate["layout_data"] = $this->prepareDataForSave($this->gridData);
        $this->updateLayoutInDB($arrUpdate);
    }
    public function delete()
    {
        $this->validateInited();
        $this->db->delete(GlobalsUC::$table_layouts, "id=" . $this->id);
    }
    protected function getDuplicateTitle()
    {
        $objLayouts = new UniteCreatorLayouts();
        $suffixTitle = " - copy";
        $title = $this->getTitle();
        $newTitle = $title . $suffixTitle;
        $isExists = $objLayouts->isLayoutExistsByTitle($newTitle, $this->layoutType);
        $num = 1;
        $limit = 1;
        while ($isExists == true && $limit < 10) {
            $limit++;
            $num++;
            $suffixTitle = " - copy" . $num;
            $newTitle = $title . $suffixTitle;
            $isExists = $objLayouts->isLayoutExistsByTitle($newTitle, $this->layoutType);
        }
        return $newTitle;
    }
    public function duplicate()
    {
        $this->validateInited();
        $newTitle = $this->getDuplicateTitle();
        $newName = $this->generateName($newTitle);
        $layouts = new UniteCreatorLayouts();
        $layouts->shiftOrder($this->ordering, $this->layoutType);
        $newOrder = $this->ordering + 1;
        $sqlSelect = "select " . self::FIELDS_LAYOUTS . " from " . GlobalsUC::$table_layouts . " where id={$this->id}";
        $sqlInsert = "insert into " . GlobalsUC::$table_layouts . " (" . self::FIELDS_LAYOUTS . ") ({$sqlSelect})";
        $this->db->runSql($sqlInsert);
        $lastID = $this->db->getLastInsertID();
        UniteFunctionsUC::validateNotEmpty($lastID);
        $arrUpdate = array();
        $arrUpdate["title"] = $newTitle;
        $arrUpdate["name"] = $newName;
        $arrUpdate["ordering"] = $newOrder;
        $this->db->update(GlobalsUC::$table_layouts, $arrUpdate, array("id" => $lastID));
        return $lastID;
    }
    private function a________________CREATE_CONTENT____________()
    {
    }
    public function getArrNewRow($arrAddonContent = array())
    {
        $row = array();
        $containers = array();
        $column = array();
        $addon = array();
        $column["size"] = "1_1";
        $arrAddons = array();
        if (!empty($arrAddonContent)) {
            $arrAddons[] = $arrAddonContent;
        }
        $column["addon_data"] = $arrAddons;
        $containers["cols"] = array($column);
        $row["containers"] = array($containers);
        return $row;
    }
    public function setRows($arrRows)
    {
        $this->validateInited();
        if (empty($this->gridData)) {
            $this->gridData = array();
        }
        $this->gridData["rows"] = $arrRows;
    }
    public function addRow($arrAddonContent = array())
    {
        $this->validateInited();
        if (empty($this->gridData)) {
            $this->gridData = array();
        }
        $arrRows = $this->getRows();
        $arrRows[] = $this->getArrNewRow($arrAddonContent);
        $this->setRows($arrRows);
    }
    public function addRowWithHtmlAddon($arrAddonContent)
    {
        $this->addRow($arrAddonContent);
    }
}