JezK

Edit File: unitecreator_settings.class.php

<?php
/**
 * @package Unlimited Elements
 * @author unlimited-elements.com
 * @copyright (C) 2021 Unlimited Elements, All Rights Reserved.
 * @license GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
 * */
if ( ! defined( 'ABSPATH' ) ) exit;

class UniteCreatorSettingsWork extends UniteSettingsAdvancedUC{
	
	const TYPE_FONT_PANEL = "fonts_panel";
	const TYPE_ITEMS = "items";
	const INSTAGRAM_DEFAULT_VALUE = "@gianlucavacchi";

//additional attributes that allowed to add to regular settings from params
	protected $arrAddAttributes = array(
		"simple_mode",
		"all_cats_mode",
		"add_current_posts",
		"selector",
		"selector_value",
		"selector1",		//for typography
		"selector2",
		"selector2_value",
		"selector3",
		"selector3_value"
	);

private $currentAddon;
	private $currentTabs;
	private static $addEditWidgetHTML = null;
    private $currentCategoryID;

private function a___________GETTERS_________(){}

/**
	 * get settings in creator format
	 * the type should be given as "origtype" attribute
	 */
	public function getSettingsCreatorFormat(){

$arrParams = array();
		foreach($this->arrSettings as $setting){

$settingName = UniteFunctionsUC::getVal($setting, "name");

$param = array();
			$origType = UniteFunctionsUC::getVal($setting, "origtype");
			$function = UniteFunctionsUC::getVal($setting, "function");

UniteFunctionsUC::validateNotEmpty($origType, "settings original type for: $settingName");

$param["type"] = $origType;
			$param["title"] = UniteFunctionsUC::getVal($setting, "text");
			$param["name"] = UniteFunctionsUC::getVal($setting, "name");
			$param["description"] = UniteFunctionsUC::getVal($setting, "description");
			$param["default_value"] = UniteFunctionsUC::getVal($setting, "default_value");
			$param["placeholder"] = UniteFunctionsUC::getVal($setting, "placeholder");

$arrKeys = array("min","max","step","units","disabled","html",
							 "settings_items","items_values","hide_label","title_field","usefor");

foreach($arrKeys as $key){

$value = UniteFunctionsUC::getVal($setting, $key);

if(!empty($value))
					$param[$key] = $value;
			}

if(!empty($function))
				$param["function"] = $function;

$classAdd = UniteFunctionsUC::getVal($setting, UniteSettingsUC::PARAM_CLASSADD);
			if(!empty($classAdd))
				$param[UniteSettingsUC::PARAM_CLASSADD] = $classAdd;

$addParams = UniteFunctionsUC::getVal($setting, UniteSettingsUC::PARAM_ADDPARAMS);
			if(!empty($addParams))
				$param[UniteSettingsUC::PARAM_ADDPARAMS] = $addParams;

$isMultiple = UniteFunctionsUC::getVal($setting, "is_multiple");	//for dropdown
			if(!empty($isMultiple))
				$param["is_multiple"] = true;

$elementorCondition = UniteFunctionsUC::getVal($setting, "elementor_condition");	//for dropdown
			if(!empty($elementorCondition))
				$param["elementor_condition"] = $elementorCondition;

$addDynamic = UniteFunctionsUC::getVal($setting, "add_dynamic");
			$addDynamic = UniteFunctionsUC::strToBool($addDynamic);

if($addDynamic)
				$param["add_dynamic"] = true;

$labelBlock = UniteFunctionsUC::getVal($setting, "label_block");	//label block
			if(!empty($labelBlock))
				$param["label_block"] = $labelBlock;

$items = UniteFunctionsUC::getVal($setting, "items");
			if(!empty($items))
				$param["options"] = $items;

$arrParams[] = $param;
		}

return($arrParams);
	}

/**
	 * get setting as creator params, for mapping, used in visual composer
	 * not metter the type
	 */
	public function getSettingsAsCreatorParams(){

$arrParams = array();

foreach($this->arrSettings as $setting){

$param = array();

$param["type"] = "uc_textfield";	//no metter what type, will be parsed anyway
			$param["name"] = UniteFunctionsUC::getVal($setting, "name");
			$param["title"] = UniteFunctionsUC::getVal($setting, "text");
			$param["description"] = UniteFunctionsUC::getVal($setting, "description");

$param["uc_setting"] = $setting;

$arrParams[] = $param;
		}

return($arrParams);
	}

/**
	* get multiple params creator format from one param
	*/
	public function getMultipleCreatorParams($param){

if(!empty($this->arrSettings))
			UniteFunctionsUC::throwError("the settings should be empty for this operation");

$this->addByCreatorParam($param);

$arrParams = $this->getSettingsCreatorFormat();

return($arrParams);
	}

/**
	 * get settings types array
	 */
	public function getArrUCSettingTypes(){
	
		$arrTypes = array(
			"uc_textfield",
			UniteCreatorDialogParam::PARAM_NUMBER,
			"uc_textarea",
			"uc_editor",
			UniteCreatorDialogParam::PARAM_RADIOBOOLEAN,
			"uc_checkbox",
			"uc_dropdown",
			"uc_colorpicker",
			"uc_image",
			UniteCreatorDialogParam::PARAM_FILE,
			"uc_mp3",
			"uc_icon",
			UniteCreatorDialogParam::PARAM_ICON_LIBRARY,
			UniteCreatorDialogParam::PARAM_SHAPE,
			UniteCreatorDialogParam::PARAM_HR,
			UniteCreatorDialogParam::PARAM_HEADING,
			"uc_font_override",
			UniteCreatorDialogParam::PARAM_POST,
			UniteCreatorDialogParam::PARAM_POSTS_LIST,
			"uc_statictext",
			UniteCreatorDialogParam::PARAM_MENU
		);

return($arrTypes);
	}

private function a________SETTINGS_TYPES_________(){}

/**
	 * add base url for image settings if needed
	 */
	public function addImage($name,$defaultValue = "",$text = "",$arrParams = array()){

parent::addImage($name, $defaultValue, $text, $arrParams);

//check the source param
		$lastIndex = count($this->arrSettings)-1;
		$this->arrSettings[$lastIndex] = $this->checkParamsSource($this->arrSettings[$lastIndex]);

}

/**
	 * add base url for image settings if needed
	 */
	public function addMp3($name,$defaultValue = "",$text = "",$arrParams = array()){

parent::addMp3($name, $defaultValue, $text, $arrParams);

//check the source param
		$lastIndex = count($this->arrSettings)-1;
		$this->arrSettings[$lastIndex] = $this->checkParamsSource($this->arrSettings[$lastIndex]);

}

/**
	 * add settings provider types
	 */
	protected function addSettingsProvider($type, $name,$value,$title,$extra ){

dmp("function for override: addSettingsProvider ");
		exit();

}

/**
	 * add post terms settings
	 */
	protected function addPostTermsPicker($name,$value,$title,$extra){

dmp("addPostsListPicker - function for override");
		exit();
	}

/**
	 * add listing picker, function for override
	 */
	protected function addListingPicker($name,$value,$title,$extra){

dmp("addListingPicker - function for override");
		exit();
	}

/**
	 * add post terms settings
	 */
	protected function addWooCatsPicker($name,$value,$title,$extra){

dmp("addWooCatsPicker - function for override");
		exit();
	}

/**
	 * add users picker
	 */
	protected function addUsersPicker($name,$value,$title,$extra){

dmp("addUsersPicker - function for override");
		exit();
	}

/**
	 * add template picker
	 */
	protected function addTemplatePicker($name, $value, $title, $extra){

dmp("addTemplatePicker - function for override");
		exit();
	}

/**
	 * add post list picker
	 */
	protected function addPostsListPicker($name, $value, $title, $extra){

dmp("addPostsListPicker - function for override");
		exit();
	}

/**
	 * add background settings
	 */
	protected function addBackgroundSettings($name, $value, $title, $param, $extra){

dmp("addBackgroundSettings - function for override");
		exit();
	}

/**
	 * add menu picker
	 */
	protected function addMenuPicker($name, $value, $title, $extra){

dmp("addMenuPicker - function for override");
		exit();
	}

/**
	 * add instagram selector
	 */
	protected function addInstagramSelector($name,$value,$title,$extra){

$defaultMaxItems = UniteFunctionsUC::getVal($extra, "max_items");
		if(is_numeric($defaultMaxItems) == false || $defaultMaxItems < 1)
			$defaultMaxItems = 12;

$objServies = new UniteServicesUC();
		$objServies->includeInstagramAPI();

$accessData = HelperInstaUC::getInstagramSavedAccessData();
		$accessToken = UniteFunctionsUC::getVal($accessData, "access_token");
		$username = UniteFunctionsUC::getVal($accessData, "username");

if(!empty($accessToken)){

$params = array();
			$params["origtype"] = UniteCreatorDialogParam::PARAM_STATIC_TEXT;

$text = __("Get data from instagram user: ", "unlimited-elements-for-elementor");

$this->addStaticText($text. $username, $name, $params);

}else{

$params = array();
			$params["origtype"] = UniteCreatorDialogParam::PARAM_STATIC_TEXT;

$linkSettings = HelperUC::getViewUrl(GlobalsUnlimitedElements::VIEW_SETTINGS_ELEMENTOR);
			$htmlLink = HelperHtmlUC::getHtmlLink($linkSettings, __("General Settings","unlimited-elements-for-elementor"),"","",true);

/*
			$text = __("Please connect to your instagram account from ", "unlimited-elements-for-elementor");
			$text .= $htmlLink;

$this->addStaticText($text, $name, $params);
			*/

$description = esc_html__("Type instagram user (@username). This method is deprecated. Please connect with your instagram user from general settings", "unlimited-elements-for-elementor");
			$params = array("description"=>$description);

if(empty($value))
				$value = self::INSTAGRAM_DEFAULT_VALUE;

$params["origtype"] = UniteCreatorDialogParam::PARAM_TEXTFIELD;

$this->addTextBox($name, $value ,esc_html__("Instagram User", "unlimited-elements-for-elementor"), $params);

}

//add number of items
		$params = array();
		$params["origtype"] = UniteCreatorDialogParam::PARAM_TEXTFIELD;
		// translators: %d is a number
		$desciption = __("Number of instagram items. Leave empty for default number ( %d ) set by the widget", "unlimited-elements-for-elementor");
		$desciption = sprintf($desciption, $defaultMaxItems);
		$params["description"] = $desciption;

$this->addTextBox($name."_num_items", $defaultMaxItems ,esc_html__("Number Of Items", "unlimited-elements-for-elementor"), $params);

$params = array();
		$params["origtype"] = UniteCreatorDialogParam::PARAM_HR;
		$this->addHr("hr_after_insta", $params);

}

/**
	 * add font panel setting
	 */
	public function addFontPanel($arrParamNames, $arrFontsData, $name = null, $options = array()){

$arrParams = array();
		$arrParams["font_param_names"] = $arrParamNames;
		if(!empty($options))
			$arrParams = array_merge($arrParams, $options);

if(empty($name))
			$name = "uc_fonts_panel";

$this->add($name, $arrFontsData, self::PARAM_NOTEXT, self::TYPE_FONT_PANEL, $arrParams);
	}

/**
	 * add gallery setting
	 */
	public function addGallery($name, $defaultValue, $text, $params = array()){

$params["label_block"] = true;
		
		$this->add($name, $defaultValue, $text, self::TYPE_GALLERY, $params);
	}

/**
	 * add repeater items panel
	 */
	public function addItemsPanelRepeater($addon, $source){

$itemsType = $addon->getItemsType();

if($itemsType == UniteCreatorAddon::ITEMS_TYPE_IMAGE){
			$this->addItemsPanel($addon, $source);
			return(false);
		}

$arrDefaults = $addon->getArrItemsForConfig();

$objSettings = $addon->getSettingsItemsObject();

$text = self::PARAM_NOTEXT;

$this->addRepeater("uc_items", $objSettings, $arrDefaults, $text);

}

/**
	 * add items setting
	 */
	public function addItemsPanel($addon, $source = null){

$value = "";
		$arrParams = array();

if(!empty($source))
			$arrParams["source"] = $source;

$objManager = new UniteCreatorManagerInline();
		$objManager->setStartAddon($addon);
		
		$arrParams["items_manager"] = $objManager;
		$this->add("uc_items_editor", "", self::PARAM_NOTEXT, self::TYPE_ITEMS, $arrParams);
	}

/**
	 * add typography setting
	 */
	public function addTypographySetting($name, $value, $title, $params = array()){

$this->add($name, $value, $title, self::TYPE_TYPOGRAPHY, $params);
	}

/**
	 * add text shadow setting
	 */
	public function addTextShadowSetting($name, $value, $title, $params = array()){

$this->add($name, $value, $title, self::TYPE_TEXTSHADOW, $params);
	}

/**
	 * add text shadow setting
	 */
	public function addTextStrokeSetting($name, $value, $title, $params = array()){

$this->add($name, $value, $title, self::TYPE_TEXTSTROKE, $params);
	}

/**
	 * add box shadow setting
	 */
	public function addBoxShadowSetting($name, $value, $title, $params = array()){

$this->add($name, $value, $title, self::TYPE_BOXSHADOW, $params);
	}

/**
	 * add css filters setting
	 */
	public function addCssFiltersSetting($name, $value, $title, $params = array()){

$this->add($name, $value, $title, self::TYPE_CSS_FILTERS, $params);
	}

/**
	 * add dimentions setting
	 */
	public function addDimentionsSetting($name, $value, $title, $params = array()){

$params["label_block"] = true;

$this->add($name, $value, $title, self::TYPE_DIMENTIONS, $params);
	}

/**
	 * add buttons group
	 */
	public function addButtonsGroup($name, $items, $title, $value, $params = array()){

$params["items"] = $items;

$this->add($name, $value, $title, self::TYPE_BUTTONS_GROUP, $params);
	}

/**
	 * add tabs
	 */
	public function addTabs($name, $items, $value, $params = array()){

$params["items"] = $items;
		$params["label_block"] = true;

$this->add($name, $value, self::PARAM_NOTEXT, self::TYPE_TABS, $params);
	}

/**
	 * add tab
	 */
	public function addTabIfNeeded($name){

// check if the name is empty - reset the tabs
		if(empty($name) === true){
			$this->currentTabs = null;
			return null;
		}

// initialize the tabs
		$tabs = $this->currentTabs;

if(empty($tabs) === true){
			$tabs = array(
				"name" => "tabs_" . UniteFunctionsUC::getRandomString(5),
				"items" => array(),
			);
		}

// add/update the tab
		$value = UniteFunctionsUC::getVal($tabs["items"], $name);
		if(empty($value) === true){

$value = "tab_" . UniteFunctionsUC::getRandomString(5);

$tabs["items"][$name] = $value;

try{
				$this->updateSettingItems($tabs["name"] . '-' . $this->currentCategoryID, $tabs["items"]);
			}catch(Exception $exception){
				$this->addTabs($tabs["name"] . '-' . $this->currentCategoryID, $tabs["items"], $value);
			}
		}

$this->currentTabs = $tabs;

return array(
			"name" => $tabs["name"] . '-' . $this->currentCategoryID,
			"value" => $value,
		);
	}

private function a__________SETTERS_________(){}

/**
	 * set current addon
	 */
	public function setCurrentAddon(UniteCreatorAddon $addon){
		
		$this->currentAddon = $addon;
		
	}

/**
	 * if the source == "addon" add url base
	 */
	private function checkParamsSource($arrParams){

$source = UniteFunctionsUC::getVal($arrParams, "source");

if($source == "addon"){

if(empty($this->currentAddon))
				UniteFunctionsUC::throwError("You must set current addon before init settings for addon related image select option");

$urlAssets = $this->currentAddon->getUrlAssets();

$arrParams["url_base"] = $urlAssets;
		}

return($arrParams);
	}

/**
	 * if in this type exists multiple settings
	 */
	public static function isMultipleUCSettingType($type){

switch($type){
			case UniteCreatorDialogParam::PARAM_POSTS_LIST:
			case UniteCreatorDialogParam::PARAM_CONTENT:
			case UniteCreatorDialogParam::PARAM_INSTAGRAM:
			case UniteCreatorDialogParam::PARAM_POST_TERMS:
			case UniteCreatorDialogParam::PARAM_META_SELECT:
			case UniteCreatorDialogParam::PARAM_WOO_CATS:
			case UniteCreatorDialogParam::PARAM_USERS:
			case UniteCreatorDialogParam::PARAM_TEMPLATE:
			case "uc_filters_repeater_params":
			case UniteCreatorDialogParam::PARAM_LISTING:
			case UniteCreatorDialogParam::PARAM_SPECIAL:

return(true);
			break;
		}

return(false);
	}

/**
	 * add image base settings
	 */
	public function addImageBaseSettings(){

$extra = array("origtype"=>"uc_image");
		$this->addImage("image","","Image",$extra);

$extra = array("origtype"=>"uc_textarea");
		$this->addTextArea("description", "", esc_html__("Description", "unlimited-elements-for-elementor"),$extra);

/*
		$extra = array("origtype"=>"uc_radioboolean");
		$this->addRadioBoolean("enable_link", esc_html__("Enable Link", "unlimited-elements-for-elementor"),false, "Yes","No",$extra);

$extra = array("class"=>"unite-input-link", "origtype"=>"uc_textfield");
		$this->addTextBox("link", "", esc_html__("Link", "unlimited-elements-for-elementor"),$extra);
		*/

}

/**
	 * add items image size setting
	 */
	private function addItemsImageSizeSetting($name, $param){

$title = UniteFunctionsUC::getVal($param, "title");

$arrSizes = UniteFunctionsWPUC::getArrThumbSizes();

$params = array();
		$params["origtype"] = UniteCreatorDialogParam::PARAM_DROPDOWN;
		$params["label_block"] = true;

$arrSizes = array_flip($arrSizes);

$this->addSelect($name."_size", $arrSizes, $title, "medium_large", $params);

}

/**
	 * add special param
	 */
	private function addSpecialParam($name, $param){

$attributeType = UniteFunctionsUC::getVal($param, "attribute_type");

$condition = HelperProviderCoreUC_EL::paramToElementorCondition($param);

switch($attributeType){
			case "non":
			case "none":
			break;
			case "entrance_animation":

UniteCreatorEntranceAnimations::addSettings($this, $name, $param);

break;
			case "items_image_size":

$this->addItemsImageSizeSetting($name, $param);

break;
			case "schema":
				
				$objSchema = new UniteCreatorSchema();
				$objSchema->setObjAddon($this->currentAddon);
				
				$objSchema->addSchemaSettings($this, $name, $param);
				
			break;
			case "dynamic_popup":

$title = UniteFunctionsUC::getVal($param, "title");

$arrOptions = array();
				$arrOptions["post"] = __("Post Link","unlimited-elements-for-elementor");
				$arrOptions["popup"] = __("Dynamic Post Popup","unlimited-elements-for-elementor");
				$arrOptions["empty"] = __("Disable Link","unlimited-elements-for-elementor");
				$arrOptions["meta"] = __("Link From Meta Field","unlimited-elements-for-elementor");

$params = array();
				$params["origtype"] = UniteCreatorDialogParam::PARAM_DROPDOWN;
				$params["elementor_condition"] = $condition;

$arrOptions = array_flip($arrOptions);

$this->addSelect("{$name}_link_type", $arrOptions, $title, "post", $params);

//add text

$params = array();
				$params["origtype"] = UniteCreatorDialogParam::PARAM_STATIC_TEXT;

$condition["{$name}_link_type"] = "popup";
				$params["elementor_condition"] = $condition;

$text = __("This option works with \"Dynamic Post Popup\" widget. Please put it to the page.", "unlimited-elements-for-elementor");

$this->addStaticText($text, $name."_text", $params);

//add meta name

$params = array();
				$params["origtype"] = UniteCreatorDialogParam::PARAM_TEXTFIELD;

$condition["{$name}_link_type"] = "meta";
				$params["elementor_condition"] = $condition;

$this->addTextBox($name."_meta_field","", __("Meta Field Name","unlimited-elements-for-elementor"), $params);

break;
			case "contact_form7":

//add not exists heading.
				$isInstalled = UniteCreatorPluginIntegrations::isContactFrom7Installed();

if($isInstalled == false){

$params = array();
					$params["origtype"] = UniteCreatorDialogParam::PARAM_STATIC_TEXT;
					$params["elementor_condition"] = $condition;

$text = __("The Contact Form 7 Plugin is not installed", "unlimited-elements-for-elementor");

$this->addStaticText($text, "{$name}_text", $params);

}

$title = UniteFunctionsUC::getVal($param, "title");

$arrForms = UniteCreatorPluginIntegrations::getArrContactForm7();

$default = UniteFunctionsUC::getArrFirstValue($arrForms);

$params = array();
				$params["origtype"] = UniteCreatorDialogParam::PARAM_DROPDOWN;
				$params["elementor_condition"] = $condition;

$this->addSelect("{$name}_form", $arrForms, $title, $default, $params);

break;
			case "ucform_conditions":

$params = array();
				$params["elementor_condition"] = $condition;
				$params["origtype"] = UniteCreatorDialogParam::PARAM_REPEATER;
				$params["hide_label"] = true;
				$params["title_field"] = "{{{operator}}} {{{field_name}}} {{{condition}}} {{{field_value}}}";

$settingsItems = UniteCreatorForm::getConditionsRepeaterSettings();

$title = UniteFunctionsUC::getVal($param, "title");

$this->addRepeater("{$name}_conditions", $settingsItems, array(), $title, $params);

break;
			case "sort_filter_fields":
			
				$params = array();
				$params["elementor_condition"] = $condition;
				$params["origtype"] = UniteCreatorDialogParam::PARAM_REPEATER;
				$params["hide_label"] = true;
				$params["title_field"] = "{{{title}}} ({{{type}}})";
				
				$description = UniteFunctionsUC::getVal($param, "description");

if(!empty($description))
					$params["description"] = $description;

$settingsItems = HelperProviderUC::getSortFilterRepeaterFields();
				
				$settingsValues = HelperProviderUC::getSortFilterDefaultValues();
				
				$title = UniteFunctionsUC::getVal($param, "title");
								
				$this->addRepeater("{$name}_fields", $settingsItems, $settingsValues, $title, $params);
				
			break;
			case "currency_api":
				UniteCreatorAPIIntegrations::getInstance()->addServiceSettingsFields($this, UniteCreatorAPIIntegrations::TYPE_CURRENCY_EXCHANGE, $name, $condition);
			break;
			case "weather_api":
				UniteCreatorAPIIntegrations::getInstance()->addServiceSettingsFields($this, UniteCreatorAPIIntegrations::TYPE_WEATHER_FORECAST, $name, $condition);
			break;
            case "rss_feed":
                
            	$objRss = new UniteCreatorRSS();
            	
            	$fields = $objRss->getRssFields($name);
                
                HelperProviderUC::addSettingsFields($this, $fields, $name, $condition);
            break;
            case "repeater":
            	
            	HelperProviderUC::addRepeaterSettings($this, $name,"",true, true);
            	
            break;
			case "base_widget":	//operate base widget addon object
			break;
			case "reviews":
				
				UniteCreatorAPIIntegrations::getInstance()->addServiceSettingsFields($this, UniteCreatorAPIIntegrations::TYPE_GOOGLE_REVIEWS, $name, $condition);
				
			break;
			case "youtube_playlist":

UniteCreatorAPIIntegrations::getInstance()->addServiceSettingsFields($this, UniteCreatorAPIIntegrations::TYPE_YOUTUBE_PLAYLIST, $name, $condition);

break;
			case "google_events":

UniteCreatorAPIIntegrations::getInstance()->addServiceSettingsFields($this, UniteCreatorAPIIntegrations::TYPE_GOOGLE_EVENTS, $name, $condition);

break;
			default:
				UniteFunctionsUC::throwError("Add special param error: wrong attribute type: $attributeType, please check that the plugin version is up to date");
			break;
		}

}

/**
	 * modify external loaded settings
	 */
	public function modifyLoadedSettings($loadParam){

if($loadParam != "layout_row"){
			parent::modifyLoadedSettings($loadParam);
			return(false);
		}

$arrChange = array(
			"padding_top"=>"row_padding_top",
			"padding_bottom"=>"row_padding_bottom",
			"padding_left"=>"row_padding_left",
			"padding_right"=>"row_padding_right",

"margin_top"=>"row_margin_top",
			"margin_bottom"=>"row_margin_bottom",
			"margin_left"=>"row_margin_left",
			"margin_right"=>"row_margin_right"
		);

foreach($arrChange as $oldName=>$newName)
			$this->changeSettingName($oldName, $newName);

}

/**
	 * modify by categories of the addons or layouts
	 */
	protected function modifyBeforeAdd_categories($setting, $addonType, $addNew = false){

$objCategories = new UniteCreatorCategories();
		$arrCats = $objCategories->getCatsShort("", $addonType);

if($addNew == true)
			$arrCats["new"] = "[". esc_html__("New Category", "unlimited-elements-for-elementor")."]";

$fistValue = UniteFunctionsUC::getFirstNotEmptyKey($arrCats);

$arrCats = array_flip($arrCats);

$setting["items"] = $arrCats;

$setting["value"] = $fistValue;
		$setting["default_value"] = $fistValue;

return($setting);
	}

/**
	 * modify setting before add (any setting)
	 */
	protected function modifyBeforeAdd($setting, $modifyType){

switch($modifyType){
			case "choose_background":

if($this->settingsType != "row_bg")
					unset($setting["items"]["More"]);

break;
			case "library_sections_categories":

$setting = $this->modifyBeforeAdd_categories($setting, GlobalsUC::ADDON_TYPE_LAYOUT_SECTION, true);

break;
		}

return($setting);
	}

private function a__________CONDITIONS_________(){}

/**
	 * add controls
	 */
	public function addByCreatorParam_handleConditions($param, $isForSap = false){

$enableCondition = UniteFunctionsUC::getVal($param, "enable_condition");

$enableCondition = UniteFunctionsUC::strToBool($enableCondition);

if($enableCondition == false){
			return(false);
		}

$name = UniteFunctionsUC::getVal($param, "name");

$attribute = UniteFunctionsUC::getVal($param, "condition_attribute");
		$operator = UniteFunctionsUC::getVal($param, "condition_operator");
		$value = UniteFunctionsUC::getVal($param, "condition_value");

$attribute2 = UniteFunctionsUC::getVal($param, "condition_attribute2");
		$operator2 = UniteFunctionsUC::getVal($param, "condition_operator2");
		$value2 = UniteFunctionsUC::getVal($param, "condition_value2");

if(empty($attribute))
			return(false);

$action = "show";
		if($operator == "not_equal")
			$action = "hide";

$this->addControl($attribute, $name, $action, $value, $isForSap);

if(empty($attribute2))
			return(false);

$action = "show";
		if($operator2 == "not_equal")
			$action = "hide";

$this->addControl($attribute2, $name, $action, $value2, $isForSap);
	}

/**
     * add control by elementor condition
     */
    public function addControl_byElementorConditions($nameChild, $arrConditions){

if(empty($arrConditions) == true)
    		return(false);

if(is_array($arrConditions) == false)
    		UniteFunctionsUC::throwError("The elementor conditions should be array");

foreach($arrConditions as $nameParent=>$value){

$type = "show";

$lastCharacter = substr($nameParent, -1);

if($lastCharacter == "!"){
				$type = "hide";
				$nameParent = substr($nameParent, 0, -1);	//cut last character
			}

$this->addControl($nameParent, $nameChild, $type, $value);
    	}

}

/**
     * add controls by elementor conditions
     */
	private function addControls_byElementorConditions(){

if(empty($this->arrSettings))
			return(false);

foreach($this->arrSettings as $setting){

$elementorCondition	 = UniteFunctionsUC::getVal($setting, "elementor_condition");

if(empty($elementorCondition))
				continue;

$name = UniteFunctionsUC::getVal($setting, "name");

$this->addControl_byElementorConditions($name, $elementorCondition);
		}

}

/**
	 * Test addon settings - inside addon use and gutenberg.
	 * Not for elementor
	 */
	private function a__________SETTINGS_OUTPUT_GUTENBERG_TEST_ADDON_________(){}

/**
	 * add free version 
	 */
	private function addFreeVersionInsideNotification(){
		
    	$text = GlobalsUnlimitedElements::$insideNotificationText;
		
    	$urlBuy = GlobalsUnlimitedElements::$insideNotificationUrl;
    	
		$text = str_replace( "[url_buy]", $urlBuy, $text );
	    
		$html = "<div class='uc-settings-cta-notification'>{$text}</div>";
		
		GlobalsUnlimitedElements::$insideNotificationText;
		
		$this->addStaticHTML($html);
		
	}
	
	/**
	 * check and add images sizes chooser - for image input
	 */
	private function checkAddImageSizes($paramImage){

$isAddSizes = UniteFunctionsUC::getVal($paramImage, "add_image_sizes");
		$isAddSizes = UniteFunctionsUC::strToBool($isAddSizes);

if($isAddSizes == false)
			return(false);

$type = UniteFunctionsUC::getVal($paramImage, "type");
    	$title = UniteFunctionsUC::getVal($paramImage, "title");
    	$name = UniteFunctionsUC::getVal($paramImage, "name");

$arrSizes = UniteFunctionsWPUC::getArrThumbSizes();

$arrSizes = array_flip($arrSizes);

if($type == UniteCreatorDialogParam::PARAM_POSTS_LIST){
	    	$paramTitle = $title .= " ".__("Image Size","unlimited-elements-for-elementor");
	    	$paramName = $name .= "_imagesize";
    	}else{
	    	$paramTitle = $title .= " ".__("Size","unlimited-elements-for-elementor");
    		$paramName = $name .= "_size";
    	}

// add the new setting

$arrOptions = array();
    	$this->addSelect($paramName, $arrSizes, $paramTitle, "medium_large", $arrOptions);

//handle new param conditions

$newParam = $paramImage;

$newParam["name"] = $paramName;
    	$newParam["type"] = UniteCreatorDialogParam::PARAM_DROPDOWN;

$this->addByCreatorParam_handleConditions($newParam);

}

/**
	 * add setting by creator param
	 */
	public function addByCreatorParam($param, $inputValue = null){

//add ready setting if exists
		$arrReadySetting = UniteFunctionsUC::getVal($param, "uc_setting");

if(!empty($arrReadySetting)){
			$classAdd = UniteFunctionsUC::getVal($arrReadySetting, UniteSettingsUC::PARAM_CLASSADD);

$arrReadySetting[UniteSettingsUC::PARAM_CLASSADD] = $classAdd;

if(!empty($inputValue))
				$arrReadySetting["value"] = $inputValue;

$this->addSettingByArray($arrReadySetting);

return;
		}

$defaultValue = UniteFunctionsUC::getVal($param, "default_value");
		$value = UniteFunctionsUC::getVal($param, "value", $defaultValue);
		$type = UniteFunctionsUC::getVal($param, "type");
		$title = UniteFunctionsUC::getVal($param, "title");
		$name = UniteFunctionsUC::getVal($param, "name");
		$description = UniteFunctionsUC::getVal($param, "description");
		$placeholder = UniteFunctionsUC::getVal($param, "placeholder");
		$tabName = UniteFunctionsUC::getVal($param, "tabname");
		$labelBlock = UniteFunctionsUC::getVal($param, "label_block");
		$labelBlock = UniteFunctionsUC::strToBool($labelBlock);
		$isResponsive = UniteFunctionsUC::getVal($param, "is_responsive");
		$isResponsive = UniteFunctionsUC::strToBool($isResponsive);
		$unit = UniteFunctionsUC::getVal($param, "unit");

if($unit == "other")
			$unit = UniteFunctionsUC::getVal($param, "unit_custom");

$extra = array(
			"origtype" => $type,
			"label_block" => $labelBlock,
			"is_responsive" => $isResponsive,
			"responsive_id" => $name,
		);

if(!empty($description))
			$extra["description"] = $description;

if(!empty($placeholder))
			$extra["placeholder"] = $placeholder;

if(!empty($unit))
			$extra["unit"] = $unit;

$tab = $this->addTabIfNeeded($tabName);

if(!empty($tab)){
			$extra["tabs_id"] = $tab["name"];
			$extra["tabs_value"] = $tab["value"];
		}

foreach($this->arrAddAttributes as $attributeName){
			$attributeValue = UniteFunctionsUC::getVal($param, $attributeName);

if(!empty($attributeValue))
				$extra[$attributeName] = $attributeValue;
		}

$isMultipleSettingType = self::isMultipleUCSettingType($type);
		$isUpdateValue = true;

if($isMultipleSettingType && !empty($inputValue)){
			$value = $inputValue;
			$isUpdateValue = false;
		}

switch ($type){
			case UniteCreatorDialogParam::PARAM_EDITOR:
				$this->addEditor($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_TEXTFIELD:
				$this->addTextBox($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_LINK:
				$this->addLink($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_NUMBER:
				$extra["class"] = UniteCreatorSettingsOutput::INPUT_CLASS_NUMBER;

$values = array(
					"desktop" => $value,
					"tablet" => UniteFunctionsUC::getVal($param, "default_value_tablet"),
					"mobile" => UniteFunctionsUC::getVal($param, "default_value_mobile"),
				);

$responsive = array("desktop" => "");

if($isResponsive === true){
					$responsive["tablet"] = "_tablet";
					$responsive["mobile"] = "_mobile";
				}

foreach($responsive as $device => $suffix){
					$value = UniteFunctionsUC::getVal($values, $device);

$extra["responsive_type"] = $device;

$this->addTextBox($name . $suffix, $value, $title, $extra);
				}
			break;
			case UniteCreatorDialogParam::PARAM_RADIOBOOLEAN:
				$extra["true_value"] = $param["true_value"];
				$extra["false_value"] = $param["false_value"];

$this->addRadioBoolean($name, $title, $value, $param["true_name"], $param["false_name"], $extra);
			break;
			case UniteCreatorDialogParam::PARAM_TEXTAREA:
				$this->addTextArea($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_CHECKBOX:
				$textNear = UniteFunctionsUC::getVal($param, "text_near");
				$isChecked = UniteFunctionsUC::getVal($param, "is_checked");
				$isChecked = UniteFunctionsUC::strToBool($isChecked);

$this->addCheckbox($name, $isChecked, $title, $textNear, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_DROPDOWN:
				$options = UniteFunctionsUC::getVal($param, "options");

$values = array(
					"desktop" => $value,
					"tablet" => UniteFunctionsUC::getVal($param, "default_value_tablet"),
					"mobile" => UniteFunctionsUC::getVal($param, "default_value_mobile"),
				);

$responsive = array("desktop" => "");

if($isResponsive === true){
					$responsive["tablet"] = "_tablet";
					$responsive["mobile"] = "_mobile";
				}

foreach($responsive as $device => $suffix){
					$value = UniteFunctionsUC::getVal($values, $device);

$extra["responsive_type"] = $device;

$this->addSelect($name . $suffix, $options, $title, $value, $extra);
				}
			break;
			case UniteCreatorDialogParam::PARAM_MULTIPLE_SELECT:
				$options = UniteFunctionsUC::getVal($param, "options");

$this->addMultiSelect($name, $options, $title, $value, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_TERM_SELECT:
				$extra["post_select"] = true;
				$extra["post_select_type"] = "term";

$this->addMultiSelect($name, array(), $title, $value, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_META_SELECT:
				$extra["meta_key"] = UniteFunctionsUC::getVal($param, "meta_key");

$this->addMetaSelectPicker($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_POST_SELECT:
				$extra["post_select"] = true;
				$extra["post_select_type"] = "post";

$this->addMultiSelect($name, array(), $title, $value, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_COLORPICKER:
				$this->addColorPicker($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_ADDONPICKER:
				$extra["addontype"] = UniteFunctionsUC::getVal($param, "addon_type");

$this->addAddonPicker($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_IMAGE:

$this->addImage($name,$value,$title,$extra);

$this->checkAddImageSizes($param);

break;
			case "uc_mp3":
				$this->addMp3($name,$value,$title,$extra);
			break;
			case "uc_imagebase":
				$this->addImageBaseSettings();
			break;
			case "uc_statictext":
				$this->addStaticText($title, $name, $extra);
				$isUpdateValue = false;
			break;
			case UniteCreatorDialogParam::PARAM_GALLERY:
				$this->addGallery($name, $defaultValue, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_ICON:
				$this->addIconPicker($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_ICON_LIBRARY:
				$extra["enable_svg"] = UniteFunctionsUC::getVal($param, "enable_svg");

$this->addIconPicker($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_SHAPE:
				$this->addShapePicker($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_MAP:
				$this->addGoogleMap($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_HR:
				$this->addHr($name);
				$isUpdateValue = false;
			break;
			case UniteCreatorDialogParam::PARAM_HEADING:
				$extra["is_heading"] = true;

$this->addStaticText($value,$name,$extra);
			break;
			case "uc_font_override":
				//don't draw anything
			break;
			case UniteCreatorDialogParam::PARAM_INSTAGRAM:
				$extra["max_items"] = UniteFunctionsUC::getVal($param, "max_items");

$this->addInstagramSelector($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_POST:
				$this->addPostPicker($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_POSTS_LIST:
				$extra["for_woocommerce_products"] = UniteFunctionsUC::getVal($param, "for_woocommerce_products");
				$extra["default_max_posts"] = UniteFunctionsUC::getVal($param, "default_max_posts");

$this->addPostsListPicker($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_POST_TERMS:
				$extra["for_woocommerce"] = UniteFunctionsUC::getVal($param, "for_woocommerce");
				$extra["filter_type"] = UniteFunctionsUC::getVal($param, "filter_type");

$this->addPostTermsPicker($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_WOO_CATS:
				$this->addWooCatsPicker($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_LISTING:
				$this->addListingPicker($name,$value,$title,$param);
			break;
			case UniteCreatorDialogParam::PARAM_USERS:
				$this->addUsersPicker($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_TEMPLATE:
				$this->addTemplatePicker($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_DATASET:
				//don't add any settings
			break;
			case UniteCreatorDialogParam::PARAM_CONTENT;
				$this->addContentSelector($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_MENU:
				$useFor = UniteFunctionsUC::getVal($param, "usefor");

if(!empty($useFor))
					$extra["usefor"] = $useFor;

$this->addMenuPicker($name,$value,$title,$extra);
			break;
			case UniteCreatorDialogParam::PARAM_BORDER:
				$types = array_flip(array(
					"" => __("Default", "unlimited-elements-for-elementor"),
					"none" => __("None", "unlimited-elements-for-elementor"),
					"solid" => __("Solid", "unlimited-elements-for-elementor"),
					"dashed" => __("Dashed", "unlimited-elements-for-elementor"),
					"dotted" => __("Dotted", "unlimited-elements-for-elementor"),
					"double" => __("Double", "unlimited-elements-for-elementor"),
					"groove" => __("Groove", "unlimited-elements-for-elementor"),
				));

$selector = UniteFunctionsUC::getVal($param, "selector");

$typeName = $name . "_type";
				// translators: %s is a string
				$typeTitle = sprintf(__("%s Type", "unlimited-elements-for-elementor"), $title);
				$typeDefault = UniteFunctionsUC::getVal($param, "border_type");
				$typeCondition = array($typeName . "!" => array("", "none"));

$typeParams = array_merge($extra, array(
					"selector" => $selector,
					"selector_value" => HelperHtmlUC::getCSSSelectorValueByParam($type, "style"),
				));

$this->addSelect($typeName, $types, $typeTitle, $typeDefault, $typeParams);
				// translators: %s is a string
				$widthTitle = sprintf(__("%s Width", "unlimited-elements-for-elementor"), $title);

$widthParams = array_merge($extra, array(
					"elementor_condition" => $typeCondition,
					"selector" => $selector,
					"selector_value" => HelperHtmlUC::getCSSSelectorValueByParam($type, "width"),
					"units" => array("px", "%", "em", "rem"),
					"is_responsive" => true,
				));

$responsive = array(
					"desktop" => "",
					"tablet" => "_tablet",
					"mobile" => "_mobile",
				);

foreach($responsive as $device => $suffix){
					$addValue = array();
					$addValue["top"] = UniteFunctionsUC::getVal($param, "width_{$device}_top");
					$addValue["bottom"] = UniteFunctionsUC::getVal($param, "width_{$device}_bottom");
					$addValue["left"] = UniteFunctionsUC::getVal($param, "width_{$device}_left");
					$addValue["right"] = UniteFunctionsUC::getVal($param, "width_{$device}_right");
					$addValue["unit"] = UniteFunctionsUC::getVal($param, "width_{$device}_unit");
					$addValue["is_linked"] = UniteFunctionsUC::getVal($param, "width_{$device}_is_linked", true);

$widthParams["responsive_type"] = $device;

$this->addDimentionsSetting("{$name}_width{$suffix}", $addValue, $widthTitle, $widthParams);
				}
				// translators: %s is a string
				$colorTitle = sprintf(__("%s Color", "unlimited-elements-for-elementor"), $title);
				$colorDefault = UniteFunctionsUC::getVal($param, "border_color");

$colorParams = array_merge($extra, array(
					"elementor_condition" => $typeCondition,
					"selector" => $selector,
					"selector_value" => HelperHtmlUC::getCSSSelectorValueByParam($type, "color"),
				));

$this->addColorPicker($name . "_color", $colorDefault, $colorTitle, $colorParams);
			break;
			case UniteCreatorDialogParam::PARAM_PADDING:
			case UniteCreatorDialogParam::PARAM_MARGINS:
			case UniteCreatorDialogParam::PARAM_BORDER_DIMENTIONS:
				$extra["selector_value"] = HelperHtmlUC::getCSSSelectorValueByParam($type);

$withoutUnits = UniteFunctionsUC::getVal($param, "no_units");
				$withoutUnits = UniteFunctionsUC::strToBool($withoutUnits);

if($withoutUnits === false)
					$extra["units"] = array("px", "%", "em", "rem");

$responsive = array("desktop" => "");

if($isResponsive === true){
					$responsive["tablet"] = "_tablet";
					$responsive["mobile"] = "_mobile";
				}

foreach($responsive as $device => $suffix){
					$addValue = array();
					$addValue["top"] = UniteFunctionsUC::getVal($param, "{$device}_top");
					$addValue["bottom"] = UniteFunctionsUC::getVal($param, "{$device}_bottom");
					$addValue["left"] = UniteFunctionsUC::getVal($param, "{$device}_left");
					$addValue["right"] = UniteFunctionsUC::getVal($param, "{$device}_right");
					$addValue["unit"] = UniteFunctionsUC::getVal($param, "{$device}_unit");
					$addValue["is_linked"] = UniteFunctionsUC::getVal($param, "{$device}_is_linked", true);

$extra["responsive_type"] = $device;

$this->addDimentionsSetting($name . $suffix, $addValue, $title, $extra);
				}
			break;
			case UniteCreatorDialogParam::PARAM_SLIDER:
				$extra["min"] = UniteFunctionsUC::getVal($param, "min");
				$extra["max"] = UniteFunctionsUC::getVal($param, "max");
				$extra["step"] = UniteFunctionsUC::getVal($param, "step");
				$extra["units"] = UniteFunctionsUC::getVal($param, "units");
				$extra["units"] = str_replace("percent", "%", $extra["units"]);
				$extra["units"] = explode("_", $extra["units"]);

$responsive = array("desktop" => "");

if($isResponsive === true){
					$responsive["tablet"] = "_tablet";
					$responsive["mobile"] = "_mobile";
				}

foreach($responsive as $device => $suffix){
					$value = UniteFunctionsUC::getVal($param, "default_value{$suffix}");

$extra["responsive_type"] = $device;

$this->addRangeSlider($name . $suffix, $value, $title, $extra);
				}
			break;
			case UniteCreatorDialogParam::PARAM_TYPOGRAPHY:
				$this->addTypographySetting($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_TEXTSHADOW:
				$this->addTextShadowSetting($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_TEXTSTROKE:
				$this->addTextStrokeSetting($name, $value, $title, $extra);
				break;
			case UniteCreatorDialogParam::PARAM_BOXSHADOW:
				$this->addBoxShadowSetting($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_CSS_FILTERS:
				$this->addCssFiltersSetting($name, $value, $title, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_BACKGROUND:
				$this->addBackgroundSettings($name, $value, $title, $param, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_HOVER_ANIMATIONS:
				$animations = HelperProviderCoreUC_EL::getHoverAnimations();
				$prefix = GlobalsUnlimitedElements::PREFIX_ANIMATION_CLASS;
				$items = array("" => __("None", "unlimited-elements-for-elementor"));

foreach($animations as $key => $value){
					$items[$prefix . $key] = $value;
				}

$value = UniteFunctionsUC::getVal($param, "default_value");
				$value = str_replace("elementor-animation-", $prefix, $value);

$this->addSelect($name, array_flip($items), $title, $value, $extra);
			break;
			case UniteCreatorDialogParam::PARAM_SPECIAL:
				$this->addSpecialParam($name, $param);
			break;
			case UniteCreatorDialogParam::PARAM_DATETIME:
				$extra["placeholder"] = "YYYY-mm-dd HH:ii";

$this->addDateTime($name, $value, $title, $extra);
			break;
			default:
				$isAdded = $this->addSettingsProvider($type, $name, $value, $title, $extra);

if($isAdded == false)
					UniteFunctionsUC::throwError("initByCreatorParams error: Wrong setting type: $type");
			break;
		}

$this->addByCreatorParam_handleConditions($param);

//set setting value
		if($inputValue !== null && $isUpdateValue === true)
			$this->updateSettingValue($name, $inputValue);

}

/**
     * sort params by categories
     */
    private function sortParamsByCats($arrCats, $params){

if(empty($arrCats))
    		$arrCats = array();

$arrOutput = array();

foreach($arrCats as $cat){
    		$catID = UniteFunctionsUC::getVal($cat, "id");
    		unset($cat["id"]);

$cat["params"] = array();

$arrOutput[$catID] = $cat;
    	}

foreach($params as $param){

$catID = UniteFunctionsUC::getVal($param, GlobalsUC::ATTR_CATID);

if(empty($catID))
    			$catID = "cat_general_general";

if(array_key_exists($catID, $arrOutput) == false)
    			$catID = "cat_general_general";

unset($param[GlobalsUC::ATTR_CATID]);

$sectionCounter = 0;

//add category
    		if(array_key_exists($catID, $arrOutput) == false){

//set category title
    			$catTitle = __("General", "unlimited-elements-for-elementor");
				
    			if($catID != "cat_general_general"){
    				$sectionCounter++;
    				$catTitle = __("Section ","unlimited-elements-for-elementor") . $sectionCounter;
    			}

$catTab = "content";

$arrOutput[$catID] = array(
    				"title"=>$catTitle,
    				"tab"=>$catTab,
    				"params"=>array()
    			);
    		}

$arrOutput[$catID]["params"][] = $param;
    	}

//remove empty categories
    	foreach($arrOutput as $catID => $cat){
    		if(empty($cat["params"]))
    			unset($arrOutput[$catID]);
    	}

return($arrOutput);
    }

/**
	 * add edit widget button to advanced settings - if allowed
	 */
	private function addEditWidgetButton(){

if(is_admin() == false)
    		return(false);

if(class_exists("UniteProviderAdminUC") == false)
    		return(false);

if(UniteProviderAdminUC::$isUserHasCapability == false)
    		return(false);
		
    	$addonID =  $this->currentAddon->getID();
		
    	$urlEditAddon = HelperUC::getViewUrl_EditAddon($addonID, "", "tab=uc_tablink_html");

$arrParams = array();
		$arrParams["url"] = $urlEditAddon;
		$arrParams["newwindow"] = true;
		if(GlobalsUnlimitedElements::$enableEditWidget == false) {
			$arrParams["title"] = "Available only in PRO Version";
			$arrParams["class"] = "unite-button-secondary uc-disabled";			
		} else {
			$arrParams["class"] = "unite-button-secondary";	
		}

$this->addButton("html_button_gotoaddon", __("Edit Block HTML","unlimited-elements-for-elementor"), self::PARAM_NOTEXT, $arrParams);

}

/**
	 * add advanced settings section
	 */
	public function addAdvancedSection(){

$this->addSap(esc_html__("Advanced", "unlimited-elements-for-elementor"), "advanced");

$params = array();
		$params["description"] = __("Show widget data for debugging purposes. Please turn off this option when you releasing the widget.", "unlimited-elements-for-elementor");

$this->addRadioBoolean("show_widget_debug_data", __("Show Widget Data For Debug", "unlimited-elements-for-elementor"), false, "Yes", "No", $params);

$isItemsEnabled = $this->currentAddon->isHasItems();
		$hasPostsList = $this->currentAddon->isParamTypeExists(UniteCreatorDialogParam::PARAM_POSTS_LIST);

//--------- debug type options ---------
		$debugTypeOptions = array();
		$debugTypeOptions["default"] = __('Default', 'unlimited-elements-for-elementor');

if($hasPostsList == true)
			$isItemsEnabled = true;

if($isItemsEnabled == true)
			$debugTypeOptions["items_only"] = __('Items Only', 'unlimited-elements-for-elementor');

if($hasPostsList == true){
			$debugTypeOptions["post_titles"] = __('Posts Titles', 'unlimited-elements-for-elementor');
			$debugTypeOptions["post_meta"] = __('Posts Titles and Meta', 'unlimited-elements-for-elementor');
		}

$debugTypeOptions["current_post_data"] = __('Current Post Data', 'unlimited-elements-for-elementor');
		$debugTypeOptions["settings_values"] = __('Show Settings Values', 'unlimited-elements-for-elementor');

$hasDebugType = (count($debugTypeOptions) > 1);

if($hasDebugType == true){
			$params = array();

$debugTypeOptions = array_flip($debugTypeOptions);

$this->addSelect("widget_debug_data_type", $debugTypeOptions,
				__("Debug Data Type", "unlimited-elements-for-elementor"), "default", $params);
		}

$this->addControl("show_widget_debug_data", "widget_debug_data_type", "show", "true");
		
		if(self::$addEditWidgetHTML === null){
				self::$addEditWidgetHTML = HelperProviderCoreUC_EL::getGeneralSetting("show_edit_html_button");
				self::$addEditWidgetHTML = UniteFunctionsUC::strToBool(self::$addEditWidgetHTML);
		}
	
		if(self::$addEditWidgetHTML === true)
			$this->addEditWidgetButton();
		
	}
	
	/**
	 * add the background section
	 */
	public function addGutenbergEditorBackgroundSection(){

$this->addSap(esc_html__("Background", "unlimited-elements-for-elementor"), "uc_background");
		
		$params = array();
		$params["description"] = __("Choose the background location.", "unlimited-elements-for-elementor");

$arrItems = array(
			'back'  => __( 'In Background', 'unlimited-elements-for-elementor' ),
			'front' => __( 'In Foregroud', 'unlimited-elements-for-elementor' )
			/*
			'body' => __( 'Site Body Background', 'unlimited-elements-for-elementor' ),
			'body_front' => __( 'Site Body Foreground', 'unlimited-elements-for-elementor' ),
			'layout' => __( 'Layout Background', 'unlimited-elements-for-elementor' ),
			'layout_front' => __( 'Layout Foreground', 'unlimited-elements-for-elementor' )
			*/
		);
		
		$arrItems = array_flip($arrItems);
		
		$this->addSelect("background_location", $arrItems, __( 'Background Location', 'unlimited-elements-for-elementor' ), "back", $params);
		
	}
	
	
	/**
	 * add image sizes param
	 */
	private function addImageSizesParam($paramImage){

$param = HelperProviderUC::getImageSizesParamFromPostListParam($paramImage);

$this->addByCreatorParam($param);

}

/**
	 * add pagination and filtering section
	 */
	private function addPaginationAndFilteringSection($postListParam){

$objPagination = new UniteCreatorElementorPagination();
		$objPagination->addUniteSettingsSection($this, $postListParam);
	}
	
	/**
	 * add schema section
	 */
	private function addSchemaSectionForPosts($postsListParam){
		
		
	}
	
	/**
	 * mark general tab
	 */
	private function markGeneralTab($arrParamsWithCats){
		
		if(empty($arrParamsWithCats))
			return($arrParamsWithCats);
					
		foreach($arrParamsWithCats as $catID => &$cat){
	
			$tab = UniteFunctionsUC::getVal($cat, "tab");
			
			if($tab != self::TAB_CONTENT)
				continue;
			
			if($catID == self::CAT_GENERAL){
				
				$cat["is_general"] = true;
				
				return($arrParamsWithCats);
			}
			
		}
		
		//if not found - set the first one
		$isFirst = true;
		foreach($arrParamsWithCats as $catID => &$cat){
	
			$tab = UniteFunctionsUC::getVal($cat, "tab");
			
			if($tab != self::TAB_CONTENT)
				continue;
			
			$cat["is_general"] = true;
			
			return($arrParamsWithCats);
		}
		
		
		return($arrParamsWithCats);
	}
	
	/**
	 * add settings by creator params - works for single widget only (not for elementor)
	 */
	public function initByCreatorParams($arrParams, $arrCats = array()){

if(empty($arrCats) === true){
			foreach($arrParams as $param){
				$this->addByCreatorParam($param);
			}

return;
		}

// put params with cats
		$arrParamsWithCats = $this->sortParamsByCats($arrCats, $arrParams);
						
		if(empty($arrParamsWithCats) === true)
			return;
		
		$arrParamsWithCats = $this->markGeneralTab($arrParamsWithCats);
				
		$listingParam = null;
		$postsListParam = null;
			
		$addPagination = false;

$this->ensureAdvancedFields();
				
		foreach($arrParamsWithCats as $catID => $arrCat){

$this->currentCategoryID = $catID;

// reset tabs to create for new cat 
			$this->currentTabs = null;

$title = UniteFunctionsUC::getVal($arrCat, "title");
			$tab = UniteFunctionsUC::getVal($arrCat, "tab");
			$arrParams = UniteFunctionsUC::getVal($arrCat, "params");
			
			$isGeneralCategory = UniteFunctionsUC::getVal($arrCat, "is_general");

$this->addSap($title, $catID, $tab);

$sapParams = $arrCat;
			$sapParams["name"] = $catID;

unset($sapParams["params"]);

$this->addByCreatorParam_handleConditions($sapParams, true);
		
			foreach($arrParams as $param){
				$type = UniteFunctionsUC::getVal($param, "type");
				
				$isSkip = false;
				
				switch($type) {
					case UniteCreatorDialogParam::PARAM_LISTING:
						$useFor = UniteFunctionsUC::getVal($param, "use_for");

switch($useFor){
							case "remote":
							case "filter":
							break;
							default:
								$listingParam = $param;
								$addPagination = true;
							break;
						}
					break;
					case UniteCreatorDialogParam::PARAM_POSTS_LIST:
						
						$addPagination = true;
						
						$postsListParam = $param;
						
						$showImageSizes = UniteFunctionsUC::getVal($postsListParam, "show_image_sizes");
						$showImageSizes = UniteFunctionsUC::strToBool($showImageSizes);
		
						if($showImageSizes == true)
							$this->addImageSizesParam($postsListParam);
						
						$isSkip = true;
						
					break;
				}
						
				if($isSkip == false)
					$this->addByCreatorParam($param);
				
			}
			
			if($isGeneralCategory == true && GlobalsUC::$isProVersion == false){
				$this->addFreeVersionInsideNotification();
			}
		}
		
		if(!empty($listingParam))
			$this->addMultisourceSections($listingParam);
		
		if(empty($postsListParam) === false)
			$this->addPostsQuerySection($postsListParam);
		
		if($addPagination == true){
			
			if(!empty($postsListParam))
				$this->addPaginationAndFilteringSection($postsListParam);
			else{
				
	          	$enablePagination = UniteFunctionsUC::getVal($listingParam, "enable_pagination");
	          	$enablePagination = UniteFunctionsUC::strToBool($enablePagination);
	
	          	$enableFiltering = UniteFunctionsUC::getVal($listingParam, "enable_ajax");
	          	$enableFiltering = UniteFunctionsUC::strToBool($enableFiltering);
	
	          	if($enableFiltering == true)
	          		$listingParam["is_filterable"] = true;
	
	          	$listingName = $listingParam["name"];
	
	          	$listingParam["condition"] = array($listingName."_source"=>array("posts","products"));
				
	          	if($enablePagination == true)
					$this->addPaginationAndFilteringSection($listingParam);
			}
			
		}
		
		//---- add schema section
		
		if(GlobalsUnlimitedElements::$enableSchema == true){
			
			if(empty($postsListParam) === false)
				$this->addSchemaSectionForPosts($postsListParam);
			
		}
				
		
		// add control by elementor conditions - from posts list, terms list etc.
		$this->addControls_byElementorConditions();
	}

/**
	 * add posts query section
	 */
	private function addPostsQuerySection($param){

$forWooCommerce = UniteFunctionsUC::getVal($param, "for_woocommerce_products");
		$forWooCommerce = UniteFunctionsUC::strToBool($forWooCommerce);

if($forWooCommerce === true)
			$label = esc_html__("Products Query", "unlimited-elements-for-elementor");
		else
			$label = esc_html__("Posts Query", "unlimited-elements-for-elementor");

$this->addSap($label, "section_query");

$this->addByCreatorParam($param);
	}

/**
	 * add multisource sections
	 */
	private function addMultisourceSections($listingParam){

$name = UniteFunctionsUC::getVal($listingParam, "name");
		$useFor = UniteFunctionsUC::getVal($listingParam, "use_for");

switch($useFor){
			case "remote":
			case "filter":
				return;
		}

$isForGallery = ($useFor === "gallery");
		$isForItems = ($useFor === "items");

//control to hide the items
		$this->addControl($name . "_source", "items", "show", "items", true);

//set text prefix
		$textPrefix = __("Items ", "unlimited-elements-for-elementor");

if($isForGallery === true)
			$textPrefix = __("Gallery ", "unlimited-elements-for-elementor");

//------ posts -------------
		$label = $textPrefix . __("Posts Query", "unlimited-elements-for-elementor");

$this->addSap($label, "uc_section_listing_posts_query");
		$this->addControl($name . "_source", "uc_section_listing_posts_query", "show", "posts", true);

$postParam = $listingParam;

$postParam["type"] = UniteCreatorDialogParam::PARAM_POSTS_LIST;
		$postParam["name"] = $name . "_posts";

$this->addByCreatorParam($postParam);

if($isForItems === true){
			//------ terms -------------
			$label = $textPrefix . __("Terms Query", "unlimited-elements-for-elementor");

$this->addSap($label, "uc_section_listing_terms_query");
			$this->addControl($name . "_source", "uc_section_listing_terms_query", "show", "terms", true);

$termParam = $listingParam;

$termParam["type"] = UniteCreatorDialogParam::PARAM_POST_TERMS;
			$termParam["name"] = $name . "_terms";

$this->addByCreatorParam($termParam);

//------ users -------------
			$label = $textPrefix . __("Users Query", "unlimited-elements-for-elementor");

$this->addSap($label, "uc_section_listing_users_query");
			$this->addControl($name . "_source", "uc_section_listing_users_query", "show", "users", true);

$usersParam = $listingParam;

$usersParam["type"] = UniteCreatorDialogParam::PARAM_USERS;
			$usersParam["name"] = $name . "_users";

$this->addByCreatorParam($usersParam);

//------ menu -------------
			$label = $textPrefix . __("Menu Query", "unlimited-elements-for-elementor");

$this->addSap($label, "uc_section_listing_menu_query");
			$this->addControl($name . "_source", "uc_section_listing_menu_query", "show", "menu", true);

$menuParam = $listingParam;

$menuParam["type"] = UniteCreatorDialogParam::PARAM_MENU;
			$menuParam["name"] = $name . "_menu";
			$menuParam["usefor"] = "multisource";

$this->addByCreatorParam($menuParam);

//------ gallery -------------
			$label = $textPrefix . __("Select Items Images", "unlimited-elements-for-elementor");

$this->addSap($label, "uc_section_listing_gallery");
			$this->addControl($name . "_source", "uc_section_listing_gallery", "show", "gallery", true);

$galleryParam = $listingParam;
			$galleryParam["type"] = UniteCreatorDialogParam::PARAM_GALLERY;
			$galleryParam["name"] = $name . "_gallery";
			$galleryParam["default_value"] = HelperProviderUC::getArrDynamicGalleryDefaults();
			$galleryParam["add_dynamic"] = true;

$this->addByCreatorParam($galleryParam);
		}

//woocommerce
		$isWooActive = UniteCreatorWooIntegrate::isWooActive();

if($isWooActive === true){
			$label = $textPrefix . __("Products Query", "unlimited-elements-for-elementor");

$this->addSap($label, "uc_section_listing_products_query");
			$this->addControl($name . "_source", "uc_section_listing_products_query", "show", "products", true);

$postParam["type"] = UniteCreatorDialogParam::PARAM_POSTS_LIST;
			$postParam["name"] = $name . "_products";
			$postParam["for_woocommerce_products"] = true;

$this->addByCreatorParam($postParam);
		}
	}
	
    public function loadXMLFile($filepath, $loadedSettingsType = null){
        parent::loadXMLFile($filepath, $loadedSettingsType);
    }

}