/*
 * (c) Copyright Ascensio System SIA 2010-2024
 *
 * This program is a free software product. You can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License (AGPL)
 * version 3 as published by the Free Software Foundation. In accordance with
 * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
 * that Ascensio System SIA expressly excludes the warranty of non-infringement
 * of any third-party rights.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
 * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
 * street, Riga, Latvia, EU, LV-1050.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */

"use strict";

(/**
 * @param {Window} window
 * @param {undefined} undefined
 */
function (window, undefined) {

	const Asc = window['Asc'];
	const AscCommon = window['AscCommon'];

	// Import
	let prot;
	const c_oAscMouseMoveDataTypes = Asc.c_oAscMouseMoveDataTypes;

	const c_oAscColor = Asc.c_oAscColor;
	const c_oAscFill = Asc.c_oAscFill;
	const c_oAscFillBlipType = Asc.c_oAscFillBlipType;
	const c_oAscChartTypeSettings = Asc.c_oAscChartTypeSettings;
	const c_oAscTickMark = Asc.c_oAscTickMark;
	const c_oAscAxisType = Asc.c_oAscAxisType;
	// ---------------------------------------------------------------------------------------------------------------

	const c_oAscArrUserColors = [10646501, 16749875, 1087211, 103817, 16760641, 16272775, 8765789, 14707685, 48336, 5729515, 16757719, 56805, 10081791, 12884479, 16751001, 6748927, 16762931, 6865407, 15650047, 16737894, 3407768, 16759142, 10852863, 6750176, 16774656, 13926655, 13815039, 3397375, 11927347, 16752947, 9404671, 4980531, 16744678, 3407830, 15919360, 16731553, 52479, 13330175, 16743219, 3386367, 14221056, 16737966, 1896960, 65484, 10970879, 16759296, 16711680, 13496832, 62072, 49906, 16734720, 10682112, 7890687, 16731610, 65406, 38655, 16747008, 59890, 12733951, 15859712, 47077, 15050496, 15224319, 10154496, 58807, 16724950, 1759488, 9981439, 15064320, 15893248, 16724883, 58737, 15007744, 36594, 12772608, 12137471, 6442495, 15039488, 16718470, 14274816, 53721, 16718545, 1625088, 15881472, 13419776, 32985, 16711800, 1490688, 16711884, 8991743, 13407488, 41932, 7978752, 15028480, 52387, 15007927, 12114176, 1421824, 55726, 13041893, 10665728, 30924, 49049, 14241024, 36530, 11709440, 13397504, 45710, 34214];

	function CreateAscColorCustom(r, g, b, auto) {
		let ret = new asc_CColor();
		ret.type = c_oAscColor.COLOR_TYPE_SRGB;
		ret.r = r;
		ret.g = g;
		ret.b = b;
		ret.a = 255;
		ret.Auto = (undefined === auto ? false : auto);
		return ret;
	}

	function CreateAscColor(unicolor) {
		if (null == unicolor || null == unicolor.color) {
			return new asc_CColor();
		}

		let ret = new asc_CColor();
		ret.r = unicolor.RGBA.R;
		ret.g = unicolor.RGBA.G;
		ret.b = unicolor.RGBA.B;
		ret.a = unicolor.RGBA.A;

		let _color = unicolor.color;
		switch (_color.type) {
			case c_oAscColor.COLOR_TYPE_SRGB:
			case c_oAscColor.COLOR_TYPE_SYS: {
				break;
			}
			case c_oAscColor.COLOR_TYPE_PRST:
			case c_oAscColor.COLOR_TYPE_SCHEME: {
				ret.type = _color.type;
				ret.value = _color.id;
				break;
			}
			default:
				break;
		}
		return ret;
	}

	let uuid = [];
	for (let i = 0; i < 256; i++) {
		uuid[i] = (i < 16 ? "0" : "") + (i).toString(16);
	}

	function CreateUUID(isNoDashes) {
		let d0 = Math.random() * 0xffffffff | 0;
		let d1 = Math.random() * 0xffffffff | 0;
		let d2 = Math.random() * 0xffffffff | 0;
		let d3 = Math.random() * 0xffffffff | 0;

		if (isNoDashes) return uuid[d0 & 0xff] + uuid[d0 >> 8 & 0xff] + uuid[d0 >> 16 & 0xff] + uuid[d0 >> 24 & 0xff] +
			uuid[d1 & 0xff] + uuid[d1 >> 8 & 0xff] + uuid[d1 >> 16 & 0x0f | 0x40] + uuid[d1 >> 24 & 0xff] +
			uuid[d2 & 0x3f | 0x80] + uuid[d2 >> 8 & 0xff] + uuid[d2 >> 16 & 0xff] + uuid[d2 >> 24 & 0xff] +
			uuid[d3 & 0xff] + uuid[d3 >> 8 & 0xff] + uuid[d3 >> 16 & 0xff] + uuid[d3 >> 24 & 0xff];
		else
			return uuid[d0 & 0xff] + uuid[d0 >> 8 & 0xff] + uuid[d0 >> 16 & 0xff] + uuid[d0 >> 24 & 0xff] + "-" +
				uuid[d1 & 0xff] + uuid[d1 >> 8 & 0xff] + "-" + uuid[d1 >> 16 & 0x0f | 0x40] + uuid[d1 >> 24 & 0xff] + "-" +
				uuid[d2 & 0x3f | 0x80] + uuid[d2 >> 8 & 0xff] + "-" + uuid[d2 >> 16 & 0xff] + uuid[d2 >> 24 & 0xff] +
				uuid[d3 & 0xff] + uuid[d3 >> 8 & 0xff] + uuid[d3 >> 16 & 0xff] + uuid[d3 >> 24 & 0xff];
	}

	function CreateGUID() {
		function s4() {
			return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
		}

		let val = '{' + s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4() + '}';
		val = val.toUpperCase();
		return val;
	}

	function CreateUInt32() {
		return Math.floor(Math.random() * 0x100000000);
	}

	function FixDurableId(val) {
		//numbers greater than 0x7FFFFFFE cause MS Office errors(ST_LongHexNumber by spec)
		let res = val & 0x7FFFFFFF;
		return (0x7FFFFFFF !== res) ? res : res - 1;
	}

	function CreateDurableId() {
		return FixDurableId(CreateUInt32());
	}

	function ExtendPrototype(dst, src) {
		for (let k in src.prototype) {
			dst.prototype[k] = src.prototype[k];
		}
	}

	function isFileBuild() {
		return window["NATIVE_EDITOR_ENJINE"] && !window["IS_NATIVE_EDITOR"] && !window["DoctRendererMode"];
	}

	function checkCanvasInDiv(sDivId) {
		let oDiv = document.getElementById(sDivId);
		if (!oDiv) {
			return null;
		}
		let aChildren = oDiv.children;
		let oCanvas = null, i;
		for (i = 0; i < aChildren.length; ++i) {
			if (aChildren[i].nodeName && aChildren[i].nodeName.toUpperCase() === 'CANVAS') {
				oCanvas = aChildren[i];
				break;
			}
		}
		if (null === oCanvas) {
			let rPR = AscCommon.AscBrowser.retinaPixelRatio;
			oCanvas = document.createElement('canvas');
			oCanvas.style.width = "100%";
			oCanvas.style.height = "100%";
			oDiv.appendChild(oCanvas);
			oCanvas.width = Math.round(oCanvas.clientWidth * rPR);
			oCanvas.height = Math.round(oCanvas.clientHeight * rPR);
		}
		return oCanvas;
	}

	function isValidJs(str) {
		try {
			eval("throw 0;" + str);
		} catch (e) {
			if (e === 0) return true;
		}
		return false;
	}


	function asc_menu_ReadPaddings(_params, _cursor){
		const _paddings = new Asc.asc_CPaddings();
		_paddings.read(_params, _cursor);
		return _paddings;
	}

	function asc_menu_ReadColor(_params, _cursor) {
		const _color = new Asc.asc_CColor();
		_color.read(_params, _cursor);
		return _color;
	}

	function parseJSDoc(jsDoc) {
		// function for parsing jsDoc (for builder method "AddCustomFunction")
		const result = [];

		// A regular expression for searching for JSDoc comments describing parameters, properties, and functions
		const jsDocRegex = /\/\*\*([\s\S]*?)\*\//g;
		const paramRegex = /@param\s+{(\??)(.+?)}\s+(?:(\[)?([\w.]+|\{[\w.]+\}))?(?:\s*=\s*([^@]+?)(?=\s|\)|$))?(?:\s+(.+))?/g;
		const propertyRegex = /@property\s+{(\??)(.+?)}\s+(?:(\[)?([\w.]+|\{[\w.]+\}))?(?:\s*=\s*([^@]+?)(?=\s|\)|$))?(?:\s+(.+))?/g;
	
		let match;
		while ((match = jsDocRegex.exec(jsDoc)) !== null) {
			const parsedData = {};
			const commentBlock = match[1].trim();
	
			// Parsing of function parameters
			const params = [];
			let paramMatch;
			while ((paramMatch = paramRegex.exec(commentBlock)) !== null) {
				const type = paramMatch[2];
				const isOptional = paramMatch[3] !== undefined || paramMatch[1] === '?';
				const name = paramMatch[4];
				const defaultValue = isOptional && paramMatch[5] !== undefined ? paramMatch[5].trim().replace(/\]$/, '') : undefined;
				const description = paramMatch[6] || '';
	
				params.push({
					type: type,
					name: name,
					isOptional: isOptional,
					defaultValue: defaultValue,
					description: description
				});
			}
	
			// Parsing properties
			const properties = [];
			let propertyMatch;
			while ((propertyMatch = propertyRegex.exec(commentBlock)) !== null) {
				const type = propertyMatch[2];
				const isOptional = propertyMatch[3] !== undefined || propertyMatch[1] === '?';
				const name = propertyMatch[4];
				const defaultValue = isOptional && propertyMatch[5] !== undefined ? propertyMatch[5].trim().replace(/\]$/, '') : undefined;
				const description = propertyMatch[6] || '';
	
				properties.push({
					type: type,
					name: name,
					isOptional: isOptional,
					defaultValue: defaultValue,
					description: description
				});
			}
	
			// Parsing what the function returns
			const returnRegex = /@returns?\s+{(.+?)}\s+(.+)/g;
			let returnInfo = null;
			const returnMatch = returnRegex.exec(commentBlock);
			if (returnMatch !== null) {
				returnInfo = {
					type: returnMatch[1],
					description: returnMatch[2]
				};
			}

			const regex = /@nameLocale\s+{([^}]+)}/;
			const nameMatch = regex.exec(commentBlock);
			const nameLocale = {};

			if (nameMatch && nameMatch[1]) {
				const localesAndNames = nameMatch[1].split(/\s*\|\s*/);
				localesAndNames.forEach(function (localeAndName) {
					const splitLocaleAndName = localeAndName.split(':');
					const locale = splitLocaleAndName[0];
					const name = splitLocaleAndName[1];
					nameLocale[locale.trim()] = name.trim();
				});
			}

	
			// Parsing function description
			const descriptionRegex = /\*\s*(.*)/g;
			const descriptionMatch = descriptionRegex.exec(commentBlock);
			const description = descriptionMatch ? descriptionMatch[1].trim() : '';
	
			parsedData.params = params;
			parsedData.properties = properties;
			parsedData.returnInfo = returnInfo;
			parsedData.description = description;
			parsedData.nameLocale = nameLocale;
			result.push(parsedData);
		}
	
		return result;
	};

	var c_oLicenseResult = {
		Error         : 1,
		Expired       : 2,
		Success       : 3,
		UnknownUser   : 4,
		Connections   : 5,
		ExpiredTrial  : 6,
		SuccessLimit  : 7,
		UsersCount    : 8,
		ConnectionsOS : 9,
		UsersCountOS  : 10,
		ExpiredLimited: 11,
		ConnectionsLiveOS: 12,
		ConnectionsLive: 13,
		UsersViewCount: 14,
		UsersViewCountOS: 15,
		NotBefore: 16
	};

	let c_oRights = {
		None: 0, Edit: 1, Review: 2, Comment: 3, View: 4
	};

	let c_oLicenseMode = {
		None: 0, Trial: 1, Developer: 2, Limited: 4
	};

	let EPluginDataType = {
		none: "none", text: "text", ole: "ole", html: "html", desktop: "desktop"
	};

	/** @constructor */
	function asc_CSignatureLine() {
		this.id = undefined;
		this.guid = "";
		this.signer1 = "";
		this.signer2 = "";
		this.email = "";

		this.instructions = "";
		this.showDate = false;

		this.valid = 0;

		this.image = "";

		this.date = "";
		this.isvisible = false;
		this.isrequested = false;
	}

	asc_CSignatureLine.prototype.correct = function () {
		if (this.id == null) this.id = "0";
		if (this.guid == null) this.guid = "";
		if (this.signer1 == null) this.signer1 = "";
		if (this.signer2 == null) this.signer2 = "";
		if (this.email == null) this.email = "";
		if (this.instructions == null) this.instructions = "";
		if (this.showDate == null) this.showDate = false;
		if (this.valid == null) this.valid = 0;
		if (this.image == null) this.image = "";
		if (this.date == null) this.date = "";
		if (this.isvisible == null) this.isvisible = false;
	};
	asc_CSignatureLine.prototype.asc_getId = function () {
		return this.id;
	};
	asc_CSignatureLine.prototype.asc_setId = function (v) {
		this.id = v;
	};
	asc_CSignatureLine.prototype.asc_getGuid = function () {
		return this.guid;
	};
	asc_CSignatureLine.prototype.asc_setGuid = function (v) {
		this.guid = v;
	};
	asc_CSignatureLine.prototype.asc_getSigner1 = function () {
		return this.signer1;
	};
	asc_CSignatureLine.prototype.asc_setSigner1 = function (v) {
		this.signer1 = v;
	};
	asc_CSignatureLine.prototype.asc_getSigner2 = function () {
		return this.signer2;
	};
	asc_CSignatureLine.prototype.asc_setSigner2 = function (v) {
		this.signer2 = v;
	};
	asc_CSignatureLine.prototype.asc_getEmail = function () {
		return this.email;
	};
	asc_CSignatureLine.prototype.asc_setEmail = function (v) {
		this.email = v;
	};
	asc_CSignatureLine.prototype.asc_getInstructions = function () {
		return this.instructions;
	};
	asc_CSignatureLine.prototype.asc_setInstructions = function (v) {
		this.instructions = v;
	};
	asc_CSignatureLine.prototype.asc_getShowDate = function () {
		return this.showDate !== false;
	};
	asc_CSignatureLine.prototype.asc_setShowDate = function (v) {
		this.showDate = v;
	};
	asc_CSignatureLine.prototype.asc_getValid = function () {
		return this.valid;
	};
	asc_CSignatureLine.prototype.asc_setValid = function (v) {
		this.valid = v;
	};
	asc_CSignatureLine.prototype.asc_getDate = function () {
		return this.date;
	};
	asc_CSignatureLine.prototype.asc_setDate = function (v) {
		this.date = v;
	};
	asc_CSignatureLine.prototype.asc_getVisible = function () {
		return this.isvisible;
	};
	asc_CSignatureLine.prototype.asc_setVisible = function (v) {
		this.isvisible = v;
	};
	asc_CSignatureLine.prototype.asc_getRequested = function () {
		return this.isrequested;
	};
	asc_CSignatureLine.prototype.asc_setRequested = function (v) {
		this.isrequested = v;
	};

	/**
	 * Класс asc_CAscEditorPermissions для прав редакторов
	 * -----------------------------------------------------------------------------
	 *
	 * @constructor
	 * @memberOf Asc
	 */
	function asc_CAscEditorPermissions() {
		this.licenseType = c_oLicenseResult.Error;
		this.licenseMode = c_oLicenseMode.None;
		this.isLight = false;
		this.rights = c_oRights.None;

		this.canCoAuthoring = true;
		this.canReaderMode = true;
		this.canBranding = false;
		this.customization = false;
		this.isAutosaveEnable = true;
		this.AutosaveMinInterval = 300;
		this.isAnalyticsEnable = false;
		this.buildVersion = null;
		this.buildNumber = null;
		this.liveViewerSupport = null;

		this.betaVersion = AscCommon.g_cIsBeta;

		return this;
	}

	asc_CAscEditorPermissions.prototype.asc_getLicenseType = function () {
		return this.licenseType;
	};
	asc_CAscEditorPermissions.prototype.asc_getCanCoAuthoring = function () {
		return this.canCoAuthoring;
	};
	asc_CAscEditorPermissions.prototype.asc_getCanReaderMode = function () {
		return this.canReaderMode;
	};
	asc_CAscEditorPermissions.prototype.asc_getCanBranding = function () {
		return this.canBranding;
	};
	asc_CAscEditorPermissions.prototype.asc_getCustomization = function () {
		return this.customization;
	};
	asc_CAscEditorPermissions.prototype.asc_getIsAutosaveEnable = function () {
		return this.isAutosaveEnable;
	};
	asc_CAscEditorPermissions.prototype.asc_getAutosaveMinInterval = function () {
		return this.AutosaveMinInterval;
	};
	asc_CAscEditorPermissions.prototype.asc_getIsAnalyticsEnable = function () {
		return this.isAnalyticsEnable;
	};
	asc_CAscEditorPermissions.prototype.asc_getIsLight = function () {
		return this.isLight;
	};
	asc_CAscEditorPermissions.prototype.asc_getLicenseMode = function () {
		return this.licenseMode;
	};
	asc_CAscEditorPermissions.prototype.asc_getRights = function () {
		return this.rights;
	};
	asc_CAscEditorPermissions.prototype.asc_getBuildVersion = function () {
		return this.buildVersion;
	};
	asc_CAscEditorPermissions.prototype.asc_getBuildNumber = function () {
		return this.buildNumber;
	};
	asc_CAscEditorPermissions.prototype.asc_getLiveViewerSupport = function () {
		return this.liveViewerSupport;
	};
	asc_CAscEditorPermissions.prototype.asc_getIsBeta = function () {
		return this.betaVersion === 'true';
	};

	asc_CAscEditorPermissions.prototype.setLicenseType = function (v) {
		this.licenseType = v;
	};
	asc_CAscEditorPermissions.prototype.setCanBranding = function (v) {
		this.canBranding = v;
	};
	asc_CAscEditorPermissions.prototype.setCustomization = function (v) {
		this.customization = v;
	};
	asc_CAscEditorPermissions.prototype.setIsLight = function (v) {
		this.isLight = v;
	};
	asc_CAscEditorPermissions.prototype.setLicenseMode = function (v) {
		this.licenseMode = v;
	};
	asc_CAscEditorPermissions.prototype.setRights = function (v) {
		this.rights = v;
	};
	asc_CAscEditorPermissions.prototype.setBuildVersion = function (v) {
		this.buildVersion = v;
	};
	asc_CAscEditorPermissions.prototype.setBuildNumber = function (v) {
		this.buildNumber = v;
	};
	asc_CAscEditorPermissions.prototype.setLiveViewerSupport = function (v) {
		this.liveViewerSupport = v;
	};

	function asc_CAxNumFmt(oAxis) {
		this.formatCode = "General";
		this.sourceLinked = true;
		this.axis = oAxis;
		if (oAxis) {
			let oNumFmt = oAxis.numFmt;
			if (oNumFmt) {
				this.formatCode = oNumFmt.formatCode;
				this.sourceLinked = oNumFmt.sourceLinked;
			}
		}
	}

	asc_CAxNumFmt.prototype.getFormatCode = function () {
		if (this.sourceLinked) {
			if (this.axis) {
				return this.axis.getSourceFormatCode();
			}
			else {
				return "General";
			}
		}
		return this.formatCode || "General";
	};
	asc_CAxNumFmt.prototype.putFormatCode = function (v) {
		this.formatCode = v;
	};
	asc_CAxNumFmt.prototype.getFormatCellsInfo = function () {
		let num_format = AscCommon.oNumFormatCache.get(this.getFormatCode());
		return num_format.getTypeInfo();
	};
	asc_CAxNumFmt.prototype.getSourceLinked = function () {
		return this.sourceLinked;
	};
	asc_CAxNumFmt.prototype.putSourceLinked = function (v) {
		this.sourceLinked = v;
	};
	asc_CAxNumFmt.prototype.isEqual = function (v) {
		if (!v) {
			return false;
		}
		return this.formatCode === v.formatCode && this.sourceLinked === v.sourceLinked;
	};
	asc_CAxNumFmt.prototype.isCorrect = function () {
		return typeof this.formatCode === "string" && this.formatCode.length > 0;
	};

	/** @constructor */
	function asc_ValAxisSettings() {
		this.minValRule = null;
		this.minVal = null;
		this.maxValRule = null;
		this.maxVal = null;
		this.invertValOrder = null;
		this.logScale = null;
		this.logBase = null;

		this.dispUnitsRule = null;
		this.units = null;


		this.showUnitsOnChart = null;
		this.majorTickMark = null;
		this.minorTickMark = null;
		this.tickLabelsPos = null;
		this.crossesRule = null;
		this.crosses = null;
		this.axisType = c_oAscAxisType.val;
		this.show = true;
		this.label = null;
		this.gridlines = null;
		this.numFmt = null;
		this.isRadar = false;
	}

	asc_ValAxisSettings.prototype.isEqual = function (oPr) {
		if (!oPr) {
			return false;
		}
		if (this.minValRule !== oPr.minValRule) {
			return false;
		}
		if (this.minVal !== oPr.minVal) {
			return false;
		}
		if (this.maxValRule !== oPr.maxValRule) {
			return false;
		}
		if (this.maxVal !== oPr.maxVal) {
			return false;
		}
		if (this.invertValOrder !== oPr.invertValOrder) {
			return false;
		}
		if (this.logScale !== oPr.logScale) {
			return false;
		}
		if (this.logBase !== oPr.logBase) {
			return false;
		}
		if (this.dispUnitsRule !== oPr.dispUnitsRule) {
			return false;
		}
		if (this.units !== oPr.units) {
			return false;
		}
		if (this.showUnitsOnChart !== oPr.showUnitsOnChart) {
			return false;
		}
		if (this.majorTickMark !== oPr.majorTickMark) {
			return false;
		}
		if (this.minorTickMark !== oPr.minorTickMark) {
			return false;
		}
		if (this.tickLabelsPos !== oPr.tickLabelsPos) {
			return false;
		}
		if (this.crossesRule !== oPr.crossesRule) {
			return false;
		}
		if (this.crosses !== oPr.crosses) {
			return false;
		}
		if (this.axisType !== oPr.axisType) {
			return false;
		}
		if (this.show !== oPr.show) {
			return false;
		}
		if (this.label !== oPr.label) {
			return false;
		}
		if (this.gridlines !== oPr.gridlines) {
			return false;
		}
		let bEqualNumFmt = false;
		if (this.numFmt) {
			bEqualNumFmt = this.numFmt.isEqual(oPr.numFmt);
		}
		else {
			bEqualNumFmt = (this.numFmt === oPr.numFmt);
		}
		if (!bEqualNumFmt) {
			return false;
		}
		return true;
	};
	asc_ValAxisSettings.prototype.putAxisType = function (v) {
		this.axisType = v;
	};
	asc_ValAxisSettings.prototype.putMinValRule = function (v) {
		this.minValRule = v;
	};
	asc_ValAxisSettings.prototype.putMinVal = function (v) {
		this.minVal = v;
	};
	asc_ValAxisSettings.prototype.putMaxValRule = function (v) {
		this.maxValRule = v;
	};
	asc_ValAxisSettings.prototype.putMaxVal = function (v) {
		this.maxVal = v;
	};
	asc_ValAxisSettings.prototype.putInvertValOrder = function (v) {
		this.invertValOrder = v;
	};
	asc_ValAxisSettings.prototype.putLogScale = function (v) {
		this.logScale = v;
	};
	asc_ValAxisSettings.prototype.putLogBase = function (v) {
		this.logBase = v;
	};
	asc_ValAxisSettings.prototype.putUnits = function (v) {
		this.units = v;
	};
	asc_ValAxisSettings.prototype.putShowUnitsOnChart = function (v) {
		this.showUnitsOnChart = v;
	};
	asc_ValAxisSettings.prototype.putMajorTickMark = function (v) {
		this.majorTickMark = v;
	};
	asc_ValAxisSettings.prototype.putMinorTickMark = function (v) {
		this.minorTickMark = v;
	};
	asc_ValAxisSettings.prototype.putTickLabelsPos = function (v) {
		this.tickLabelsPos = v;
	};
	asc_ValAxisSettings.prototype.putCrossesRule = function (v) {
		this.crossesRule = v;
	};
	asc_ValAxisSettings.prototype.putCrosses = function (v) {
		this.crosses = v;
	};
	asc_ValAxisSettings.prototype.putDispUnitsRule = function (v) {
		this.dispUnitsRule = v;
	};
	asc_ValAxisSettings.prototype.getAxisType = function () {
		return this.axisType;
	};
	asc_ValAxisSettings.prototype.getDispUnitsRule = function () {
		return this.dispUnitsRule;
	};
	asc_ValAxisSettings.prototype.getMinValRule = function () {
		return this.minValRule;
	};
	asc_ValAxisSettings.prototype.getMinVal = function () {
		return this.minVal;
	};
	asc_ValAxisSettings.prototype.getMaxValRule = function () {
		return this.maxValRule;
	};
	asc_ValAxisSettings.prototype.getMaxVal = function () {
		return this.maxVal;
	};
	asc_ValAxisSettings.prototype.getInvertValOrder = function () {
		return this.invertValOrder;
	};
	asc_ValAxisSettings.prototype.getLogScale = function () {
		return this.logScale;
	};
	asc_ValAxisSettings.prototype.getLogBase = function () {
		return this.logBase;
	};
	asc_ValAxisSettings.prototype.getUnits = function () {
		return this.units;
	};
	asc_ValAxisSettings.prototype.getShowUnitsOnChart = function () {
		return this.showUnitsOnChart;
	};
	asc_ValAxisSettings.prototype.getMajorTickMark = function () {
		return this.majorTickMark;
	};
	asc_ValAxisSettings.prototype.getMinorTickMark = function () {
		return this.minorTickMark;
	};
	asc_ValAxisSettings.prototype.getTickLabelsPos = function () {
		return this.tickLabelsPos;
	};
	asc_ValAxisSettings.prototype.getCrossesRule = function () {
		return this.crossesRule;
	};
	asc_ValAxisSettings.prototype.getCrosses = function () {
		return this.crosses;
	};
	asc_ValAxisSettings.prototype.setDefault = function () {
		this.putMinValRule(Asc.c_oAscValAxisRule.auto);
		this.putMaxValRule(Asc.c_oAscValAxisRule.auto);
		this.putTickLabelsPos(Asc.c_oAscTickLabelsPos.TICK_LABEL_POSITION_NEXT_TO);
		this.putInvertValOrder(false);
		this.putDispUnitsRule(Asc.c_oAscValAxUnits.none);
		this.putMajorTickMark(c_oAscTickMark.TICK_MARK_OUT);
		this.putMinorTickMark(c_oAscTickMark.TICK_MARK_NONE);
		this.putCrossesRule(Asc.c_oAscCrossesRule.auto);
		this.putShow(true);
	};
	asc_ValAxisSettings.prototype.getShow = function () {
		return this.show;
	};
	asc_ValAxisSettings.prototype.putShow = function (val) {
		this.show = val;
	};
	asc_ValAxisSettings.prototype.getLabel = function () {
		return this.label;
	};
	asc_ValAxisSettings.prototype.putLabel = function (v) {
		this.label = v;
	};
	asc_ValAxisSettings.prototype.getGridlines = function () {
		return this.gridlines;
	};
	asc_ValAxisSettings.prototype.putGridlines = function (v) {
		this.gridlines = v;
	};
	asc_ValAxisSettings.prototype.getNumFmt = function () {
		return this.numFmt;
	};
	asc_ValAxisSettings.prototype.putNumFmt = function (v) {
		this.numFmt = v;
	};
	asc_ValAxisSettings.prototype.isRadarAxis = function () {
		return this.isRadar;
	};
	asc_ValAxisSettings.prototype.putIsRadarAxis = function (v) {
		this.isRadar = v;
	};

	/** @constructor */
	function asc_CatAxisSettings() {
		this.intervalBetweenTick = null;
		this.intervalBetweenLabelsRule = null;
		this.intervalBetweenLabels = null;
		this.invertCatOrder = null;
		this.labelsAxisDistance = null;
		this.majorTickMark = null;
		this.minorTickMark = null;
		this.tickLabelsPos = null;
		this.crossesRule = null;
		this.crosses = null;
		this.labelsPosition = null;
		this.axisType = c_oAscAxisType.cat;
		this.crossMinVal = null;
		this.crossMaxVal = null;
		this.show = true;
		this.label = null;
		this.gridlines = null;
		this.numFmt = null;
		this.auto = false;
		this.isRadar = false;
	}

	asc_CatAxisSettings.prototype.isEqual = function (oPr) {
		if (!oPr) {
			return false;
		}
		if (this.intervalBetweenTick !== oPr.intervalBetweenTick) {
			return false;
		}
		if (this.intervalBetweenLabelsRule !== oPr.intervalBetweenLabelsRule) {
			return false;
		}
		if (this.intervalBetweenLabels !== oPr.intervalBetweenLabels) {
			return false;
		}
		if (this.invertCatOrder !== oPr.invertCatOrder) {
			return false;
		}
		if (this.labelsAxisDistance !== oPr.labelsAxisDistance) {
			return false;
		}
		if (this.majorTickMark !== oPr.majorTickMark) {
			return false;
		}
		if (this.minorTickMark !== oPr.minorTickMark) {
			return false;
		}
		if (this.tickLabelsPos !== oPr.tickLabelsPos) {
			return false;
		}
		if (this.crossesRule !== oPr.crossesRule) {
			return false;
		}
		if (this.crosses !== oPr.crosses) {
			return false;
		}
		if (this.labelsPosition !== oPr.labelsPosition) {
			return false;
		}
		if (this.axisType !== oPr.axisType) {
			return false;
		}
		if (this.crossMinVal !== oPr.crossMinVal) {
			return false;
		}
		if (this.crossMaxVal !== oPr.crossMaxVal) {
			return false;
		}
		if (this.show !== oPr.show) {
			return false;
		}
		if (this.label !== oPr.label) {
			return false;
		}
		if (this.gridlines !== oPr.gridlines) {
			return false;
		}
		if (this.auto !== oPr.auto) {
			return false;
		}
		let bEqualNumFmt = false;
		if (this.numFmt) {
			bEqualNumFmt = this.numFmt.isEqual(oPr.numFmt);
		}
		else {
			bEqualNumFmt = (this.numFmt === oPr.numFmt);
		}
		if (!bEqualNumFmt) {
			return false;
		}
		return true;
	};
	asc_CatAxisSettings.prototype.putIntervalBetweenTick = function (v) {
		this.intervalBetweenTick = v;
	};
	asc_CatAxisSettings.prototype.putIntervalBetweenLabelsRule = function (v) {
		this.intervalBetweenLabelsRule = v;
	};
	asc_CatAxisSettings.prototype.putIntervalBetweenLabels = function (v) {
		this.intervalBetweenLabels = v;
	};
	asc_CatAxisSettings.prototype.putInvertCatOrder = function (v) {
		this.invertCatOrder = v;
	};
	asc_CatAxisSettings.prototype.putLabelsAxisDistance = function (v) {
		this.labelsAxisDistance = v;
	};
	asc_CatAxisSettings.prototype.putMajorTickMark = function (v) {
		this.majorTickMark = v;
	};
	asc_CatAxisSettings.prototype.putMinorTickMark = function (v) {
		this.minorTickMark = v;
	};
	asc_CatAxisSettings.prototype.putTickLabelsPos = function (v) {
		this.tickLabelsPos = v;
	};
	asc_CatAxisSettings.prototype.putCrossesRule = function (v) {
		this.crossesRule = v;
	};
	asc_CatAxisSettings.prototype.putCrosses = function (v) {
		this.crosses = v;
	};
	asc_CatAxisSettings.prototype.putAxisType = function (v) {
		this.axisType = v;
	};
	asc_CatAxisSettings.prototype.putLabelsPosition = function (v) {
		this.labelsPosition = v;
	};
	asc_CatAxisSettings.prototype.getIntervalBetweenTick = function () {
		return this.intervalBetweenTick;
	};
	asc_CatAxisSettings.prototype.getIntervalBetweenLabelsRule = function () {
		return this.intervalBetweenLabelsRule;
	};
	asc_CatAxisSettings.prototype.getIntervalBetweenLabels = function () {
		return this.intervalBetweenLabels;
	};
	asc_CatAxisSettings.prototype.getInvertCatOrder = function () {
		return this.invertCatOrder;
	};
	asc_CatAxisSettings.prototype.getLabelsAxisDistance = function () {
		return this.labelsAxisDistance;
	};
	asc_CatAxisSettings.prototype.getMajorTickMark = function () {
		return this.majorTickMark;
	};
	asc_CatAxisSettings.prototype.getMinorTickMark = function () {
		return this.minorTickMark;
	};
	asc_CatAxisSettings.prototype.getTickLabelsPos = function () {
		return this.tickLabelsPos;
	};
	asc_CatAxisSettings.prototype.getCrossesRule = function () {
		return this.crossesRule;
	};
	asc_CatAxisSettings.prototype.getCrosses = function () {
		return this.crosses;
	};
	asc_CatAxisSettings.prototype.getAxisType = function () {
		return this.axisType;
	};
	asc_CatAxisSettings.prototype.getLabelsPosition = function () {
		return this.labelsPosition;
	};
	asc_CatAxisSettings.prototype.getCrossMinVal = function () {
		return this.crossMinVal;
	};
	asc_CatAxisSettings.prototype.getCrossMaxVal = function () {
		return this.crossMaxVal;
	};
	asc_CatAxisSettings.prototype.putCrossMinVal = function (val) {
		this.crossMinVal = val;
	};
	asc_CatAxisSettings.prototype.putCrossMaxVal = function (val) {
		this.crossMaxVal = val;
	};
	asc_CatAxisSettings.prototype.setDefault = function () {
		this.putIntervalBetweenLabelsRule(Asc.c_oAscBetweenLabelsRule.auto);
		this.putLabelsPosition(Asc.c_oAscLabelsPosition.betweenDivisions);
		this.putTickLabelsPos(Asc.c_oAscTickLabelsPos.TICK_LABEL_POSITION_NEXT_TO);
		this.putLabelsAxisDistance(100);
		this.putMajorTickMark(c_oAscTickMark.TICK_MARK_OUT);
		this.putMinorTickMark(c_oAscTickMark.TICK_MARK_NONE);
		this.putIntervalBetweenTick(1);
		this.putCrossesRule(Asc.c_oAscCrossesRule.auto);
		this.putShow(true);
		this.putAuto(true);
	};
	asc_CatAxisSettings.prototype.getShow = function () {
		return this.show;
	};
	asc_CatAxisSettings.prototype.putShow = function (val) {
		this.show = val;
	};
	asc_CatAxisSettings.prototype.getLabel = function () {
		return this.label;
	};
	asc_CatAxisSettings.prototype.putLabel = function (v) {
		this.label = v;
	};
	asc_CatAxisSettings.prototype.getGridlines = function () {
		return this.gridlines;
	};
	asc_CatAxisSettings.prototype.putGridlines = function (v) {
		this.gridlines = v;
	};
	asc_CatAxisSettings.prototype.getNumFmt = function () {
		return this.numFmt;
	};
	asc_CatAxisSettings.prototype.putNumFmt = function (v) {
		this.numFmt = v;
	};
	asc_CatAxisSettings.prototype.getAuto = function () {
		return this.auto;
	};
	asc_CatAxisSettings.prototype.putAuto = function (v) {
		this.auto = v;
	};
	asc_CatAxisSettings.prototype.isRadarAxis = function () {
		return this.isRadar;
	};
	asc_CatAxisSettings.prototype.putIsRadarAxis = function (v) {
		this.isRadar = v;
	};

	/** @constructor */
	function asc_ChartSettings() {
		this.style = null;
		this.title = null;
		this.rowCols = null;
		this.legendPos = null;
		this.dataLabelsPos = null;
		this.type = null;
		this.showSerName = null;
		this.showCatName = null;
		this.showVal = null;
		this.separator = null;
		this.inColumns = null;

		this.sRange = null;


		this.showMarker = null;
		this.bLine = null;
		this.smooth = null;
		this.chartSpace = null;

		this.bStartEdit = false;
		this.horizontalAxes = [];
		this.verticalAxes = [];
		this.depthAxes = [];

		this.view3D = null;

		this.displayTrendlinesEquation = false;
	}

	//TODO:remove this---------------------
	asc_ChartSettings.prototype.putHorAxisProps = function (v) {
		if (!AscCommon.isRealObject(v)) {
			this.horizontalAxes.length = 0;
		}
		else {
			this.horizontalAxes[0] = v;
		}
	};
	asc_ChartSettings.prototype.getHorAxisProps = function () {
		return this.horizontalAxes[0] || null;
	};
	asc_ChartSettings.prototype.putVertAxisProps = function (v) {
		if (!AscCommon.isRealObject(v)) {
			this.verticalAxes.length = 0;
		}
		else {
			this.verticalAxes[0] = v;
		}
	};
	asc_ChartSettings.prototype.getVertAxisProps = function () {
		return this.verticalAxes[0] || null;
	};
	asc_ChartSettings.prototype.putShowHorAxis = function (v) {
		let oAx = this.horizontalAxes[0];
		if (oAx) {
			oAx.putShow(v);
		}
	};
	asc_ChartSettings.prototype.getShowHorAxis = function () {
		let oAx = this.horizontalAxes[0];
		if (oAx) {
			return oAx.getShow();
		}
		return false;
	};
	asc_ChartSettings.prototype.putShowVerAxis = function (v) {
		let oAx = this.verticalAxes[0];
		if (oAx) {
			oAx.putShow(v);
		}
	};
	asc_ChartSettings.prototype.getShowVerAxis = function () {
		let oAx = this.verticalAxes[0];
		if (oAx) {
			return oAx.getShow();
		}
		return false;
	};
	asc_ChartSettings.prototype.putHorAxisLabel = function (v) {
		let oAx = this.horizontalAxes[0];
		if (oAx) {
			oAx.putLabel(v);
		}
	};
	asc_ChartSettings.prototype.getHorAxisLabel = function () {
		let oAx = this.horizontalAxes[0];
		if (oAx) {
			return oAx.getLabel();
		}
		return null;
	};
	asc_ChartSettings.prototype.putVertAxisLabel = function () {
		let oAx = this.verticalAxes[0];
		if (oAx) {
			return oAx.getLabel();
		}
		return null;
	};
	asc_ChartSettings.prototype.getVertAxisLabel = function () {
		let oAx = this.verticalAxes[0];
		if (oAx) {
			return oAx.getLabel();
		}
		return null;
	};
	asc_ChartSettings.prototype.putHorGridLines = function (v) {
		let oAx = this.verticalAxes[0];
		if (oAx) {
			oAx.putGridlines(v);
		}
	};
	asc_ChartSettings.prototype.getHorGridLines = function () {
		let oAx = this.verticalAxes[0];
		if (oAx) {
			return oAx.getGridlines();
		}
		return null;
	};
	asc_ChartSettings.prototype.putVertGridLines = function (v) {
		let oAx = this.horizontalAxes[0];
		if (oAx) {
			oAx.putGridlines(v);
		}
	};
	asc_ChartSettings.prototype.getVertGridLines = function () {
		let oAx = this.horizontalAxes[0];
		if (oAx) {
			return oAx.getGridlines();
		}
		return null;
	};
	//------------------------------
	asc_ChartSettings.prototype.getHorAxesProps = function () {
		return this.horizontalAxes;
	};
	asc_ChartSettings.prototype.getVertAxesProps = function () {
		return this.verticalAxes;
	};
	asc_ChartSettings.prototype.getDepthAxesProps = function () {
		return this.depthAxes;
	};
	asc_ChartSettings.prototype.getView3d = function () {
		if (this.chartSpace) {
			return this.chartSpace.getView3d();
		}
		return this.view3D ? this.view3D.createDuplicate() : null;
	};
	asc_ChartSettings.prototype.putView3d = function (v) {
		this.view3D = v;
	};
	asc_ChartSettings.prototype.setView3d = function (v) {
		this.putView3d(v);
		if (this.chartSpace) {
			if (v) {
				this.chartSpace.changeView3d(v.createDuplicate());
			}
			else {
				this.chartSpace.changeView3d(null);
			}
			this.updateChart();
		}
	};

	asc_ChartSettings.prototype.addHorAxesProps = function (v) {
		this.horizontalAxes.push(v);
	};
	asc_ChartSettings.prototype.addVertAxesProps = function (v) {
		this.verticalAxes.push(v);
	};
	asc_ChartSettings.prototype.addDepthAxesProps = function (v) {
		this.depthAxes.push(v);
	};
	asc_ChartSettings.prototype.removeAllAxesProps = function () {
		this.horizontalAxes.length = 0;
		this.verticalAxes.length = 0;
		this.depthAxes.length = 0;
	};
	asc_ChartSettings.prototype.equalBool = function (a, b) {
		return ((!!a) === (!!b));
	};
	asc_ChartSettings.prototype.isEqual = function (oPr) {
		if (!oPr) {
			return false;
		}
		if (this.style !== oPr.style) {
			return false;
		}
		if (this.title !== oPr.title) {
			return false;
		}
		if (this.rowCols !== oPr.rowCols) {
			return false;
		}
		if (this.legendPos !== oPr.legendPos) {
			return false;
		}
		if (this.dataLabelsPos !== oPr.dataLabelsPos) {
			return false;
		}
		if (this.type !== oPr.type) {
			return false;
		}
		if (!this.equalBool(this.showSerName, oPr.showSerName)) {
			return false;
		}
		if (!this.equalBool(this.showCatName, oPr.showCatName)) {
			return false;
		}
		if (!this.equalBool(this.showVal, oPr.showVal)) {
			return false;
		}

		if (this.separator !== oPr.separator && !(this.separator === ' ' && oPr.separator == null || oPr.separator === ' ' && this.separator == null)) {
			return false;
		}
		if (this.sRange !== oPr.sRange) {
			return false;
		}
		if (!this.equalBool(this.inColumns, oPr.inColumns)) {
			return false;
		}

		if (!this.equalBool(this.showMarker, oPr.showMarker)) {
			return false;
		}
		if (!this.equalBool(this.bLine, oPr.bLine)) {
			return false;
		}
		if (!this.equalBool(this.smooth, oPr.smooth)) {
			return false;
		}
		if (this.verticalAxes.length !== oPr.verticalAxes.length) {
			return false;
		}
		if (this.horizontalAxes.length !== oPr.horizontalAxes.length) {
			return false;
		}
		let nAx;
		for (nAx = 0; nAx < this.verticalAxes.length; ++nAx) {
			if (!this.verticalAxes[nAx].isEqual(oPr.verticalAxes[nAx])) {
				return false;
			}
		}
		for (nAx = 0; nAx < this.horizontalAxes.length; ++nAx) {
			if (!this.horizontalAxes[nAx].isEqual(oPr.horizontalAxes[nAx])) {
				return false;
			}
		}
		if (this.view3D && !oPr.view3D || !this.view3D && oPr.view3D) {
			return false;
		}
		if (this.view3D && oPr.view3D && !this.view3D.isEqual(oPr.view3D)) {
			return false;
		}
		if(this.displayTrendlinesEquation !== oPr.displayTrendlinesEquation) {
			return false;
		}
		return true;
	};
	asc_ChartSettings.prototype.isEmpty = function () {
		return this.isEqual(new asc_ChartSettings());
	};
	asc_ChartSettings.prototype.putShowMarker = function (v) {
		this.showMarker = v;
	};
	asc_ChartSettings.prototype.getShowMarker = function () {
		return this.showMarker;
	};
	asc_ChartSettings.prototype.putLine = function (v) {
		this.bLine = v;
	};
	asc_ChartSettings.prototype.getLine = function () {
		return this.bLine;
	};
	asc_ChartSettings.prototype.putRanges = function (aRanges) {
		if (Array.isArray(aRanges) && aRanges.length > 0) {
			let sRange = "=";
			for (let nRange = 0; nRange < aRanges.length; ++nRange) {
				if (nRange > 0) {
					sRange += ",";
				}
				sRange += aRanges[nRange];
			}
			this.sRange = sRange;
		}
		else {
			this.sRange = null;
		}
	};
	asc_ChartSettings.prototype.getRanges = function () {
		let sRange = this.sRange;
		if (typeof sRange === "string" && sRange > 0) {
			if (sRange.charAt(0) === '=') {
				sRange = sRange.slice(1);
			}
			return sRange.split(",");
		}
		else {
			return [];
		}
	};
	asc_ChartSettings.prototype.putSmooth = function (v) {
		this.smooth = v;
	};
	asc_ChartSettings.prototype.getSmooth = function () {
		return this.smooth;
	};
	asc_ChartSettings.prototype.putStyle = function (index) {
		if (!AscFormat.isRealNumber(index)) {
			this.style = null;
			return;
		}
		this.style = parseInt(index, 10);
		if (this.bStartEdit && this.chartSpace) {
			if (AscFormat.isRealNumber(this.style)) {
				let aStyle = AscCommon.g_oChartStyles[this.type] && AscCommon.g_oChartStyles[this.type][this.style - 1];
				if (Array.isArray(aStyle)) {
					this.chartSpace.applyChartStyleByIds(aStyle);
					this.updateChart();
				}
			}
		}
	};
	asc_ChartSettings.prototype.getStyle = function () {
		return this.style;
	};
	asc_ChartSettings.prototype.putRange = function (range) {
		this.sRange = range;
	};
	asc_ChartSettings.prototype.setRange = function (sRange) {
		if (this.chartSpace) {
			const oDataRefs = new AscFormat.CChartDataRefs(null);
			const nCheckResult = oDataRefs.checkDataRange(sRange, this.getInRows(), this.getType());
			if (nCheckResult !== Asc.c_oAscError.ID.No) {
				this.sendError(nCheckResult);
				return;
			}
			this.chartSpace.setRange(sRange);
			this.updateChart();
		}
	};
	asc_ChartSettings.prototype.isValidRange = function (sRange) {
		if (this.getRange() !== sRange) {
			const oDataRefs = new AscFormat.CChartDataRefs(null);
			const nCheckResult = oDataRefs.checkDataRange(sRange, this.getInRows(), this.getType());
			if (nCheckResult === Asc.c_oAscError.ID.MaxDataPointsError) {
				return nCheckResult;
			}
		}
		return AscFormat.isValidChartRange(sRange);
	};
	asc_ChartSettings.prototype.getRange = function () {
		if (this.chartSpace) {
			return this.chartSpace.getCommonRange();
		}
		return this.sRange;
	};
	asc_ChartSettings.prototype.putInColumns = function (inColumns) {
		this.inColumns = inColumns;
	};
	asc_ChartSettings.prototype.getInColumns = function () {
		return this.inColumns;
	};
	asc_ChartSettings.prototype.getInRows = function () {
		if (this.inColumns === true || this.inColumns === false) {
			return !this.inColumns;
		}
		return null;
	};
	asc_ChartSettings.prototype.putTitle = function (v) {
		this.title = v;
	};
	asc_ChartSettings.prototype.getTitle = function () {
		return this.title;
	};
	asc_ChartSettings.prototype.putRowCols = function (v) {
		this.rowCols = v;
	};
	asc_ChartSettings.prototype.getRowCols = function () {
		return this.rowCols;
	};
	asc_ChartSettings.prototype.putLegendPos = function (v) {
		this.legendPos = v;
	};
	asc_ChartSettings.prototype.putDataLabelsPos = function (v) {
		this.dataLabelsPos = v;
	};
	asc_ChartSettings.prototype.getLegendPos = function () {
		return this.legendPos;
	};
	asc_ChartSettings.prototype.getDataLabelsPos = function () {
		return this.dataLabelsPos;
	};
	asc_ChartSettings.prototype.getType = function () {
		if (this.chartSpace) {
			return this.chartSpace.getChartType();
		}
		return this.type;
	};
	asc_ChartSettings.prototype.checkParams = function () {
		if (this.type === null || this.type === Asc.c_oAscChartTypeSettings.comboAreaBar || this.type === Asc.c_oAscChartTypeSettings.comboBarLine || this.type === Asc.c_oAscChartTypeSettings.comboBarLineSecondary || this.type === Asc.c_oAscChartTypeSettings.comboCustom) {
			return;
		}
		if (AscFormat.getIsMarkerByType(this.type)) {
			this.showMarker = true;
		}
		else {
			this.showMarker = false;
		}
		if (AscFormat.getIsSmoothByType(this.type)) {
			this.smooth = true;
		}
		else {
			this.smooth = false;
		}
		if (AscFormat.getIsLineByType(this.type)) {
			this.bLine = true;
		}
		else {
			this.bLine = false;
		}
	};
	asc_ChartSettings.prototype.putType = function (v) {
		this.type = v;
		this.checkParams();
	};
	asc_ChartSettings.prototype.putShowSerName = function (v) {
		this.showSerName = v;
	};
	asc_ChartSettings.prototype.putShowCatName = function (v) {
		this.showCatName = v;
	};
	asc_ChartSettings.prototype.putShowVal = function (v) {
		this.showVal = v;
	};
	asc_ChartSettings.prototype.getShowSerName = function () {
		return this.showSerName;
	};
	asc_ChartSettings.prototype.getShowCatName = function () {
		return this.showCatName;
	};
	asc_ChartSettings.prototype.getShowVal = function () {
		return this.showVal;
	};
	asc_ChartSettings.prototype.putSeparator = function (v) {
		this.separator = v;
	};
	asc_ChartSettings.prototype.getSeparator = function () {
		return this.separator;
	};
	asc_ChartSettings.prototype.sendErrorOnChangeType = function (nType) {
		this.sendError(nType);
	};
	asc_ChartSettings.prototype.sendError = function (nType) {
		let oApi = Asc.editor || editor;
		if (oApi) {
			oApi.sendEvent("asc_onError", nType, Asc.c_oAscError.Level.NoCritical);
			if (oApi.UpdateInterfaceState) {
				oApi.UpdateInterfaceState();
			}
		}
	};
	asc_ChartSettings.prototype.changeType = function (type) {
		if (this.chartSpace) {
			if (type === Asc.c_oAscChartTypeSettings.stock) {
				if (!this.chartSpace.canChangeToStockChart()) {
					this.sendErrorOnChangeType(Asc.c_oAscError.ID.StockChartError);
					return false;
				}
			}
			if (type === Asc.c_oAscChartTypeSettings.comboCustom || type === Asc.c_oAscChartTypeSettings.comboAreaBar || type === Asc.c_oAscChartTypeSettings.comboBarLine || type === Asc.c_oAscChartTypeSettings.comboBarLineSecondary) {
				if (!this.chartSpace.canChangeToComboChart()) {
					this.sendErrorOnChangeType(Asc.c_oAscError.ID.ComboSeriesError);
					return false;
				}
			}
			this.putType(type);
			if (this.chartSpace) {
				let oController = this.chartSpace.getDrawingObjectsController();
				if (oController) {
					let oThis = this;
					let oChartSpace = this.chartSpace;
					oController.checkSelectedObjectsAndCallback(function () {
						oChartSpace.changeChartType(type);
						oThis.updateChart();
						let oApi = Asc.editor || editor;
						if (oApi) {
							if (oApi.UpdateInterfaceState) {
								oApi.UpdateInterfaceState();
							}
						}
					}, [], false, 0, []);
				}
			}
		}
		else {
			this.putType(type);
		}
		return true;
	};
	asc_ChartSettings.prototype.getSeries = function () {
		if (this.chartSpace) {
			return this.chartSpace.getAllSeries();
		}
		return [];
	};
	asc_ChartSettings.prototype.getCatValues = function () {
		if (this.chartSpace) {
			return this.chartSpace.getCatValues();
		}
		return [];
	};
	asc_ChartSettings.prototype.getCatFormula = function () {
		if (this.chartSpace) {
			return this.chartSpace.getCatFormula();
		}
		return "";
	};
	asc_ChartSettings.prototype.setCatFormula = function (sFormula) {
		if (this.chartSpace) {
			return this.chartSpace.setCatFormula(sFormula);
		}
		this.updateChart();
	};
	asc_ChartSettings.prototype.isValidCatFormula = function (sFormula) {
		if (sFormula === "" || sFormula === null) {
			return Asc.c_oAscError.ID.No;
		}
		return AscFormat.ExecuteNoHistory(function () {
			let oCat = new AscFormat.CCat();
			return oCat.setValues(sFormula).getError();
		}, this, []);
	};
	asc_ChartSettings.prototype.switchRowCol = function () {
		let nError = Asc.c_oAscError.ID.No;
		if (this.chartSpace) {
			nError = this.chartSpace.switchRowCol();
		}
		this.updateChart();
		return nError;
	};
	asc_ChartSettings.prototype.addSeries = function () {
		let oRet = null;
		if (this.chartSpace) {
			oRet = this.chartSpace.addNewSeries();
		}
		this.updateChart();
		return oRet;
	};
	asc_ChartSettings.prototype.addScatterSeries = function () {
		let oRet = null;
		if (this.chartSpace) {
			oRet = this.chartSpace.addNewSeries();
		}
		this.updateChart();
		return oRet;
	};
	asc_ChartSettings.prototype.startEdit = function () {
		this.bStartEdit = true;
		AscCommon.History.Create_NewPoint();
		AscCommon.History.StartTransaction();
	};
	asc_ChartSettings.prototype.updateInterface = function () {
		let oApi = Asc.editor || editor;
		if (oApi) {
			if (oApi.UpdateInterfaceState) {
				oApi.UpdateInterfaceState();
			}
			else {
				let oWbView = oApi.wb;
				if (oWbView) {
					let oWSView = oWbView.getWorksheet();
					if (oWSView) {
						let oRender = oWSView.objectRender;
						if (oRender) {
							oRender.sendGraphicObjectProps();
						}
					}
				}
			}
		}
	};
	asc_ChartSettings.prototype.endEdit = function () {
		if (AscCommon.History.Is_LastPointEmpty()) {
			this.cancelEdit();
			return;
		}
		this.bStartEdit = false;
		AscCommon.History.EndTransaction();
		this.updateChart();
		this.updateInterface();
	};
	asc_ChartSettings.prototype.cancelEdit = function () {
		this.bStartEdit = false;
		const bLastPointEmpty = AscCommon.History.Is_LastPointEmpty();
		AscCommon.History.EndTransaction();
		if (!bLastPointEmpty) {
			AscCommon.History.Undo();
			AscCommon.History.Clear_Redo();
		}
		AscCommon.History._sendCanUndoRedo();
		this.updateChart();
		this.updateInterface();
	};
	asc_ChartSettings.prototype.startEditData = function () {
		AscCommon.History.SavePointIndex();
	};
	asc_ChartSettings.prototype.cancelEditData = function () {
		AscCommon.History.UndoToPointIndex();
		this.updateChart();
	};
	asc_ChartSettings.prototype.endEditData = function () {
		AscCommon.History.ClearPointIndex();
		this.updateChart();
	};
	asc_ChartSettings.prototype.updateChart = function () {
		if (this.chartSpace) {
			this.chartSpace.onDataUpdate();
		}
	};
	asc_ChartSettings.prototype.getDisplayTrendlinesEquation = function() {
		return this.displayTrendlinesEquation;
	};
	asc_ChartSettings.prototype.putDisplayTrendlinesEquation = function(v) {
		this.displayTrendlinesEquation = v;
	};

	/** @constructor */
	function asc_CRect(x, y, width, height) {
		// private members
		this._x = x;
		this._y = y;
		this._width = width;
		this._height = height;
	}

	asc_CRect.prototype.asc_getX = function () {
		return this._x;
	};
	asc_CRect.prototype.asc_getY = function () {
		return this._y;
	};
	asc_CRect.prototype.asc_getWidth = function () {
		return this._width;
	};
	asc_CRect.prototype.asc_getHeight = function () {
		return this._height;
	};


	const STANDART_COLORS_MAP = {};
	STANDART_COLORS_MAP[0x000000] = "Black";
	STANDART_COLORS_MAP[0xFFFFFF] = "White";
	STANDART_COLORS_MAP[0xFF0000] = "Red";
	STANDART_COLORS_MAP[0x00FF00] = "Green";
	STANDART_COLORS_MAP[0x0000FF] = "Blue";
	STANDART_COLORS_MAP[0xFFFF00] = "Yellow";
	STANDART_COLORS_MAP[0xFF00FF] = "Purple";
	STANDART_COLORS_MAP[0x00FFFF] = "Aqua";
	STANDART_COLORS_MAP[0x800000] = "Dark Red";
	STANDART_COLORS_MAP[0x008000] = "Dark Green";
	STANDART_COLORS_MAP[0x000080] = "Dark Blue";
	STANDART_COLORS_MAP[0x808000] = "Dark Yellow";
	STANDART_COLORS_MAP[0x800080] = "Dark Purple";
	STANDART_COLORS_MAP[0x008080] = "Dark Teal";
	STANDART_COLORS_MAP[0xC0C0C0] = "Light Gray";
	STANDART_COLORS_MAP[0x808080] = "Gray";
	STANDART_COLORS_MAP[0x9999FF] = "Light Blue";
	STANDART_COLORS_MAP[0x993366] = "Pink";
	STANDART_COLORS_MAP[0xFFFFCC] = "Light Yellow";
	STANDART_COLORS_MAP[0xCCFFFF] = "Sky Blue";
	STANDART_COLORS_MAP[0x660066] = "Dark Purple";
	STANDART_COLORS_MAP[0xFF8080] = "Rose";
	STANDART_COLORS_MAP[0x0066CC] = "Blue";
	STANDART_COLORS_MAP[0xCCCCFF] = "Light Blue";
	STANDART_COLORS_MAP[0x00CCFF] = "Turquosie";
	STANDART_COLORS_MAP[0xCCFFCC] = "Light Green";
	STANDART_COLORS_MAP[0xFFFF99] = "Light Yellow";
	STANDART_COLORS_MAP[0x99CCFF] = "Light Blue";
	STANDART_COLORS_MAP[0xFF99CC] = "Pink";
	STANDART_COLORS_MAP[0xCC99FF] = "Lavender";
	STANDART_COLORS_MAP[0xFFCC99] = "Light Orange";
	STANDART_COLORS_MAP[0x3366FF] = "Blue";
	STANDART_COLORS_MAP[0x33CCCC] = "Teal";
	STANDART_COLORS_MAP[0x99CC00] = "Green";
	STANDART_COLORS_MAP[0xFFCC00] = "Gold";
	STANDART_COLORS_MAP[0xFF9900] = "Orange";
	STANDART_COLORS_MAP[0xFF6600] = "Orange";
	STANDART_COLORS_MAP[0x666699] = "Indigo";
	STANDART_COLORS_MAP[0x969696] = "Gray";
	STANDART_COLORS_MAP[0x003366] = "Dark Blue";
	STANDART_COLORS_MAP[0x339966] = "Green";
	STANDART_COLORS_MAP[0x003300] = "Dark Green";
	STANDART_COLORS_MAP[0x333300] = "Dark Yellow";
	STANDART_COLORS_MAP[0x993300] = "Brown";
	STANDART_COLORS_MAP[0x333399] = "Indigo";
	STANDART_COLORS_MAP[0x333333] = "Dark Gray";


	/**
	 * Класс CColor для работы с цветами
	 * -----------------------------------------------------------------------------
	 *
	 * @constructor
	 * @memberOf window
	 */

	function CColor(r, g, b, a) {
		this.r = (undefined == r) ? 0 : r;
		this.g = (undefined == g) ? 0 : g;
		this.b = (undefined == b) ? 0 : b;
		this.a = (undefined == a) ? 1 : a;
	}

	CColor.prototype.constructor = CColor;
	CColor.prototype.getR = function () {
		return this.r
	};
	CColor.prototype.get_r = function () {
		return this.r
	};
	CColor.prototype.put_r = function (v) {
		this.r = v;
		this.hex = undefined;
	};
	CColor.prototype.getG = function () {
		return this.g
	};
	CColor.prototype.get_g = function () {
		return this.g;
	};
	CColor.prototype.put_g = function (v) {
		this.g = v;
		this.hex = undefined;
	};
	CColor.prototype.getB = function () {
		return this.b
	};
	CColor.prototype.get_b = function () {
		return this.b;
	};
	CColor.prototype.put_b = function (v) {
		this.b = v;
		this.hex = undefined;
	};
	CColor.prototype.getA = function () {
		return this.a;
	};
	CColor.prototype.get_hex = function () {
		if (!this.hex) {
			let r = this.r.toString(16);
			let g = this.g.toString(16);
			let b = this.b.toString(16);
			this.hex = (r.length == 1 ? "0" + r : r) + (g.length == 1 ? "0" + g : g) + (b.length == 1 ? "0" + b : b);
		}
		return this.hex;
	};

	CColor.prototype.Compare = function (Color) {
		return (this.r === Color.r && this.g === Color.g && this.b === Color.b && this.a === Color.a);
	};
	CColor.prototype.Copy = function () {
		return new CColor(this.r, this.g, this.b, this.a);
	};

	CColor.prototype.getVal = function () {
		return (((this.r << 16) & 0xFF0000) + ((this.g << 8) & 0xFF00) + this.b);
	};

	CColor.prototype.getColorName = function () {
		return (new asc_CColor(this.r, this.g, this.b)).asc_getName();
	};

	CColor.prototype.getAscColor = function () {
		return (new asc_CColor(this.r, this.g, this.b));
	};
	CColor.prototype.fromAscColor = function (oAscColor) {
		return new CColor(oAscColor.r, oAscColor.g, oAscColor.b);
	};

	/** @constructor */
	function asc_CColor() {
		this.type = c_oAscColor.COLOR_TYPE_SRGB;
		this.value = null;
		this.r = 0;
		this.g = 0;
		this.b = 0;
		this.a = 255;

		this.Auto = false;

		this.Mods = [];
		this.ColorSchemeId = -1;
		this.EffectValue = 0;
		if (1 === arguments.length) {
			this.r = arguments[0].r;
			this.g = arguments[0].g;
			this.b = arguments[0].b;
		}
		else {
			if (3 <= arguments.length) {
				this.r = arguments[0];
				this.g = arguments[1];
				this.b = arguments[2];
			}
			if (4 === arguments.length) {
				this.a = arguments[3];
			}
		}
	}

	asc_CColor.prototype.constructor = asc_CColor;
	asc_CColor.prototype.asc_getR = function () {
		return this.r
	};
	asc_CColor.prototype.asc_putR = function (v) {
		this.r = v;
		this.hex = undefined;
	};
	asc_CColor.prototype.asc_getG = function () {
		return this.g;
	};
	asc_CColor.prototype.asc_putG = function (v) {
		this.g = v;
		this.hex = undefined;
	};
	asc_CColor.prototype.asc_getB = function () {
		return this.b;
	};
	asc_CColor.prototype.asc_putB = function (v) {
		this.b = v;
		this.hex = undefined;
	};
	asc_CColor.prototype.asc_getA = function () {
		return this.a;
	};
	asc_CColor.prototype.asc_putA = function (v) {
		this.a = v;
		this.hex = undefined;
	};
	asc_CColor.prototype.asc_getType = function () {
		return this.type;
	};
	asc_CColor.prototype.asc_putType = function (v) {
		this.type = v;
	};
	asc_CColor.prototype.asc_getValue = function () {
		return this.value;
	};
	asc_CColor.prototype.asc_putValue = function (v) {
		this.value = v;
	};
	asc_CColor.prototype.asc_getHex = function () {
		if (!this.hex) {
			let a = this.a.toString(16);
			let r = this.r.toString(16);
			let g = this.g.toString(16);
			let b = this.b.toString(16);
			this.hex = (a.length == 1 ? "0" + a : a) + (r.length == 1 ? "0" + r : r) + (g.length == 1 ? "0" + g : g) + (b.length == 1 ? "0" + b : b);
		}
		return this.hex;
	};
	asc_CColor.prototype.asc_getColor = function () {
		return new CColor(this.r, this.g, this.b);
	};
	asc_CColor.prototype.asc_putAuto = function (v) {
		this.Auto = v;
	};
	asc_CColor.prototype.asc_getAuto = function () {
		return this.Auto;
	};
	asc_CColor.prototype.getColorDiff = function (nC1, nC2) {
		let nC1R = (nC1 >> 16) & 0xFF;
		let nC1G = (nC1 >> 8) & 0xFF;
		let nC1B = nC1 & 0xFF;
		let nC2R = (nC2 >> 16) & 0xFF;
		let nC2G = (nC2 >> 8) & 0xFF;
		let nC2B = nC2 & 0xFF;
		let lab1 = this.RGB2LAB(nC1R, nC1G, nC1B);
		let lab2 = this.RGB2LAB(nC2R, nC2G, nC2B);

		const d2r = AscCommon.deg2rad;

		const L1 = lab1[0];
		const a1 = lab1[1];
		const b1 = lab1[2];

		const L2 = lab2[0];
		const a2 = lab2[1];
		const b2 = lab2[2];

		const k_L = 1.0, k_C = 1.0, k_H = 1.0;
		const deg360InRad = d2r(360.0);
		const deg180InRad = d2r(180.0);
		const pow25To7 = 6103515625.0; /* Math.pow(25, 7) */

		let C1 = Math.sqrt((a1 * a1) + (b1 * b1));
		let C2 = Math.sqrt((a2 * a2) + (b2 * b2));
		let barC = (C1 + C2) / 2.0;
		let G = 0.5 * (1 - Math.sqrt(Math.pow(barC, 7) / (Math.pow(barC, 7) + pow25To7)));
		let a1Prime = (1.0 + G) * a1;
		let a2Prime = (1.0 + G) * a2;
		let CPrime1 = Math.sqrt((a1Prime * a1Prime) + (b1 * b1));
		let CPrime2 = Math.sqrt((a2Prime * a2Prime) + (b2 * b2));
		let hPrime1;
		const fAE = function (a, b) {
			return Math.abs(a - b) < 1e-15;
		};
		if (fAE(b1, 0.0) && fAE(a1Prime, 0.0)) hPrime1 = 0.0; else {
			hPrime1 = Math.atan2(b1, a1Prime);
			if (hPrime1 < 0) hPrime1 += deg360InRad;
		}
		let hPrime2;
		if (fAE(b2, 0.0) && fAE(a2Prime, 0.0)) hPrime2 = 0.0; else {
			hPrime2 = Math.atan2(b2, a2Prime);
			if (hPrime2 < 0) hPrime2 += deg360InRad;
		}

		let deltaLPrime = L2 - L1;
		let deltaCPrime = CPrime2 - CPrime1;
		let deltahPrime;
		let CPrimeProduct = CPrime1 * CPrime2;
		if (fAE(CPrimeProduct, 0.0)) deltahPrime = 0; else {
			deltahPrime = hPrime2 - hPrime1;
			if (deltahPrime < -deg180InRad) deltahPrime += deg360InRad; else if (deltahPrime > deg180InRad) deltahPrime -= deg360InRad;
		}
		let deltaHPrime = 2.0 * Math.sqrt(CPrimeProduct) * Math.sin(deltahPrime / 2.0);

		let barLPrime = (L1 + L2) / 2.0;
		let barCPrime = (CPrime1 + CPrime2) / 2.0;
		let barhPrime, hPrimeSum = hPrime1 + hPrime2;
		if (fAE(CPrime1 * CPrime2, 0.0)) {
			barhPrime = hPrimeSum;
		}
		else {
			if (Math.abs(hPrime1 - hPrime2) <= deg180InRad) barhPrime = hPrimeSum / 2.0; else {
				if (hPrimeSum < deg360InRad) barhPrime = (hPrimeSum + deg360InRad) / 2.0; else barhPrime = (hPrimeSum - deg360InRad) / 2.0;
			}
		}
		let T = 1.0 - (0.17 * Math.cos(barhPrime - d2r(30.0))) + (0.24 * Math.cos(2.0 * barhPrime)) + (0.32 * Math.cos((3.0 * barhPrime) + d2r(6.0))) - (0.20 * Math.cos((4.0 * barhPrime) - d2r(63.0)));
		let deltaTheta = d2r(30.0) * Math.exp(-Math.pow((barhPrime - d2r(275.0)) / d2r(25.0), 2.0));
		let R_C = 2.0 * Math.sqrt(Math.pow(barCPrime, 7.0) / (Math.pow(barCPrime, 7.0) + pow25To7));
		let S_L = 1 + ((0.015 * Math.pow(barLPrime - 50.0, 2.0)) / Math.sqrt(20 + Math.pow(barLPrime - 50.0, 2.0)));
		let S_C = 1 + (0.045 * barCPrime);
		let S_H = 1 + (0.015 * barCPrime * T);
		let R_T = (-Math.sin(2.0 * deltaTheta)) * R_C;

		let deltaE = Math.sqrt(Math.pow(deltaLPrime / (k_L * S_L), 2.0) + Math.pow(deltaCPrime / (k_C * S_C), 2.0) + Math.pow(deltaHPrime / (k_H * S_H), 2.0) + (R_T * (deltaCPrime / (k_C * S_C)) * (deltaHPrime / (k_H * S_H))));

		return deltaE;
	};
	asc_CColor.prototype.RGB2LAB = function (R, G, B) {
		let r, g, b, X, Y, Z, fx, fy, fz, xr, yr, zr;
		let Ls, as, bs;
		let eps = 216.0 / 24389.0;
		let k = 24389.0 / 27.0;

		let Xr = 0.964221;  // reference white D50
		let Yr = 1.0;
		let Zr = 0.825211;

		// RGB to XYZ
		r = R / 255; //R 0..1
		g = G / 255; //G 0..1
		b = B / 255; //B 0..1

		// assuming sRGB (D65)
		if (r <= 0.04045) r = r / 12; else r = Math.pow((r + 0.055) / 1.055, 2.4);

		if (g <= 0.04045) g = g / 12; else g = Math.pow((g + 0.055) / 1.055, 2.4);

		if (b <= 0.04045) b = b / 12; else b = Math.pow((b + 0.055) / 1.055, 2.4);


		X = 0.436052025 * r + 0.385081593 * g + 0.143087414 * b;
		Y = 0.222491598 * r + 0.71688606 * g + 0.060621486 * b;
		Z = 0.013929122 * r + 0.097097002 * g + 0.71418547 * b;

		// XYZ to Lab
		xr = X / Xr;
		yr = Y / Yr;
		zr = Z / Zr;

		if (xr > eps) fx = Math.pow(xr, 1 / 3.); else fx = ((k * xr + 16.) / 116.);

		if (yr > eps) fy = Math.pow(yr, 1 / 3.); else fy = ((k * yr + 16.) / 116.);

		if (zr > eps) fz = Math.pow(zr, 1 / 3.); else fz = ((k * zr + 16.) / 116);

		Ls = (116 * fy) - 16;
		as = 500 * (fx - fy);
		bs = 200 * (fy - fz);

		let lab = [];
		lab[0] = (2.55 * Ls + .5) >> 0;
		lab[1] = (as + .5) >> 0;
		lab[2] = (bs + .5) >> 0;
		return lab;
	};
	asc_CColor.prototype.asc_getName = function () {
		const nColorVal = this.getVal();
		if (STANDART_COLORS_MAP.hasOwnProperty(nColorVal)) {
			return STANDART_COLORS_MAP[nColorVal];
		}
		let dMinDistance = 1000000;
		let sMinName = "Black";
		for (let nCurColor in STANDART_COLORS_MAP) {
			if (STANDART_COLORS_MAP.hasOwnProperty(nCurColor)) {
				let dDist = this.getColorDiff(nColorVal, nCurColor);
				if (dDist < dMinDistance) {
					dMinDistance = dDist;
					sMinName = STANDART_COLORS_MAP[nCurColor];
				}
			}
		}
		return sMinName;
	};
	asc_CColor.prototype.getVal = function () {
		return (((this.r << 16) & 0xFF0000) + ((this.g << 8) & 0xFF00) + this.b);
	};
	asc_CColor.prototype.asc_putEffectValue = function (v) {
		let dVal = Math.abs(v);
		dVal = ((dVal * 100 + 0.5) >> 0) / 100;
		if (v < 0) {
			dVal = -dVal;
		}
		this.EffectValue = dVal;
	};
	asc_CColor.prototype.asc_getEffectValue = function () {
		return this.EffectValue;
	};
	asc_CColor.prototype.print = function () {
		console.log("Color");
		console.log("r: " + this.r);
		console.log("g: " + this.g);
		console.log("b: " + this.b);
		console.log("effect val: " + this.asc_getEffectValue());
		console.log("name: " + this.asc_getName());
		console.log("name in scheme: " + this.asc_getNameInColorScheme());
		console.log("---------------");
	};
	asc_CColor.prototype.asc_getNameInColorScheme = function () {
		if (this.ColorSchemeId === -1) {
			return null;
		}
		switch (this.ColorSchemeId) {
			// bg1,tx1,bg2,tx2,accent1 - accent6
			case 6: {
				return "background 1";
			}
			case 15: {
				return "text 1";
			}
			case 7: {
				return "background 2";
			}
			case 16: {
				return "text 2";
			}
			case 0: {
				return "accent 1";
			}
			case 1: {
				return "accent 2";
			}
			case 2: {
				return "accent 3";
			}
			case 3: {
				return "accent 4";
			}
			case 4: {
				return "accent 5";
			}
			case 5: {
				return "accent 6";
			}
		}
		return null;
	};
	asc_CColor.prototype.setColorSchemeId = function (v) {
		this.ColorSchemeId = v;
		if (!AscFormat.isRealNumber(this.ColorSchemeId)) {
			this.ColorSchemeId = -1;
		}
	};

	/** @constructor */
	function asc_CTextBorder(obj) {
		if (obj) {
			if (obj.Color instanceof asc_CColor) {
				this.Color = obj.Color;
			}
			else {
				this.Color = (undefined != obj.Color && null != obj.Color) ? CreateAscColorCustom(obj.Color.r, obj.Color.g, obj.Color.b) : null;
			}
			this.Size = (undefined != obj.Size) ? obj.Size : null;
			this.Value = (undefined != obj.Value) ? obj.Value : null;
			this.Space = (undefined != obj.Space) ? obj.Space : null;
		}
		else {
			this.Color = CreateAscColorCustom(0, 0, 0);
			this.Size = 0.5 * window["AscCommonWord"].g_dKoef_pt_to_mm;
			this.Value = window["AscCommonWord"].border_Single;
			this.Space = 0;
		}
	}

	asc_CTextBorder.prototype.asc_getColor = function () {
		return this.Color;
	};
	asc_CTextBorder.prototype.asc_putColor = function (v) {
		this.Color = v;
	};
	asc_CTextBorder.prototype.asc_getSize = function () {
		return this.Size;
	};
	asc_CTextBorder.prototype.asc_putSize = function (v) {
		this.Size = v;
	};
	asc_CTextBorder.prototype.asc_getValue = function () {
		return this.Value;
	};
	asc_CTextBorder.prototype.asc_putValue = function (v) {
		this.Value = v;
	};
	asc_CTextBorder.prototype.asc_getSpace = function () {
		return this.Space;
	};
	asc_CTextBorder.prototype.asc_putSpace = function (v) {
		this.Space = v;
	};
	asc_CTextBorder.prototype.asc_getForSelectedCells = function () {
		return this.ForSelectedCells;
	};
	asc_CTextBorder.prototype.asc_putForSelectedCells = function (v) {
		this.ForSelectedCells = v;
	};

	/** @constructor */
	function asc_CParagraphBorders(obj) {

		if (obj) {
			this.Left = (undefined != obj.Left && null != obj.Left) ? new asc_CTextBorder(obj.Left) : null;
			this.Top = (undefined != obj.Top && null != obj.Top) ? new asc_CTextBorder(obj.Top) : null;
			this.Right = (undefined != obj.Right && null != obj.Right) ? new asc_CTextBorder(obj.Right) : null;
			this.Bottom = (undefined != obj.Bottom && null != obj.Bottom) ? new asc_CTextBorder(obj.Bottom) : null;
			this.Between = (undefined != obj.Between && null != obj.Between) ? new asc_CTextBorder(obj.Between) : null;
		}
		else {
			this.Left = null;
			this.Top = null;
			this.Right = null;
			this.Bottom = null;
			this.Between = null;
		}
	}

	asc_CParagraphBorders.prototype.asc_getLeft = function () {
		return this.Left;
	};
	asc_CParagraphBorders.prototype.asc_putLeft = function (v) {
		this.Left = (v) ? new asc_CTextBorder(v) : null;
	};
	asc_CParagraphBorders.prototype.asc_getTop = function () {
		return this.Top;
	};
	asc_CParagraphBorders.prototype.asc_putTop = function (v) {
		this.Top = (v) ? new asc_CTextBorder(v) : null;
	};
	asc_CParagraphBorders.prototype.asc_getRight = function () {
		return this.Right;
	};
	asc_CParagraphBorders.prototype.asc_putRight = function (v) {
		this.Right = (v) ? new asc_CTextBorder(v) : null;
	};
	asc_CParagraphBorders.prototype.asc_getBottom = function () {
		return this.Bottom;
	};
	asc_CParagraphBorders.prototype.asc_putBottom = function (v) {
		this.Bottom = (v) ? new asc_CTextBorder(v) : null;
	};
	asc_CParagraphBorders.prototype.asc_getBetween = function () {
		return this.Between;
	};
	asc_CParagraphBorders.prototype.asc_putBetween = function (v) {
		this.Between = (v) ? new asc_CTextBorder(v) : null;
	};

	/** @constructor */
	function asc_CCustomListType(obj) {
		this.type = null;

		this.imageId = null;
		this.token = null;

		this.char = null;
		this.specialFont = null;

		this.numberingType = null;
		if (obj) {
			this.fillFromObject(obj);
		}
	}

	asc_CCustomListType.prototype.fillFromObject = function (obj) {
		if (obj.type) this.type = obj.type;
		if (obj.imageId) this.imageId = obj.imageId;
		if (obj.token) this.token = obj.token;
		if (obj.char) this.char = obj.char;
		if (obj.specialFont) this.specialFont = obj.specialFont;
		if (obj.numberingType) this.numberingType = obj.numberingType;
	};
	asc_CCustomListType.prototype.setType = function (pr) {
		this.type = pr;
	};
	asc_CCustomListType.prototype.setImageId = function (pr) {
		this.imageId = pr;
	};
	asc_CCustomListType.prototype.setToken = function (pr) {
		this.token = pr;
	};
	asc_CCustomListType.prototype.setChar = function (pr) {
		this.char = pr;
	};
	asc_CCustomListType.prototype.setSpecialFont = function (pr) {
		this.specialFont = pr;
	};
	asc_CCustomListType.prototype.setNumberingType = function (pr) {
		this.numberingType = pr;
	};
	asc_CCustomListType.prototype.getType = function () {
		return this.type;
	};
	asc_CCustomListType.prototype.getImageId = function () {
		return this.imageId;
	};
	asc_CCustomListType.prototype.getToken = function () {
		return this.token;
	};
	asc_CCustomListType.prototype.getChar = function () {
		return this.char;
	};
	asc_CCustomListType.prototype.getSpecialFont = function () {
		return this.specialFont;
	};
	asc_CCustomListType.prototype.getNumberingType = function () {
		return this.numberingType;
	};

	/** @constructor */
	function asc_CListType(obj) {

		if (obj) {
			this.Type = (undefined == obj.Type) ? null : obj.Type;
			this.SubType = (undefined == obj.Type) ? null : obj.SubType;
			this.Custom = (undefined == obj.Type) ? null : new asc_CCustomListType(obj.Custom);
		}
		else {
			this.Type = null;
			this.SubType = null;
			this.Custom = null;
		}
	}

	asc_CListType.prototype.asc_getListType = function () {
		return this.Type;
	};
	asc_CListType.prototype.asc_getListSubType = function () {
		return this.SubType;
	};

	asc_CListType.prototype.asc_getListCustom = function () {
		return this.Custom;
	};

	/** @constructor */
	function asc_CTextFontFamily(obj) {

		if (obj) {
			this.Name = (undefined != obj.Name) ? obj.Name : null; 		// "Times New Roman"
			this.Index = (undefined != obj.Index) ? obj.Index : null;	// -1
		}
		else {
			this.Name = "Times New Roman";
			this.Index = -1;
		}
	}

	asc_CTextFontFamily.prototype.asc_getName = function () {
		let _name = AscFonts.g_fontApplication ? AscFonts.g_fontApplication.NameToInterface[this.Name] : null;
		return _name ? _name : this.Name;
	};
	asc_CTextFontFamily.prototype.asc_getIndex = function () {
		return this.Index;
	};
	asc_CTextFontFamily.prototype.asc_putName = function (v) {
		this.Name = v;
	};
	asc_CTextFontFamily.prototype.asc_putIndex = function (v) {
		this.Index = v;
	};

	/** @constructor */
	function asc_CParagraphTab(Pos, Value, Leader) {
		this.Pos = Pos;
		this.Value = Value;
		this.Leader = Leader;
	}

	asc_CParagraphTab.prototype.asc_getValue = function () {
		return this.Value;
	};
	asc_CParagraphTab.prototype.asc_putValue = function (v) {
		this.Value = v;
	};
	asc_CParagraphTab.prototype.asc_getPos = function () {
		return this.Pos;
	};
	asc_CParagraphTab.prototype.asc_putPos = function (v) {
		this.Pos = v;
	};
	asc_CParagraphTab.prototype.asc_getLeader = function () {
		if (Asc.c_oAscTabLeader.Heavy === this.Leader) return Asc.c_oAscTabLeader.Underscore;

		return this.Leader;
	};
	asc_CParagraphTab.prototype.asc_putLeader = function (v) {
		this.Leader = v;
	};

	/** @constructor */
	function asc_CParagraphTabs(obj) {
		this.Tabs = [];

		if (undefined != obj) {
			let Count = obj.Tabs.length;
			for (let Index = 0; Index < Count; Index++) {
				this.Tabs.push(new asc_CParagraphTab(obj.Tabs[Index].Pos, obj.Tabs[Index].Value, obj.Tabs[Index].Leader));
			}
		}
	}

	asc_CParagraphTabs.prototype.asc_getCount = function () {
		return this.Tabs.length;
	};
	asc_CParagraphTabs.prototype.asc_getTab = function (Index) {
		return this.Tabs[Index];
	};
	asc_CParagraphTabs.prototype.asc_addTab = function (Tab) {
		this.Tabs.push(Tab)
	};
	asc_CParagraphTabs.prototype.asc_clear = function () {
		this.Tabs.length = 0;
	};

	/** @constructor */
	function asc_CParagraphShd(obj) {

		if (obj) {
			this.Value = (undefined != obj.Value) ? obj.Value : null;

			// TODO: В UI пока поддерживается ровно два типа заливки Nil, Clear
			if (null !== this.Value && this.Value !== Asc.c_oAscShd.Nil) this.Value = Asc.c_oAscShd.Clear;

			if (obj.GetSimpleColor) {

				if (Asc.c_oAscShd.Clear === obj.Value && obj.Unifill && obj.Unifill.fill && obj.Unifill.fill.type === c_oAscFill.FILL_TYPE_SOLID && obj.Unifill.fill.color) {
					this.Color = CreateAscColor(obj.Unifill.fill.color);
				}
				else {
					let oColor = obj.GetSimpleColor();
					if (oColor.Auto) this.Color = null; else this.Color = CreateAscColorCustom(oColor.r, oColor.g, oColor.b, oColor.Auto);
				}
			}
			else {
				if (obj.Unifill && obj.Unifill.fill && obj.Unifill.fill.type === c_oAscFill.FILL_TYPE_SOLID && obj.Unifill.fill.color) {
					this.Color = CreateAscColor(obj.Unifill.fill.color);
				}
				else {
					this.Color = (undefined != obj.Color && null != obj.Color) ? CreateAscColorCustom(obj.Color.r, obj.Color.g, obj.Color.b) : null;
				}
			}
		}
		else {

			// TODO: Пока мы не работает отдельно с Color и Fill, поэтому пишем и тот и другой
			this.Value = Asc.c_oAscShdNil;
			this.Color = CreateAscColorCustom(255, 255, 255);
			this.Fill = CreateAscColorCustom(255, 255, 255);
		}
	}

	asc_CParagraphShd.prototype.asc_getValue = function () {
		return this.Value;
	};
	asc_CParagraphShd.prototype.asc_putValue = function (v) {
		this.Value = v;
	};
	asc_CParagraphShd.prototype.asc_getColor = function () {
		return this.Color;
	};
	asc_CParagraphShd.prototype.asc_putColor = function (v) {
		this.Color = (v) ? v : null;
		this.Fill = (v) ? v : null;
	};

	/** @constructor */
	function asc_CParagraphFrame(obj) {
		if (obj) {
			this.FromDropCapMenu = false;

			this.DropCap = obj.DropCap;
			this.H = obj.H;
			this.HAnchor = obj.HAnchor;
			this.HRule = obj.HRule;
			this.HSpace = obj.HSpace;
			this.Lines = obj.Lines;
			this.VAnchor = obj.VAnchor;
			this.VSpace = obj.VSpace;
			this.W = obj.W;
			this.Wrap = obj.Wrap;
			this.X = obj.X;
			this.XAlign = obj.XAlign;
			this.Y = obj.Y;
			this.YAlign = obj.YAlign;
			this.Brd = (undefined != obj.Brd && null != obj.Brd) ? new asc_CParagraphBorders(obj.Brd) : null;
			this.Shd = (undefined != obj.Shd && null != obj.Shd) ? new asc_CParagraphShd(obj.Shd) : null;
			this.FontFamily = (undefined != obj.FontFamily && null != obj.FontFamily) ? new asc_CTextFontFamily(obj.FontFamily) : null;
		}
		else {
			this.FromDropCapMenu = false;

			this.DropCap = undefined;
			this.H = undefined;
			this.HAnchor = undefined;
			this.HRule = undefined;
			this.HSpace = undefined;
			this.Lines = undefined;
			this.VAnchor = undefined;
			this.VSpace = undefined;
			this.W = undefined;
			this.Wrap = undefined;
			this.X = undefined;
			this.XAlign = undefined;
			this.Y = undefined;
			this.YAlign = undefined;
			this.Shd = null;
			this.Brd = null;
			this.FontFamily = null;
		}
	}

	asc_CParagraphFrame.prototype.asc_getDropCap = function () {
		return this.DropCap;
	};
	asc_CParagraphFrame.prototype.asc_putDropCap = function (v) {
		this.DropCap = v;
	};
	asc_CParagraphFrame.prototype.asc_getH = function () {
		return this.H;
	};
	asc_CParagraphFrame.prototype.asc_putH = function (v) {
		this.H = v;
	};
	asc_CParagraphFrame.prototype.asc_getHAnchor = function () {
		return this.HAnchor;
	};
	asc_CParagraphFrame.prototype.asc_putHAnchor = function (v) {
		this.HAnchor = v;
	};
	asc_CParagraphFrame.prototype.asc_getHRule = function () {
		return this.HRule;
	};
	asc_CParagraphFrame.prototype.asc_putHRule = function (v) {
		this.HRule = v;
	};
	asc_CParagraphFrame.prototype.asc_getHSpace = function () {
		return this.HSpace;
	};
	asc_CParagraphFrame.prototype.asc_putHSpace = function (v) {
		this.HSpace = v;
	};
	asc_CParagraphFrame.prototype.asc_getLines = function () {
		return this.Lines;
	};
	asc_CParagraphFrame.prototype.asc_putLines = function (v) {
		this.Lines = v;
	};
	asc_CParagraphFrame.prototype.asc_getVAnchor = function () {
		return this.VAnchor;
	};
	asc_CParagraphFrame.prototype.asc_putVAnchor = function (v) {
		this.VAnchor = v;
	};
	asc_CParagraphFrame.prototype.asc_getVSpace = function () {
		return this.VSpace;
	};
	asc_CParagraphFrame.prototype.asc_putVSpace = function (v) {
		this.VSpace = v;
	};
	asc_CParagraphFrame.prototype.asc_getW = function () {
		return this.W;
	};
	asc_CParagraphFrame.prototype.asc_putW = function (v) {
		this.W = v;
	};
	asc_CParagraphFrame.prototype.asc_getWrap = function () {
		return this.Wrap;
	};
	asc_CParagraphFrame.prototype.asc_putWrap = function (v) {
		this.Wrap = v;
	};
	asc_CParagraphFrame.prototype.asc_getX = function () {
		return this.X;
	};
	asc_CParagraphFrame.prototype.asc_putX = function (v) {
		this.X = v;
	};
	asc_CParagraphFrame.prototype.asc_getXAlign = function () {
		return this.XAlign;
	};
	asc_CParagraphFrame.prototype.asc_putXAlign = function (v) {
		this.XAlign = v;
	};
	asc_CParagraphFrame.prototype.asc_getY = function () {
		return this.Y;
	};
	asc_CParagraphFrame.prototype.asc_putY = function (v) {
		this.Y = v;
	};
	asc_CParagraphFrame.prototype.asc_getYAlign = function () {
		return this.YAlign;
	};
	asc_CParagraphFrame.prototype.asc_putYAlign = function (v) {
		this.YAlign = v;
	};
	asc_CParagraphFrame.prototype.asc_getBorders = function () {
		return this.Brd;
	};
	asc_CParagraphFrame.prototype.asc_putBorders = function (v) {
		this.Brd = v;
	};
	asc_CParagraphFrame.prototype.asc_getShade = function () {
		return this.Shd;
	};
	asc_CParagraphFrame.prototype.asc_putShade = function (v) {
		this.Shd = v;
	};
	asc_CParagraphFrame.prototype.asc_getFontFamily = function () {
		return this.FontFamily;
	};
	asc_CParagraphFrame.prototype.asc_putFontFamily = function (v) {
		this.FontFamily = v;
	};
	asc_CParagraphFrame.prototype.asc_putFromDropCapMenu = function (v) {
		this.FromDropCapMenu = v;
	};

	/** @constructor */
	function asc_CParagraphSpacing(obj) {

		if (obj) {
			this.Line = (undefined != obj.Line) ? obj.Line : null; // Расстояние между строками внутри абзаца
			this.LineRule = (undefined != obj.LineRule) ? obj.LineRule : null; // Тип расстрояния между строками
			this.Before = (undefined != obj.Before) ? obj.Before : null; // Дополнительное расстояние до абзаца
			this.After = (undefined != obj.After) ? obj.After : null; // Дополнительное расстояние после абзаца
		}
		else {
			this.Line = undefined; // Расстояние между строками внутри абзаца
			this.LineRule = undefined; // Тип расстрояния между строками
			this.Before = undefined; // Дополнительное расстояние до абзаца
			this.After = undefined; // Дополнительное расстояние после абзаца
		}
	}

	asc_CParagraphSpacing.prototype.asc_getLine = function () {
		return this.Line;
	};
	asc_CParagraphSpacing.prototype.asc_getLineRule = function () {
		return this.LineRule;
	};
	asc_CParagraphSpacing.prototype.asc_getBefore = function () {
		return this.Before;
	};
	asc_CParagraphSpacing.prototype.asc_getAfter = function () {
		return this.After;
	};
	asc_CParagraphSpacing.prototype.asc_putLine = function (v) {
		this.Line = v;
	};
	asc_CParagraphSpacing.prototype.asc_putLineRule = function (v) {
		this.LineRule = v;
	};
	asc_CParagraphSpacing.prototype.asc_putBefore = function (v) {
		this.Before = v;
	};
	asc_CParagraphSpacing.prototype.asc_putAfter = function (v) {
		this.After = v;
	};

	/** @constructor */
	function asc_CParagraphInd(obj) {
		if (obj) {
			this.Left = (undefined != obj.Left) ? obj.Left : null; // Левый отступ
			this.Right = (undefined != obj.Right) ? obj.Right : null; // Правый отступ
			this.FirstLine = (undefined != obj.FirstLine) ? obj.FirstLine : null; // Первая строка
		}
		else {
			this.Left = undefined; // Левый отступ
			this.Right = undefined; // Правый отступ
			this.FirstLine = undefined; // Первая строка
		}
	}

	asc_CParagraphInd.prototype.asc_getLeft = function () {
		return this.Left;
	};
	asc_CParagraphInd.prototype.asc_putLeft = function (v) {
		this.Left = v;
	};
	asc_CParagraphInd.prototype.asc_getRight = function () {
		return this.Right;
	};
	asc_CParagraphInd.prototype.asc_putRight = function (v) {
		this.Right = v;
	};
	asc_CParagraphInd.prototype.asc_getFirstLine = function () {
		return this.FirstLine;
	};
	asc_CParagraphInd.prototype.asc_putFirstLine = function (v) {
		this.FirstLine = v;
	};

	/** @constructor */
	function asc_CParagraphProperty(obj) {

		if (obj) {
			this.Bidi = undefined !== obj.Bidi ? obj.Bidi : undefined;
			this.ContextualSpacing = (undefined != obj.ContextualSpacing) ? obj.ContextualSpacing : null;
			this.Ind = (undefined != obj.Ind && null != obj.Ind) ? new asc_CParagraphInd(obj.Ind) : null;
			this.KeepLines = (undefined != obj.KeepLines) ? obj.KeepLines : null;
			this.KeepNext = (undefined != obj.KeepNext) ? obj.KeepNext : undefined;
			this.WidowControl = (undefined != obj.WidowControl ? obj.WidowControl : undefined);
			this.PageBreakBefore = (undefined != obj.PageBreakBefore) ? obj.PageBreakBefore : null;
			this.Spacing = (undefined != obj.Spacing && null != obj.Spacing) ? new asc_CParagraphSpacing(obj.Spacing) : null;
			this.Brd = (undefined != obj.Brd && null != obj.Brd) ? new asc_CParagraphBorders(obj.Brd) : null;
			this.Shd = (undefined != obj.Shd && null != obj.Shd) ? new asc_CParagraphShd(obj.Shd) : null;
			this.Tabs = (undefined != obj.Tabs) ? new asc_CParagraphTabs(obj.Tabs) : undefined;
			this.DefaultTab = obj.DefaultTab != null ? obj.DefaultTab : window["AscCommonWord"].Default_Tab_Stop;
			this.Locked = (undefined != obj.Locked && null != obj.Locked) ? obj.Locked : false;
			this.CanAddTable = (undefined != obj.CanAddTable) ? obj.CanAddTable : true;

			this.FramePr = (undefined != obj.FramePr) ? new asc_CParagraphFrame(obj.FramePr) : undefined;
			this.CanAddDropCap = (undefined != obj.CanAddDropCap) ? obj.CanAddDropCap : false;
			this.CanAddImage = (undefined != obj.CanAddImage) ? obj.CanAddImage : false;

			this.Subscript = (undefined != obj.Subscript) ? obj.Subscript : undefined;
			this.Superscript = (undefined != obj.Superscript) ? obj.Superscript : undefined;
			this.SmallCaps = (undefined != obj.SmallCaps) ? obj.SmallCaps : undefined;
			this.AllCaps = (undefined != obj.AllCaps) ? obj.AllCaps : undefined;
			this.Strikeout = (undefined != obj.Strikeout) ? obj.Strikeout : undefined;
			this.DStrikeout = (undefined != obj.DStrikeout) ? obj.DStrikeout : undefined;
			this.TextSpacing = (undefined != obj.TextSpacing) ? obj.TextSpacing : undefined;
			this.Position = (undefined != obj.Position) ? obj.Position : undefined;
			this.Jc = (undefined != obj.Jc) ? obj.Jc : undefined;
			this.ListType = (undefined != obj.ListType) ? obj.ListType : undefined;
			this.OutlineLvl = (undefined != obj.OutlineLvl) ? obj.OutlineLvl : undefined;
			this.OutlineLvlStyle = (undefined != obj.OutlineLvlStyle) ? obj.OutlineLvlStyle : false;
			this.SuppressLineNumbers = undefined !== obj.SuppressLineNumbers ? obj.SuppressLineNumbers : false;
			this.Bullet = obj.Bullet;
			let oBullet = obj.Bullet;
			if (oBullet) {
				oBullet.FirstTextPr = obj.FirstTextPr;
			}
			this.Ligatures = undefined !== obj.Ligatures ? obj.Ligatures : undefined;

			this.CanDeleteBlockCC = undefined !== obj.CanDeleteBlockCC ? obj.CanDeleteBlockCC : true;
			this.CanEditBlockCC = undefined !== obj.CanEditBlockCC ? obj.CanEditBlockCC : true;
			this.CanDeleteInlineCC = undefined !== obj.CanDeleteInlineCC ? obj.CanDeleteInlineCC : true;
			this.CanEditInlineCC = undefined !== obj.CanEditInlineCC ? obj.CanEditInlineCC : true;
		}
		else {
			//ContextualSpacing : false,            // Удалять ли интервал между параграфами одинакового стиля
			//
			//    Ind :
			//    {
			//        Left      : 0,                    // Левый отступ
			//        Right     : 0,                    // Правый отступ
			//        FirstLine : 0                     // Первая строка
			//    },
			//
			//    Jc : align_Left,                      // Прилегание параграфа
			//
			//    KeepLines : false,                    // переносить параграф на новую страницу,
			//                                          // если на текущей он целиком не убирается
			//    KeepNext  : false,                    // переносить параграф вместе со следующим параграфом
			//
			//    PageBreakBefore : false,              // начинать параграф с новой страницы

			this.Bidi = undefined;
			this.ContextualSpacing = undefined;
			this.Ind = new asc_CParagraphInd();
			this.KeepLines = undefined;
			this.KeepNext = undefined;
			this.WidowControl = undefined;
			this.PageBreakBefore = undefined;
			this.Spacing = new asc_CParagraphSpacing();
			this.Brd = undefined;
			this.Shd = undefined;
			this.Locked = false;
			this.CanAddTable = true;
			this.Tabs = undefined;

			this.Subscript = undefined;
			this.Superscript = undefined;
			this.SmallCaps = undefined;
			this.AllCaps = undefined;
			this.Strikeout = undefined;
			this.DStrikeout = undefined;
			this.TextSpacing = undefined;
			this.Position = undefined;
			this.Jc = undefined;
			this.ListType = undefined;
			this.OutlineLvl = undefined;
			this.OutlineLvlStyle = false;
			this.SuppressLineNumbers = false;
			this.Bullet = undefined;
			this.Ligatures = undefined;

			this.CanDeleteBlockCC = true;
			this.CanEditBlockCC = true;
			this.CanDeleteInlineCC = true;
			this.CanEditInlineCC = true;
		}
	}
	
	asc_CParagraphProperty.prototype.asc_getRtlDirection = function() {
		return this.Bidi;
	};
	asc_CParagraphProperty.prototype.asc_putRtlDirection = function(v) {
		this.Bidi = v;
	};
	asc_CParagraphProperty.prototype.asc_getContextualSpacing = function () {
		return this.ContextualSpacing;
	};
	asc_CParagraphProperty.prototype.asc_putContextualSpacing = function (v) {
		this.ContextualSpacing = v;
	};
	asc_CParagraphProperty.prototype.asc_getInd = function () {
		return this.Ind;
	};
	asc_CParagraphProperty.prototype.asc_putInd = function (v) {
		this.Ind = v;
	};
	asc_CParagraphProperty.prototype.asc_getJc = function () {
		return this.Jc;
	};
	asc_CParagraphProperty.prototype.asc_putJc = function (v) {
		this.Jc = v;
	};
	asc_CParagraphProperty.prototype.asc_getKeepLines = function () {
		return this.KeepLines;
	};
	asc_CParagraphProperty.prototype.asc_putKeepLines = function (v) {
		this.KeepLines = v;
	};
	asc_CParagraphProperty.prototype.asc_getKeepNext = function () {
		return this.KeepNext;
	};
	asc_CParagraphProperty.prototype.asc_putKeepNext = function (v) {
		this.KeepNext = v;
	};
	asc_CParagraphProperty.prototype.asc_getPageBreakBefore = function () {
		return this.PageBreakBefore;
	};
	asc_CParagraphProperty.prototype.asc_putPageBreakBefore = function (v) {
		this.PageBreakBefore = v;
	};
	asc_CParagraphProperty.prototype.asc_getWidowControl = function () {
		return this.WidowControl;
	};
	asc_CParagraphProperty.prototype.asc_putWidowControl = function (v) {
		this.WidowControl = v;
	};
	asc_CParagraphProperty.prototype.asc_getSpacing = function () {
		return this.Spacing;
	};
	asc_CParagraphProperty.prototype.asc_putSpacing = function (v) {
		this.Spacing = v;
	};
	asc_CParagraphProperty.prototype.asc_getBorders = function () {
		return this.Brd;
	};
	asc_CParagraphProperty.prototype.asc_putBorders = function (v) {
		this.Brd = v;
	};
	asc_CParagraphProperty.prototype.asc_getShade = function () {
		return this.Shd;
	};
	asc_CParagraphProperty.prototype.asc_putShade = function (v) {
		this.Shd = v;
	};
	asc_CParagraphProperty.prototype.asc_getLocked = function () {
		return this.Locked;
	};
	asc_CParagraphProperty.prototype.asc_getCanAddTable = function () {
		return this.CanAddTable;
	};
	asc_CParagraphProperty.prototype.asc_getSubscript = function () {
		return this.Subscript;
	};
	asc_CParagraphProperty.prototype.asc_putSubscript = function (v) {
		this.Subscript = v;
	};
	asc_CParagraphProperty.prototype.asc_getSuperscript = function () {
		return this.Superscript;
	};
	asc_CParagraphProperty.prototype.asc_putSuperscript = function (v) {
		this.Superscript = v;
	};
	asc_CParagraphProperty.prototype.asc_getSmallCaps = function () {
		return this.SmallCaps;
	};
	asc_CParagraphProperty.prototype.asc_putSmallCaps = function (v) {
		this.SmallCaps = v;
	};
	asc_CParagraphProperty.prototype.asc_getAllCaps = function () {
		return this.AllCaps;
	};
	asc_CParagraphProperty.prototype.asc_putAllCaps = function (v) {
		this.AllCaps = v;
	};
	asc_CParagraphProperty.prototype.asc_getStrikeout = function () {
		return this.Strikeout;
	};
	asc_CParagraphProperty.prototype.asc_putStrikeout = function (v) {
		this.Strikeout = v;
	};
	asc_CParagraphProperty.prototype.asc_getDStrikeout = function () {
		return this.DStrikeout;
	};
	asc_CParagraphProperty.prototype.asc_putDStrikeout = function (v) {
		this.DStrikeout = v;
	};
	asc_CParagraphProperty.prototype.asc_getTextSpacing = function () {
		return this.TextSpacing;
	};
	asc_CParagraphProperty.prototype.asc_putTextSpacing = function (v) {
		this.TextSpacing = v;
	};
	asc_CParagraphProperty.prototype.asc_getPosition = function () {
		return this.Position;
	};
	asc_CParagraphProperty.prototype.asc_putPosition = function (v) {
		this.Position = v;
	};
	asc_CParagraphProperty.prototype.asc_getTabs = function () {
		return this.Tabs;
	};
	asc_CParagraphProperty.prototype.asc_putTabs = function (v) {
		this.Tabs = v;
	};
	asc_CParagraphProperty.prototype.asc_getDefaultTab = function () {
		return this.DefaultTab;
	};
	asc_CParagraphProperty.prototype.asc_putDefaultTab = function (v) {
		this.DefaultTab = v;
	};
	asc_CParagraphProperty.prototype.asc_getFramePr = function () {
		return this.FramePr;
	};
	asc_CParagraphProperty.prototype.asc_putFramePr = function (v) {
		this.FramePr = v;
	};
	asc_CParagraphProperty.prototype.asc_getCanAddDropCap = function () {
		return this.CanAddDropCap;
	};
	asc_CParagraphProperty.prototype.asc_getCanAddImage = function () {
		return this.CanAddImage;
	};
	asc_CParagraphProperty.prototype.asc_getOutlineLvl = function () {
		return this.OutlineLvl;
	};
	asc_CParagraphProperty.prototype.asc_putOutLineLvl = function (nLvl) {
		this.OutlineLvl = nLvl;
	};
	asc_CParagraphProperty.prototype.asc_getOutlineLvlStyle = function () {
		return this.OutlineLvlStyle;
	};
	asc_CParagraphProperty.prototype.asc_getSuppressLineNumbers = function () {
		return this.SuppressLineNumbers;
	};
	asc_CParagraphProperty.prototype.asc_putSuppressLineNumbers = function (isSuppress) {
		this.SuppressLineNumbers = isSuppress;
	};
	asc_CParagraphProperty.prototype.asc_putBullet = function (val) {
		this.Bullet = val;
	};
	asc_CParagraphProperty.prototype.asc_getBullet = function () {
		return this.Bullet;
	};
	asc_CParagraphProperty.prototype.asc_putBulletSize = function (size) {
		if (!this.Bullet) {
			this.Bullet = new Asc.asc_CBullet();
		}
		this.Bullet.asc_putSize(size);
	};
	asc_CParagraphProperty.prototype.asc_getBulletSize = function () {
		if (!this.Bullet) {
			return undefined;
		}
		return this.Bullet.asc_getSize();
	};
	asc_CParagraphProperty.prototype.asc_putBulletColor = function (color) {
		if (!this.Bullet) {
			this.Bullet = new Asc.asc_CBullet();
		}
		this.Bullet.asc_putColor(color);
	};
	asc_CParagraphProperty.prototype.asc_getBulletColor = function () {
		if (!this.Bullet) {
			return undefined;
		}
		return this.Bullet.asc_getColor();
	};
	asc_CParagraphProperty.prototype.asc_putNumStartAt = function (NumStartAt) {
		if (!this.Bullet) {
			this.Bullet = new Asc.asc_CBullet();
		}
		this.Bullet.asc_putNumStartAt(NumStartAt);
	};
	asc_CParagraphProperty.prototype.asc_getNumStartAt = function () {
		if (!this.Bullet) {
			return undefined;
		}
		return this.Bullet.asc_getNumStartAt();
	};
	asc_CParagraphProperty.prototype.asc_getBulletFont = function () {
		if (!this.Bullet) {
			return undefined;
		}
		return this.Bullet.asc_getFont();
	};
	asc_CParagraphProperty.prototype.asc_putBulletFont = function (v) {
		if (!this.Bullet) {
			this.Bullet = new Asc.asc_CBullet();
		}
		this.Bullet.asc_putFont(v);
	};
	asc_CParagraphProperty.prototype.asc_getBulletSymbol = function () {
		if (!this.Bullet) {
			return undefined;
		}
		return this.Bullet.asc_getSymbol();
	};
	asc_CParagraphProperty.prototype.asc_putBulletSymbol = function (v) {
		if (!this.Bullet) {
			this.Bullet = new Asc.asc_CBullet();
		}
		this.Bullet.asc_putSymbol(v);
	};
	asc_CParagraphProperty.prototype.asc_canDeleteBlockContentControl = function () {
		return this.CanDeleteBlockCC;
	};
	asc_CParagraphProperty.prototype.asc_canEditBlockContentControl = function () {
		return this.CanEditBlockCC;
	};
	asc_CParagraphProperty.prototype.asc_canDeleteInlineContentControl = function () {
		return this.CanDeleteInlineCC;
	};
	asc_CParagraphProperty.prototype.asc_canEditInlineContentControl = function () {
		return this.CanEditInlineCC;
	};
	asc_CParagraphProperty.prototype.asc_getLigatures = function () {
		return this.Ligatures;
	};
	asc_CParagraphProperty.prototype.asc_putLigatures = function (v) {
		this.Ligatures = v;
	};

	/** @constructor */
	function asc_CTexture() {
		this.Id = 0;
		this.Image = "";
	}

	asc_CTexture.prototype.asc_getId = function () {
		return this.Id;
	};
	asc_CTexture.prototype.asc_getImage = function () {
		return this.Image;
	};

	/** @constructor */
	function asc_CImageSize(width, height, isCorrect) {
		this.Width = (undefined == width) ? 0.0 : width;
		this.Height = (undefined == height) ? 0.0 : height;
		this.IsCorrect = isCorrect;
	}

	asc_CImageSize.prototype.asc_getImageWidth = function () {
		return this.Width;
	};
	asc_CImageSize.prototype.asc_getImageHeight = function () {
		return this.Height;
	};
	asc_CImageSize.prototype.asc_getIsCorrect = function () {
		return this.IsCorrect;
	};

	/** @constructor */
	function asc_CPaddings(obj) {

		if (obj) {
			this.Left = (undefined == obj.Left) ? null : obj.Left;
			this.Top = (undefined == obj.Top) ? null : obj.Top;
			this.Bottom = (undefined == obj.Bottom) ? null : obj.Bottom;
			this.Right = (undefined == obj.Right) ? null : obj.Right;
		}
		else {
			this.Left = null;
			this.Top = null;
			this.Bottom = null;
			this.Right = null;
		}
	}

	asc_CPaddings.prototype.asc_getLeft = function () {
		return this.Left;
	};
	asc_CPaddings.prototype.asc_putLeft = function (v) {
		this.Left = v;
	};
	asc_CPaddings.prototype.asc_getTop = function () {
		return this.Top;
	};
	asc_CPaddings.prototype.asc_putTop = function (v) {
		this.Top = v;
	};
	asc_CPaddings.prototype.asc_getBottom = function () {
		return this.Bottom;
	};
	asc_CPaddings.prototype.asc_putBottom = function (v) {
		this.Bottom = v;
	};
	asc_CPaddings.prototype.asc_getRight = function () {
		return this.Right;
	};
	asc_CPaddings.prototype.asc_putRight = function (v) {
		this.Right = v;
	};

	/** @constructor */
	function asc_CShapeProperty() {
		this.type = null; // custom
		this.fill = null;
		this.stroke = null;
		this.paddings = null;
		this.canFill = true;
		this.canChangeArrows = false;
		this.canEditText = false; // used in pdf editor
		this.bFromChart = false;
		this.bFromGroup = false;
		this.bFromImage = false;
		this.bFromSmartArt = false;
		this.bFromSmartArtInternal = false;
		this.Locked = false;
		this.w = null;
		this.h = null;
		this.vert = null;
		this.verticalTextAlign = null;
		this.textArtProperties = null;
		this.lockAspect = null;
		this.title = null;
		this.description = null;
		this.name = null;

		this.columnNumber = null;
		this.columnSpace = null;
		this.textFitType = null;
		this.vertOverflowType = null;
		this.signatureId = null;

		this.rot = null;
		this.rotAdd = null;
		this.flipH = null;
		this.flipV = null;
		this.flipHInvert = null;
		this.flipVInvert = null;
		this.Position = undefined;
		this.shadow = undefined;
		this.anchor = null;

		this.protectionLockText = null;
		this.protectionLocked = null;
		this.protectionPrint = null;
		this.isMotionPath = false;
	}

	asc_CShapeProperty.prototype.constructor = asc_CShapeProperty;
	asc_CShapeProperty.prototype.asc_getType = function () {
		return this.type;
	};
	asc_CShapeProperty.prototype.asc_putType = function (v) {
		this.type = v;
	};
	asc_CShapeProperty.prototype.asc_getFill = function () {
		return this.fill;
	};
	asc_CShapeProperty.prototype.asc_putFill = function (v) {
		this.fill = v;
	};
	asc_CShapeProperty.prototype.asc_getStroke = function () {
		return this.stroke;
	};
	asc_CShapeProperty.prototype.asc_putStroke = function (v) {
		this.stroke = v;
	};
	asc_CShapeProperty.prototype.asc_getPaddings = function () {
		return this.paddings;
	};
	asc_CShapeProperty.prototype.asc_putPaddings = function (v) {
		this.paddings = v;
	};
	asc_CShapeProperty.prototype.asc_getCanFill = function () {
		return this.canFill;
	};
	asc_CShapeProperty.prototype.asc_putCanFill = function (v) {
		this.canFill = v;
	};
	asc_CShapeProperty.prototype.asc_getCanChangeArrows = function () {
		return this.canChangeArrows;
	};
	asc_CShapeProperty.prototype.asc_setCanChangeArrows = function (v) {
		this.canChangeArrows = v;
	};
	asc_CShapeProperty.prototype.asc_getFromChart = function () {
		return this.bFromChart;
	};
	asc_CShapeProperty.prototype.asc_setFromChart = function (v) {
		this.bFromChart = v;
	};
	asc_CShapeProperty.prototype.asc_getFromSmartArt = function () {
		return this.bFromSmartArt;
	};
	asc_CShapeProperty.prototype.asc_setFromSmartArt = function (v) {
		this.bFromSmartArt = v;
	};
	asc_CShapeProperty.prototype.asc_getFromSmartArtInternal = function () {
		return this.bFromSmartArtInternal;
	};
	asc_CShapeProperty.prototype.asc_setFromSmartArtInternal = function (v) {
		this.bFromSmartArtInternal = v;
	};
	asc_CShapeProperty.prototype.asc_getFromGroup = function () {
		return this.bFromGroup;
	};
	asc_CShapeProperty.prototype.asc_setFromGroup = function (v) {
		this.bFromGroup = v;
	};
	asc_CShapeProperty.prototype.asc_getLocked = function () {
		return this.Locked;
	};
	asc_CShapeProperty.prototype.asc_setLocked = function (v) {
		this.Locked = v;
	};
	asc_CShapeProperty.prototype.asc_getWidth = function () {
		return this.w;
	};
	asc_CShapeProperty.prototype.asc_putWidth = function (v) {
		this.w = v;
	};
	asc_CShapeProperty.prototype.asc_getHeight = function () {
		return this.h;
	};
	asc_CShapeProperty.prototype.asc_putHeight = function (v) {
		this.h = v;
	};
	asc_CShapeProperty.prototype.asc_getVerticalTextAlign = function () {
		return this.verticalTextAlign;
	};
	asc_CShapeProperty.prototype.asc_putVerticalTextAlign = function (v) {
		this.verticalTextAlign = v;
	};
	asc_CShapeProperty.prototype.asc_getVert = function () {
		return this.vert;
	};
	asc_CShapeProperty.prototype.asc_putVert = function (v) {
		this.vert = v;
	};
	asc_CShapeProperty.prototype.asc_getTextArtProperties = function () {
		return this.textArtProperties;
	};
	asc_CShapeProperty.prototype.asc_putTextArtProperties = function (v) {
		this.textArtProperties = v;
	};
	asc_CShapeProperty.prototype.asc_getLockAspect = function () {
		return this.lockAspect
	};
	asc_CShapeProperty.prototype.asc_putLockAspect = function (v) {
		this.lockAspect = v;
	};
	asc_CShapeProperty.prototype.asc_getTitle = function () {
		return this.title;
	};
	asc_CShapeProperty.prototype.asc_putTitle = function (v) {
		this.title = v;
	};
	asc_CShapeProperty.prototype.asc_getDescription = function () {
		return this.description;
	};
	asc_CShapeProperty.prototype.asc_putDescription = function (v) {
		this.description = v;
	};
	asc_CShapeProperty.prototype.asc_getName = function () {
		return this.name;
	};
	asc_CShapeProperty.prototype.asc_putName = function (v) {
		this.name = v;
	};
	asc_CShapeProperty.prototype.asc_getColumnNumber = function () {
		return this.columnNumber;
	};
	asc_CShapeProperty.prototype.asc_putColumnNumber = function (v) {
		this.columnNumber = v;
	};
	asc_CShapeProperty.prototype.asc_getColumnSpace = function () {
		return this.columnSpace;
	};
	asc_CShapeProperty.prototype.asc_getTextFitType = function () {
		return this.textFitType;
	};
	asc_CShapeProperty.prototype.asc_getVertOverflowType = function () {
		return this.vertOverflowType;
	};
	asc_CShapeProperty.prototype.asc_putColumnSpace = function (v) {
		this.columnSpace = v;
	};
	asc_CShapeProperty.prototype.asc_putTextFitType = function (v) {
		this.textFitType = v;
	};
	asc_CShapeProperty.prototype.asc_putVertOverflowType = function (v) {
		this.vertOverflowType = v;
	};
	asc_CShapeProperty.prototype.asc_getSignatureId = function () {
		return this.signatureId;
	};
	asc_CShapeProperty.prototype.asc_putSignatureId = function (v) {
		this.signatureId = v;
	};
	asc_CShapeProperty.prototype.asc_getFromImage = function () {
		return this.bFromImage;
	};
	asc_CShapeProperty.prototype.asc_putFromImage = function (v) {
		this.bFromImage = v;
	};
	asc_CShapeProperty.prototype.asc_getRot = function () {
		return this.rot;
	};
	asc_CShapeProperty.prototype.asc_putRot = function (v) {
		this.rot = v;
	};
	asc_CShapeProperty.prototype.asc_getRotAdd = function () {
		return this.rotAdd;
	};
	asc_CShapeProperty.prototype.asc_putRotAdd = function (v) {
		this.rotAdd = v;
	};
	asc_CShapeProperty.prototype.asc_getFlipH = function () {
		return this.flipH;
	};
	asc_CShapeProperty.prototype.asc_putFlipH = function (v) {
		this.flipH = v;
	};
	asc_CShapeProperty.prototype.asc_getFlipV = function () {
		return this.flipV;
	};
	asc_CShapeProperty.prototype.asc_putFlipV = function (v) {
		this.flipV = v;
	};
	asc_CShapeProperty.prototype.asc_getFlipHInvert = function () {
		return this.flipHInvert;
	};
	asc_CShapeProperty.prototype.asc_putFlipHInvert = function (v) {
		this.flipHInvert = v;
	};
	asc_CShapeProperty.prototype.asc_getFlipVInvert = function () {
		return this.flipVInvert;
	};
	asc_CShapeProperty.prototype.asc_putFlipVInvert = function (v) {
		this.flipVInvert = v;
	};
	asc_CShapeProperty.prototype.asc_getShadow = function () {
		return this.shadow;
	};
	asc_CShapeProperty.prototype.asc_putShadow = function (v) {
		this.shadow = v;
	};
	asc_CShapeProperty.prototype.asc_getAnchor = function () {
		return this.anchor;
	};
	asc_CShapeProperty.prototype.asc_putAnchor = function (v) {
		this.anchor = v;
	};
	asc_CShapeProperty.prototype.asc_getProtectionLockText = function () {
		return this.protectionLockText;
	};
	asc_CShapeProperty.prototype.asc_putProtectionLockText = function (v) {
		this.protectionLockText = v;
	};
	asc_CShapeProperty.prototype.asc_getProtectionLocked = function () {
		return this.protectionLocked;
	};
	asc_CShapeProperty.prototype.asc_putProtectionLocked = function (v) {
		this.protectionLocked = v;
	};
	asc_CShapeProperty.prototype.asc_getProtectionPrint = function () {
		return this.protectionPrint;
	};
	asc_CShapeProperty.prototype.asc_putProtectionPrint = function (v) {
		this.protectionPrint = v;
	};
	asc_CShapeProperty.prototype.asc_getPosition = function () {
		return this.Position;
	};
	asc_CShapeProperty.prototype.asc_putPosition = function (v) {
		this.Position = v;
	};
	asc_CShapeProperty.prototype.asc_getIsMotionPath = function () {
		return this.isMotionPath;
	};
	asc_CShapeProperty.prototype.asc_getCanEditText = function () {
		return this.canEditText;
	};
	asc_CShapeProperty.prototype.asc_setCanEditText = function (v) {
		this.canEditText = v;
	};

	/** @constructor */
	function asc_CAnnotProperty() {
		this.type				= null; // custom
		this.fill				= null;
		this.stroke				= null;
		this.canFill			= true;
		this.canChangeArrows	= true;
		this.Locked				= false;
		this.subject			= undefined;
		this.canEditText		= false;

		this.Position = undefined;
	}

	asc_CAnnotProperty.prototype.constructor = asc_CAnnotProperty;
	asc_CAnnotProperty.prototype.asc_getType = function () {
		return this.type;
	};
	asc_CAnnotProperty.prototype.asc_putType = function (v) {
		this.type = v;
	};
	asc_CAnnotProperty.prototype.asc_getFill = function () {
		return this.fill;
	};
	asc_CAnnotProperty.prototype.asc_putFill = function (v) {
		this.fill = v;
	};
	asc_CAnnotProperty.prototype.asc_getStroke = function () {
		return this.stroke;
	};
	asc_CAnnotProperty.prototype.asc_putStroke = function (v) {
		this.stroke = v;
	};
	asc_CAnnotProperty.prototype.asc_getCanFill = function () {
		return this.canFill;
	};
	asc_CAnnotProperty.prototype.asc_putCanFill = function (v) {
		this.canFill = v;
	};
	asc_CAnnotProperty.prototype.asc_getCanChangeArrows = function () {
		return this.canChangeArrows;
	};
	asc_CAnnotProperty.prototype.asc_setCanChangeArrows = function (v) {
		this.canChangeArrows = v;
	};
	asc_CAnnotProperty.prototype.asc_getSubject = function () {
		return this.subject;
	};
	asc_CAnnotProperty.prototype.asc_setSubject = function (v) {
		this.subject = v;
	};
	asc_CAnnotProperty.prototype.asc_getCanEditText = function () {
		return this.canEditText;
	};
	asc_CAnnotProperty.prototype.asc_setCanEditText = function (v) {
		this.canEditText = v;
	};

	/** @constructor */
	function asc_CPdfPageProperty() {
		this.deleteLock	= false;
		this.rotateLock	= false;
		this.editLock	= false;
	}

	asc_CPdfPageProperty.prototype.constructor = asc_CPdfPageProperty;
	asc_CPdfPageProperty.prototype.asc_getDeleteLock = function () {
		return this.deleteLock;
	};
	asc_CPdfPageProperty.prototype.asc_putDeleteLock = function (v) {
		this.deleteLock = v;
	};
	asc_CPdfPageProperty.prototype.asc_getRotateLock = function () {
		return this.rotateLock;
	};
	asc_CPdfPageProperty.prototype.asc_putRotateLock = function (v) {
		this.rotateLock = v;
	};
	asc_CPdfPageProperty.prototype.asc_getEditLock = function () {
		return this.editLock;
	};
	asc_CPdfPageProperty.prototype.asc_putEditLock = function (v) {
		this.editLock = v;
	};

	/** @constructor */
	function asc_TextArtProperties(obj) {
		if (obj) {
			this.Fill = obj.Fill;//asc_Fill
			this.Line = obj.Line;//asc_Stroke
			this.Form = obj.Form;//srting
			this.Style = obj.Style;//
		}
		else {
			this.Fill = undefined;
			this.Line = undefined;
			this.Form = undefined;
			this.Style = undefined;
		}
	}

	asc_TextArtProperties.prototype.asc_putFill = function (oAscFill) {
		this.Fill = oAscFill;
	};
	asc_TextArtProperties.prototype.asc_getFill = function () {
		return this.Fill;
	};
	asc_TextArtProperties.prototype.asc_putLine = function (oAscStroke) {
		this.Line = oAscStroke;
	};
	asc_TextArtProperties.prototype.asc_getLine = function () {
		return this.Line;
	};
	asc_TextArtProperties.prototype.asc_putForm = function (sForm) {
		this.Form = sForm;
	};
	asc_TextArtProperties.prototype.asc_getForm = function () {
		return this.Form;
	};
	asc_TextArtProperties.prototype.asc_putStyle = function (Style) {
		this.Style = Style;
	};
	asc_TextArtProperties.prototype.asc_getStyle = function () {
		return this.Style;
	};

	function CImagePositionH(obj) {
		if (obj) {
			this.RelativeFrom = (undefined === obj.RelativeFrom) ? undefined : obj.RelativeFrom;
			this.UseAlign = (undefined === obj.UseAlign) ? undefined : obj.UseAlign;
			this.Align = (undefined === obj.Align) ? undefined : obj.Align;
			this.Value = (undefined === obj.Value) ? undefined : obj.Value;
			this.Percent = (undefined === obj.Percent) ? undefined : obj.Percent;
		}
		else {
			this.RelativeFrom = undefined;
			this.UseAlign = undefined;
			this.Align = undefined;
			this.Value = undefined;
			this.Percent = undefined;
		}
	}

	CImagePositionH.prototype.get_RelativeFrom = function () {
		return this.RelativeFrom;
	};
	CImagePositionH.prototype.put_RelativeFrom = function (v) {
		this.RelativeFrom = v;
	};
	CImagePositionH.prototype.get_UseAlign = function () {
		return this.UseAlign;
	};
	CImagePositionH.prototype.put_UseAlign = function (v) {
		this.UseAlign = v;
	};
	CImagePositionH.prototype.get_Align = function () {
		return this.Align;
	};
	CImagePositionH.prototype.put_Align = function (v) {
		this.Align = v;
	};
	CImagePositionH.prototype.get_Value = function () {
		return this.Value;
	};
	CImagePositionH.prototype.put_Value = function (v) {
		this.Value = v;
	};
	CImagePositionH.prototype.get_Percent = function () {
		return this.Percent
	};
	CImagePositionH.prototype.put_Percent = function (v) {
		this.Percent = v;
	};

	function CImagePositionV(obj) {
		if (obj) {
			this.RelativeFrom = (undefined === obj.RelativeFrom) ? undefined : obj.RelativeFrom;
			this.UseAlign = (undefined === obj.UseAlign) ? undefined : obj.UseAlign;
			this.Align = (undefined === obj.Align) ? undefined : obj.Align;
			this.Value = (undefined === obj.Value) ? undefined : obj.Value;
			this.Percent = (undefined === obj.Percent) ? undefined : obj.Percent;
		}
		else {
			this.RelativeFrom = undefined;
			this.UseAlign = undefined;
			this.Align = undefined;
			this.Value = undefined;
			this.Percent = undefined;
		}
	}

	CImagePositionV.prototype.get_RelativeFrom = function () {
		return this.RelativeFrom;
	};
	CImagePositionV.prototype.put_RelativeFrom = function (v) {
		this.RelativeFrom = v;
	};
	CImagePositionV.prototype.get_UseAlign = function () {
		return this.UseAlign;
	};
	CImagePositionV.prototype.put_UseAlign = function (v) {
		this.UseAlign = v;
	};
	CImagePositionV.prototype.get_Align = function () {
		return this.Align;
	};
	CImagePositionV.prototype.put_Align = function (v) {
		this.Align = v;
	};
	CImagePositionV.prototype.get_Value = function () {
		return this.Value;
	};
	CImagePositionV.prototype.put_Value = function (v) {
		this.Value = v;
	};
	CImagePositionV.prototype.get_Percent = function () {
		return this.Percent
	};
	CImagePositionV.prototype.put_Percent = function (v) {
		this.Percent = v;
	};

	function CPosition(obj) {
		if (obj) {
			this.X = (undefined == obj.X) ? null : obj.X;
			this.Y = (undefined == obj.Y) ? null : obj.Y;
		}
		else {
			this.X = null;
			this.Y = null;
		}
	}

	CPosition.prototype.get_X = function () {
		return this.X;
	};
	CPosition.prototype.put_X = function (v) {
		this.X = v;
	};
	CPosition.prototype.get_Y = function () {
		return this.Y;
	};
	CPosition.prototype.put_Y = function (v) {
		this.Y = v;
	};

	/** @constructor */
	function asc_CImgProperty(obj) {

		if (obj) {
			this.CanBeFlow = (undefined != obj.CanBeFlow) ? obj.CanBeFlow : true;

			this.Width = (undefined != obj.Width) ? obj.Width : undefined;
			this.Height = (undefined != obj.Height) ? obj.Height : undefined;
			this.WrappingStyle = (undefined != obj.WrappingStyle) ? obj.WrappingStyle : undefined;
			this.Paddings = (undefined != obj.Paddings) ? new asc_CPaddings(obj.Paddings) : undefined;
			this.Position = (undefined != obj.Position) ? new CPosition(obj.Position) : undefined;
			this.AllowOverlap = (undefined != obj.AllowOverlap) ? obj.AllowOverlap : undefined;
			this.PositionH = (undefined != obj.PositionH) ? new CImagePositionH(obj.PositionH) : undefined;
			this.PositionV = (undefined != obj.PositionV) ? new CImagePositionV(obj.PositionV) : undefined;

			this.SizeRelH = (undefined != obj.SizeRelH) ? new CImagePositionH(obj.SizeRelH) : undefined;
			this.SizeRelV = (undefined != obj.SizeRelV) ? new CImagePositionV(obj.SizeRelV) : undefined;

			this.Internal_Position = (undefined != obj.Internal_Position) ? obj.Internal_Position : null;

			this.ImageUrl = (undefined != obj.ImageUrl) ? obj.ImageUrl : null;
			this.Token = obj.Token;
			this.Locked = (undefined != obj.Locked) ? obj.Locked : false;
			this.lockAspect = (undefined != obj.lockAspect) ? obj.lockAspect : false;


			this.ChartProperties = (undefined != obj.ChartProperties) ? obj.ChartProperties : null;
			this.ShapeProperties = (undefined != obj.ShapeProperties) ? obj.ShapeProperties : null;
			this.SlicerProperties = (undefined != obj.SlicerProperties) ? obj.SlicerProperties : null;

			this.ChangeLevel = (undefined != obj.ChangeLevel) ? obj.ChangeLevel : null;
			this.Group = (obj.Group != undefined) ? obj.Group : null;

			this.fromGroup = obj.fromGroup != undefined ? obj.fromGroup : null;
			this.severalCharts = obj.severalCharts != undefined ? obj.severalCharts : false;
			this.severalChartTypes = obj.severalChartTypes != undefined ? obj.severalChartTypes : undefined;
			this.severalChartStyles = obj.severalChartStyles != undefined ? obj.severalChartStyles : undefined;
			this.verticalTextAlign = obj.verticalTextAlign != undefined ? obj.verticalTextAlign : undefined;
			this.vert = obj.vert != undefined ? obj.vert : undefined;

			//oleObjects
			this.pluginGuid = obj.pluginGuid !== undefined ? obj.pluginGuid : undefined;
			this.pluginData = obj.pluginData !== undefined ? obj.pluginData : undefined;

			this.title = obj.title != undefined ? obj.title : undefined;
			this.description = obj.description != undefined ? obj.description : undefined;
			this.name = obj.name != undefined ? obj.name : undefined;

			this.columnNumber = obj.columnNumber != undefined ? obj.columnNumber : undefined;
			this.columnSpace = obj.columnSpace != undefined ? obj.columnSpace : undefined;
			this.textFitType = obj.textFitType != undefined ? obj.textFitType : undefined;
			this.vertOverflowType = obj.vertOverflowType != undefined ? obj.vertOverflowType : undefined;
			this.shadow = obj.shadow != undefined ? obj.shadow : undefined;

			this.rot = obj.rot != undefined ? obj.rot : undefined;
			this.flipH = obj.flipH != undefined ? obj.flipH : undefined;
			this.flipV = obj.flipV != undefined ? obj.flipV : undefined;
			this.resetCrop = obj.resetCrop != undefined ? obj.resetCrop : undefined;
			this.anchor = obj.anchor != undefined ? obj.anchor : undefined;

			this.protectionLockText = obj.protectionLockText;
			this.protectionLocked = obj.protectionLocked;
			this.protectionPrint = obj.protectionPrint;

			this.bSetOriginalSize = obj.bSetOriginalSize;
			this.transparent = obj.transparent;
			this.isCrop      = obj.isCrop;

		}
		else {
			this.CanBeFlow = true;
			this.Width = undefined;
			this.Height = undefined;
			this.WrappingStyle = undefined;
			this.Paddings = undefined;
			this.Position = undefined;
			this.PositionH = undefined;
			this.PositionV = undefined;

			this.SizeRelH = undefined;
			this.SizeRelV = undefined;

			this.Internal_Position = null;
			this.ImageUrl = null;
			this.Token = undefined;
			this.Locked = false;

			this.ChartProperties = null;
			this.ShapeProperties = null;
			this.SlicerProperties = null;

			this.ChangeLevel = null;
			this.Group = null;
			this.fromGroup = null;
			this.severalCharts = false;
			this.severalChartTypes = undefined;
			this.severalChartStyles = undefined;
			this.verticalTextAlign = undefined;
			this.vert = undefined;

			//oleObjects
			this.pluginGuid = undefined;
			this.pluginData = undefined;

			this.title = undefined;
			this.description = undefined;
			this.name = undefined;

			this.columnNumber = undefined;
			this.columnSpace = undefined;
			this.textFitType = undefined;
			this.vertOverflowType = undefined;


			this.rot = undefined;
			this.rotAdd = undefined;
			this.flipH = undefined;
			this.flipV = undefined;
			this.resetCrop = undefined;
			this.anchor = undefined;

			this.protectionLockText = undefined;
			this.protectionLocked = undefined;
			this.protectionPrint = undefined;
			this.bSetOriginalSize = undefined;

			this.transparent = undefined;
			this.isCrop      = undefined;
		}
	}

	asc_CImgProperty.prototype.constructor = asc_CImgProperty;
	asc_CImgProperty.prototype.asc_getChangeLevel = function () {
		return this.ChangeLevel;
	};
	asc_CImgProperty.prototype.asc_putChangeLevel = function (v) {
		this.ChangeLevel = v;
	};

	asc_CImgProperty.prototype.asc_getCanBeFlow = function () {
		return this.CanBeFlow;
	};
	asc_CImgProperty.prototype.asc_getWidth = function () {
		return this.Width;
	};
	asc_CImgProperty.prototype.asc_putWidth = function (v) {
		this.Width = v;
	};
	asc_CImgProperty.prototype.asc_getHeight = function () {
		return this.Height;
	};
	asc_CImgProperty.prototype.asc_putHeight = function (v) {
		this.Height = v;
	};
	asc_CImgProperty.prototype.asc_getWrappingStyle = function () {
		return this.WrappingStyle;
	};
	asc_CImgProperty.prototype.asc_putWrappingStyle = function (v) {
		this.WrappingStyle = v;
	};

	// Возвращается объект класса Asc.asc_CPaddings
	asc_CImgProperty.prototype.asc_getPaddings = function () {
		return this.Paddings;
	}; // Аргумент объект класса Asc.asc_CPaddings
	asc_CImgProperty.prototype.asc_putPaddings = function (v) {
		this.Paddings = v;
	};
	asc_CImgProperty.prototype.asc_getAllowOverlap = function () {
		return this.AllowOverlap;
	};
	asc_CImgProperty.prototype.asc_putAllowOverlap = function (v) {
		this.AllowOverlap = v;
	}; // Возвращается объект класса CPosition
	asc_CImgProperty.prototype.asc_getPosition = function () {
		return this.Position;
	}; // Аргумент объект класса CPosition
	asc_CImgProperty.prototype.asc_putPosition = function (v) {
		this.Position = v;
	};
	asc_CImgProperty.prototype.asc_getPositionH = function () {
		return this.PositionH;
	};
	asc_CImgProperty.prototype.asc_putPositionH = function (v) {
		this.PositionH = v;
	};
	asc_CImgProperty.prototype.asc_getPositionV = function () {
		return this.PositionV;
	};
	asc_CImgProperty.prototype.asc_putPositionV = function (v) {
		this.PositionV = v;
	};

	asc_CImgProperty.prototype.asc_getSizeRelH = function () {
		return this.SizeRelH;
	};

	asc_CImgProperty.prototype.asc_putSizeRelH = function (v) {
		this.SizeRelH = v;
	};

	asc_CImgProperty.prototype.asc_getSizeRelV = function () {
		return this.SizeRelV;
	};

	asc_CImgProperty.prototype.asc_putSizeRelV = function (v) {
		this.SizeRelV = v;
	};

	asc_CImgProperty.prototype.asc_getValue_X = function (RelativeFrom) {
		if (null != this.Internal_Position) {
			return this.Internal_Position.Calculate_X_Value(RelativeFrom);
		}
		return 0;
	};
	asc_CImgProperty.prototype.asc_getValue_Y = function (RelativeFrom) {
		if (null != this.Internal_Position) {
			return this.Internal_Position.Calculate_Y_Value(RelativeFrom);
		}
		return 0;
	};

	asc_CImgProperty.prototype.asc_getImageUrl = function () {
		return this.ImageUrl;
	};
	asc_CImgProperty.prototype.asc_putImageUrl = function (v, sToken) {
		this.ImageUrl = v;
		this.Token = sToken;
	};
	asc_CImgProperty.prototype.asc_getGroup = function () {
		return this.Group;
	};
	asc_CImgProperty.prototype.asc_putGroup = function (v) {
		this.Group = v;
	};
	asc_CImgProperty.prototype.asc_getFromGroup = function () {
		return this.fromGroup;
	};
	asc_CImgProperty.prototype.asc_putFromGroup = function (v) {
		this.fromGroup = v;
	};

	asc_CImgProperty.prototype.asc_getisChartProps = function () {
		return this.isChartProps;
	};
	asc_CImgProperty.prototype.asc_putisChartPross = function (v) {
		this.isChartProps = v;
	};

	asc_CImgProperty.prototype.asc_getSeveralCharts = function () {
		return this.severalCharts;
	};
	asc_CImgProperty.prototype.asc_putSeveralCharts = function (v) {
		this.severalCharts = v;
	};
	asc_CImgProperty.prototype.asc_getSeveralChartTypes = function () {
		return this.severalChartTypes;
	};
	asc_CImgProperty.prototype.asc_putSeveralChartTypes = function (v) {
		this.severalChartTypes = v;
	};

	asc_CImgProperty.prototype.asc_getSeveralChartStyles = function () {
		return this.severalChartStyles;
	};
	asc_CImgProperty.prototype.asc_putSeveralChartStyles = function (v) {
		this.severalChartStyles = v;
	};

	asc_CImgProperty.prototype.asc_getVerticalTextAlign = function () {
		return this.verticalTextAlign;
	};
	asc_CImgProperty.prototype.asc_putVerticalTextAlign = function (v) {
		this.verticalTextAlign = v;
	};
	asc_CImgProperty.prototype.asc_getVert = function () {
		return this.vert;
	};
	asc_CImgProperty.prototype.asc_putVert = function (v) {
		this.vert = v;
	};

	asc_CImgProperty.prototype.asc_getLocked = function () {
		return this.Locked;
	};
	asc_CImgProperty.prototype.asc_getLockAspect = function () {
		return this.lockAspect;
	};
	asc_CImgProperty.prototype.asc_putLockAspect = function (v) {
		this.lockAspect = v;
	};
	asc_CImgProperty.prototype.asc_getChartProperties = function () {
		return this.ChartProperties;
	};
	asc_CImgProperty.prototype.asc_putChartProperties = function (v) {
		this.ChartProperties = v;
	};
	asc_CImgProperty.prototype.asc_getShapeProperties = function () {
		return this.ShapeProperties;
	};
	asc_CImgProperty.prototype.asc_putShapeProperties = function (v) {
		this.ShapeProperties = v;
	};
	asc_CImgProperty.prototype.asc_getSlicerProperties = function () {
		return this.SlicerProperties;
	};
	asc_CImgProperty.prototype.asc_putSlicerProperties = function (v) {
		this.SlicerProperties = v;
	};

	asc_CImgProperty.prototype.asc_getOriginSize = function (api) {
		if (this.ImageUrl === null) {
			return new asc_CImageSize(50, 50, false);
		}

		let origW = 0;
		let origH = 0;

		if(window["IS_NATIVE_EDITOR"]) {
			let fGetOriginalImageSize = window["native"]["GetOriginalImageSize"] ||
				window["native"]["DD_GetOriginalImageSize"];
			let sizes = fGetOriginalImageSize.call(window["native"], this.ImageUrl);
			let w = sizes[0];
			let h = sizes[1];
			let isN = AscFormat.isRealNumber;
			if (isN(w) && isN(h)) {
				origW = w;
				origH = h;
			}
		}
		else {
			let _image = api.ImageLoader.map_image_index[AscCommon.getFullImageSrc2(this.ImageUrl)];
			if (_image != undefined && _image.Image != null && _image.Status == window['AscFonts'].ImageLoadStatus.Complete) {
				origW = _image.Image.width;
				origH = _image.Image.height;
			}
			else if (window["AscDesktopEditor"] && window["AscDesktopEditor"]["GetImageOriginalSize"]) {
				let _size = window["AscDesktopEditor"]["GetImageOriginalSize"](this.ImageUrl);
				if (_size["W"] != 0 && _size["H"] != 0) {
					origW = _size["W"];
					origH = _size["H"];
				}
			}
		}
		if (origW != 0 && origH != 0) {
			let __w = Math.max((origW * AscCommon.g_dKoef_pix_to_mm), 1);
			let __h = Math.max((origH * AscCommon.g_dKoef_pix_to_mm), 1);

			return new asc_CImageSize(__w, __h, true);
		}
		return new asc_CImageSize(50, 50, false);
	};

	//oleObjects
	asc_CImgProperty.prototype.asc_getPluginGuid = function () {
		return this.pluginGuid;
	};

	asc_CImgProperty.prototype.asc_putPluginGuid = function (v) {
		this.pluginGuid = v;
	};

	asc_CImgProperty.prototype.asc_getPluginData = function () {
		return this.pluginData;
	};

	asc_CImgProperty.prototype.asc_putPluginData = function (v) {
		this.pluginData = v;
	};

	asc_CImgProperty.prototype.asc_getTitle = function () {
		return this.title;
	};

	asc_CImgProperty.prototype.asc_putTitle = function (v) {
		this.title = v;
	};

	asc_CImgProperty.prototype.asc_getDescription = function () {
		return this.description;
	};

	asc_CImgProperty.prototype.asc_putDescription = function (v) {
		this.description = v;
	};
	asc_CImgProperty.prototype.asc_getName = function () {
		return this.name;
	};

	asc_CImgProperty.prototype.asc_putName = function (v) {
		this.name = v;
	};

	asc_CImgProperty.prototype.asc_getColumnNumber = function () {
		return this.columnNumber;
	};

	asc_CImgProperty.prototype.asc_putColumnNumber = function (v) {
		this.columnNumber = v;
	};

	asc_CImgProperty.prototype.asc_getColumnSpace = function () {
		return this.columnSpace;
	};

	asc_CImgProperty.prototype.asc_getTextFitType = function () {
		return this.textFitType;
	};
	asc_CImgProperty.prototype.asc_getVertOverflowType = function () {
		return this.vertOverflowType;
	};

	asc_CImgProperty.prototype.asc_putColumnSpace = function (v) {
		this.columnSpace = v;
	};
	asc_CImgProperty.prototype.asc_putTextFitType = function (v) {
		this.textFitType = v;
	};
	asc_CImgProperty.prototype.asc_putVertOverflowType = function (v) {
		this.vertOverflowType = v;
	};

	asc_CImgProperty.prototype.asc_getSignatureId = function () {
		if (this.ShapeProperties) return this.ShapeProperties.asc_getSignatureId();
		return undefined;
	};

	asc_CImgProperty.prototype.asc_getRot = function () {
		return this.rot;
	};

	asc_CImgProperty.prototype.asc_putRot = function (v) {
		this.rot = v;
	};
	asc_CImgProperty.prototype.asc_getRotAdd = function () {
		return this.rotAdd;
	};

	asc_CImgProperty.prototype.asc_putRotAdd = function (v) {
		this.rotAdd = v;
	};

	asc_CImgProperty.prototype.asc_getFlipH = function () {
		return this.flipH;
	};

	asc_CImgProperty.prototype.asc_putFlipH = function (v) {
		this.flipH = v;
	};
	asc_CImgProperty.prototype.asc_getFlipHInvert = function () {
		return this.flipHInvert;
	};

	asc_CImgProperty.prototype.asc_putFlipHInvert = function (v) {
		this.flipHInvert = v;
	};

	asc_CImgProperty.prototype.asc_getFlipV = function () {
		return this.flipV;
	};

	asc_CImgProperty.prototype.asc_putFlipV = function (v) {
		this.flipV = v;
	};
	asc_CImgProperty.prototype.asc_getFlipVInvert = function () {
		return this.flipVInvert;
	};

	asc_CImgProperty.prototype.asc_putFlipVInvert = function (v) {
		this.flipVInvert = v;
	};
	asc_CImgProperty.prototype.asc_putResetCrop = function (v) {
		this.resetCrop = v;
	};
	asc_CImgProperty.prototype.asc_getShadow = function () {
		return this.shadow;
	};

	asc_CImgProperty.prototype.asc_putShadow = function (v) {
		this.shadow = v;
	};
	asc_CImgProperty.prototype.asc_getAnchor = function () {
		return this.anchor;
	};

	asc_CImgProperty.prototype.asc_putAnchor = function (v) {
		this.anchor = v;
	};
	asc_CImgProperty.prototype.asc_getProtectionLockText = function () {
		return this.protectionLockText;
	};
	asc_CImgProperty.prototype.asc_putProtectionLockText = function (v) {
		this.protectionLockText = v;
	};
	asc_CImgProperty.prototype.asc_getProtectionLocked = function () {
		return this.protectionLocked;
	};

	asc_CImgProperty.prototype.asc_putProtectionLocked = function (v) {
		this.protectionLocked = v;
	};
	asc_CImgProperty.prototype.asc_getProtectionPrint = function () {
		return this.protectionPrint;
	};
	asc_CImgProperty.prototype.asc_putProtectionPrint = function (v) {
		this.protectionPrint = v;
	};
	asc_CImgProperty.prototype.asc_getTransparent = function () {
		return this.transparent;
	};
	asc_CImgProperty.prototype.asc_putTransparent = function (v) {
		this.transparent = v;
	};

	asc_CImgProperty.prototype.asc_getIsCrop = function () {
		return this.isCrop;
	};
	/** @constructor */
	function asc_CSelectedObject(type, val) {
		this.Type = (undefined != type) ? type : null;
		this.Value = (undefined != val) ? val : null;
	}

	asc_CSelectedObject.prototype.asc_getObjectType = function () {
		return this.Type;
	};
	asc_CSelectedObject.prototype.asc_getObjectValue = function () {
		return this.Value;
	};



	/** @constructor */
	function asc_CShapeFill() {
		this.type = null;
		this.fill = null;
		this.transparent = null;
	}

	asc_CShapeFill.prototype.asc_getType = function () {
		return this.type;
	};
	asc_CShapeFill.prototype.asc_putType = function (v) {
		this.type = v;
	};
	asc_CShapeFill.prototype.asc_getFill = function () {
		return this.fill;
	};
	asc_CShapeFill.prototype.asc_putFill = function (v) {
		this.fill = v;
	};
	asc_CShapeFill.prototype.asc_getTransparent = function () {
		return this.transparent;
	};
	asc_CShapeFill.prototype.asc_putTransparent = function (v) {
		this.transparent = v;
	};
	asc_CShapeFill.prototype.asc_CheckForseSet = function () {
		if (null != this.transparent) {
			return true;
		}
		if (null != this.fill && this.fill.Positions != null) {
			return true;
		}
		return false;
	};

	/** @constructor */
	function asc_CFillBlip() {
		this.type = c_oAscFillBlipType.STRETCH;
		this.url = "";
		this.token = undefined;
		this.texture_id = null;
	}

	asc_CFillBlip.prototype.asc_getType = function () {
		return this.type
	};
	asc_CFillBlip.prototype.asc_putType = function (v) {
		this.type = v;
	};
	asc_CFillBlip.prototype.asc_getUrl = function () {
		return this.url;
	};
	asc_CFillBlip.prototype.asc_putUrl = function (v, sToken) {
		this.url = v;
		this.token = sToken;
	};
	asc_CFillBlip.prototype.asc_getTextureId = function () {
		return this.texture_id;
	};
	asc_CFillBlip.prototype.asc_putTextureId = function (v) {
		this.texture_id = v;
	};

	/** @constructor */
	function asc_CFillHatch() {
		this.PatternType = undefined;
		this.fgClr = undefined;
		this.bgClr = undefined;
	}

	asc_CFillHatch.prototype.asc_getPatternType = function () {
		return this.PatternType;
	};
	asc_CFillHatch.prototype.asc_putPatternType = function (v) {
		this.PatternType = v;
	};
	asc_CFillHatch.prototype.asc_getColorFg = function () {
		return this.fgClr;
	};
	asc_CFillHatch.prototype.asc_putColorFg = function (v) {
		this.fgClr = v;
	};
	asc_CFillHatch.prototype.asc_getColorBg = function () {
		return this.bgClr;
	};
	asc_CFillHatch.prototype.asc_putColorBg = function (v) {
		this.bgClr = v;
	};

	/** @constructor */
	function asc_CFillGrad() {
		this.Colors = undefined;
		this.Positions = undefined;
		this.GradType = 0;

		this.LinearAngle = undefined;
		this.LinearScale = true;

		this.PathType = 0;
	}

	asc_CFillGrad.prototype.asc_getColors = function () {
		return this.Colors;
	};
	asc_CFillGrad.prototype.asc_putColors = function (v) {
		this.Colors = v;
	};
	asc_CFillGrad.prototype.asc_getPositions = function () {
		return this.Positions;
	};
	asc_CFillGrad.prototype.asc_putPositions = function (v) {
		this.Positions = v;
	};
	asc_CFillGrad.prototype.asc_getGradType = function () {
		return this.GradType;
	};
	asc_CFillGrad.prototype.asc_putGradType = function (v) {
		this.GradType = v;
	};
	asc_CFillGrad.prototype.asc_getLinearAngle = function () {
		return this.LinearAngle;
	};
	asc_CFillGrad.prototype.asc_putLinearAngle = function (v) {
		this.LinearAngle = v;
	};
	asc_CFillGrad.prototype.asc_getLinearScale = function () {
		return this.LinearScale;
	};
	asc_CFillGrad.prototype.asc_putLinearScale = function (v) {
		this.LinearScale = v;
	};
	asc_CFillGrad.prototype.asc_getPathType = function () {
		return this.PathType;
	};
	asc_CFillGrad.prototype.asc_putPathType = function (v) {
		this.PathType = v;
	};

	/** @constructor */
	function asc_CFillSolid() {
		this.color = new asc_CColor();
	}

	asc_CFillSolid.prototype.asc_getColor = function () {
		return this.color
	};
	asc_CFillSolid.prototype.asc_putColor = function (v) {
		this.color = v;
	};


	/** @constructor */
	function asc_CStroke() {
		this.type = null;
		this.width = null;
		this.color = null;
		this.prstDash = null;

		this.LineJoin = null;
		this.LineCap = null;

		this.LineBeginStyle = null;
		this.LineBeginSize = null;

		this.LineEndStyle = null;
		this.LineEndSize = null;

		this.canChangeArrows = false;
		this.transparent = null;
	}

	asc_CStroke.prototype.asc_getType = function () {
		return this.type;
	};
	asc_CStroke.prototype.asc_putType = function (v) {
		this.type = v;
	};
	asc_CStroke.prototype.asc_getWidth = function () {
		return this.width;
	};
	asc_CStroke.prototype.asc_putWidth = function (v) {
		this.width = v;
	};
	asc_CStroke.prototype.asc_getColor = function () {
		return this.color;
	};
	asc_CStroke.prototype.asc_putColor = function (v) {
		this.color = v;
	};
	asc_CStroke.prototype.asc_getLinejoin = function () {
		return this.LineJoin;
	};
	asc_CStroke.prototype.asc_putLinejoin = function (v) {
		this.LineJoin = v;
	};
	asc_CStroke.prototype.asc_getLinecap = function () {
		return this.LineCap;
	};
	asc_CStroke.prototype.asc_putLinecap = function (v) {
		this.LineCap = v;
	};
	asc_CStroke.prototype.asc_getLinebeginstyle = function () {
		return this.LineBeginStyle;
	};
	asc_CStroke.prototype.asc_putLinebeginstyle = function (v) {
		this.LineBeginStyle = v;
	};
	asc_CStroke.prototype.asc_getLinebeginsize = function () {
		return this.LineBeginSize;
	};
	asc_CStroke.prototype.asc_putLinebeginsize = function (v) {
		this.LineBeginSize = v;
	};
	asc_CStroke.prototype.asc_getLineendstyle = function () {
		return this.LineEndStyle;
	};
	asc_CStroke.prototype.asc_putLineendstyle = function (v) {
		this.LineEndStyle = v;
	};
	asc_CStroke.prototype.asc_getLineendsize = function () {
		return this.LineEndSize;
	};
	asc_CStroke.prototype.asc_putLineendsize = function (v) {
		this.LineEndSize = v;
	};
	asc_CStroke.prototype.asc_getCanChangeArrows = function () {
		return this.canChangeArrows;
	};
	asc_CStroke.prototype.asc_getTransparent = function () {
		return this.transparent;
	};
	asc_CStroke.prototype.asc_putTransparent = function (v) {
		this.transparent = v;
	};
	asc_CStroke.prototype.asc_putPrstDash = function (v) {
		this.prstDash = v;
	};
	asc_CStroke.prototype.asc_getPrstDash = function () {
		return this.prstDash;
	};

	// цвет. может быть трех типов:
	// c_oAscColor.COLOR_TYPE_SRGB		: value - не учитывается
	// c_oAscColor.COLOR_TYPE_PRST		: value - имя стандартного цвета (map_prst_color)
	// c_oAscColor.COLOR_TYPE_SCHEME	: value - тип цвета в схеме
	// c_oAscColor.COLOR_TYPE_SYS		: конвертируется в srgb
	function CAscColorScheme() {
		this.colors = [];
		this.name = "";
		this.scheme = null;
		this.summ = 0;
	}

	CAscColorScheme.prototype.get_colors = function () {
		return this.colors;
	};
	CAscColorScheme.prototype.get_name = function () {
		return AscCommon.translateManager.getValue(this.name);
	};
	CAscColorScheme.prototype.get_dk1 = function () {
		return this.colors[0];
	};
	CAscColorScheme.prototype.get_lt1 = function () {
		return this.colors[1];
	};
	CAscColorScheme.prototype.get_dk2 = function () {
		return this.colors[2];
	};
	CAscColorScheme.prototype.get_lt2 = function () {
		return this.colors[3];
	};
	CAscColorScheme.prototype.get_accent1 = function () {
		return this.colors[4];
	};
	CAscColorScheme.prototype.get_accent2 = function () {
		return this.colors[5];
	};
	CAscColorScheme.prototype.get_accent3 = function () {
		return this.colors[6];
	};
	CAscColorScheme.prototype.get_accent4 = function () {
		return this.colors[7];
	};
	CAscColorScheme.prototype.get_accent5 = function () {
		return this.colors[8];
	};
	CAscColorScheme.prototype.get_accent6 = function () {
		return this.colors[9];
	};
	CAscColorScheme.prototype.get_hlink = function () {
		return this.colors[10];
	};
	CAscColorScheme.prototype.get_folHlink = function () {
		return this.colors[11];
	};
	CAscColorScheme.prototype.putColor = function (color) {
		this.colors.push(color);
		this.summ += color.getVal();
	};
	CAscColorScheme.prototype.isEqual = function (oColorScheme) {
		if (this.summ === oColorScheme.summ) {
			for (let i = 0; i < this.colors.length; ++i) {
				let oColor1 = this.colors[i];
				let oColor2 = oColorScheme.colors[i];
				if (!(!oColor1 && !oColor2 || oColor2 && oColor2 && oColor1.Compare(oColor2))) {
					return false;
				}
			}
			return this.name === oColorScheme.name;
		}
		return false;
	};


	//-----------------------------------------------------------------
	// События движения мыши
	//-----------------------------------------------------------------
	function CMouseMoveData(obj) {
		if (obj) {
			this.Type = (undefined != obj.Type) ? obj.Type : c_oAscMouseMoveDataTypes.Common;
			this.X_abs = (undefined != obj.X_abs) ? obj.X_abs : 0;
			this.Y_abs = (undefined != obj.Y_abs) ? obj.Y_abs : 0;
			this.EyedropperColor = (undefined != obj.EyedropperColor) ? obj.EyedropperColor : undefined;
			this.PlaceholderType = obj.PlaceholderType;
			switch (this.Type) {
				case c_oAscMouseMoveDataTypes.Hyperlink : {
					this.Hyperlink = (undefined != obj.PageNum) ? obj.PageNum : 0;
					break;
				}

				case c_oAscMouseMoveDataTypes.LockedObject : {
					this.UserId = (undefined != obj.UserId) ? obj.UserId : "";
					this.HaveChanges = (undefined != obj.HaveChanges) ? obj.HaveChanges : false;
					this.LockedObjectType = (undefined != obj.LockedObjectType) ? obj.LockedObjectType : Asc.c_oAscMouseMoveLockedObjectType.Common;
					break;
				}
				case c_oAscMouseMoveDataTypes.Footnote: {
					this.Text = "";
					this.Number = 1;
					break;
				}
				case c_oAscMouseMoveDataTypes.Review: {
					this.ReviewChange = obj && obj.ReviewChange ? obj.ReviewChange : null;
					break;
				}
			}
		}
		else {
			this.Type = c_oAscMouseMoveDataTypes.Common;
			this.X_abs = 0;
			this.Y_abs = 0;
			this.EyedropperColor = undefined;
		}
	}

	CMouseMoveData.prototype.get_Type = function () {
		return this.Type;
	};
	CMouseMoveData.prototype.get_X = function () {
		return this.X_abs;
	};
	CMouseMoveData.prototype.get_Y = function () {
		return this.Y_abs;
	};
	CMouseMoveData.prototype.get_Hyperlink = function () {
		return this.Hyperlink;
	};
	CMouseMoveData.prototype.get_UserId = function () {
		return this.UserId;
	};
	CMouseMoveData.prototype.get_HaveChanges = function () {
		return this.HaveChanges;
	};
	CMouseMoveData.prototype.get_LockedObjectType = function () {
		return this.LockedObjectType;
	};
	CMouseMoveData.prototype.get_FootnoteText = function () {
		return this.Text;
	};
	CMouseMoveData.prototype.get_FootnoteNumber = function () {
		return this.Number;
	};
	CMouseMoveData.prototype.get_FormHelpText = function () {
		return this.Text;
	};
	CMouseMoveData.prototype.get_ReviewChange = function () {
		return this.ReviewChange;
	};
	CMouseMoveData.prototype.get_EyedropperColor = function () {
		return this.EyedropperColor;
	};
	CMouseMoveData.prototype.get_PlaceholderType = function () {
		return this.PlaceholderType;
	};
	CMouseMoveData.prototype.get_EffectText = function () {
		return this.EffectText;
	};
	CMouseMoveData.prototype.get_EffectDescription = function () {
		return this.EffectDescription;
	};


	/**
	 * Класс для работы с интерфейсом для гиперссылок
	 * @param obj
	 * @constructor
	 */
	function CHyperlinkProperty(obj) {
		if (obj) {
			this.Text = (undefined != obj.Text) ? obj.Text : null;
			this.Value = (undefined != obj.Value) ? obj.Value : "";
			this.ToolTip = (undefined != obj.ToolTip) ? obj.ToolTip : "";
			this.Class = (undefined !== obj.Class) ? obj.Class : null;
			this.Anchor = (undefined !== obj.Anchor) ? obj.Anchor : null;
			this.Heading = (obj.Heading ? obj.Heading : null);
		}
		else {
			this.Text = null;
			this.Value = "";
			this.ToolTip = "";
			this.Class = null;
			this.Anchor = null;
			this.Heading = null;
		}
	}

	CHyperlinkProperty.prototype.get_Value = function () {
		return this.Value;
	};
	CHyperlinkProperty.prototype.put_Value = function (v) {
		this.Value = v;
	};
	CHyperlinkProperty.prototype.get_ToolTip = function () {
		return this.ToolTip;
	};
	CHyperlinkProperty.prototype.put_ToolTip = function (v) {
		this.ToolTip = v ? v.slice(0, Asc.c_oAscMaxTooltipLength) : v;
	};
	CHyperlinkProperty.prototype.get_Text = function () {
		return this.Text;
	};
	CHyperlinkProperty.prototype.put_Text = function (v) {
		this.Text = v;
	};
	CHyperlinkProperty.prototype.put_InternalHyperlink = function (oClass) {
		this.Class = oClass;
	};
	CHyperlinkProperty.prototype.get_InternalHyperlink = function () {
		return this.Class;
	};
	CHyperlinkProperty.prototype.is_TopOfDocument = function () {
		return (this.Anchor === "_top");
	};
	CHyperlinkProperty.prototype.put_TopOfDocument = function () {
		this.Anchor = "_top";
	};
	CHyperlinkProperty.prototype.get_Bookmark = function () {
		return this.Anchor;
	};
	CHyperlinkProperty.prototype.put_Bookmark = function (sBookmark) {
		this.Anchor = sBookmark;
	};
	CHyperlinkProperty.prototype.is_Heading = function () {
		return (this.Heading instanceof AscWord.Paragraph ? true : false)
	};
	CHyperlinkProperty.prototype.put_Heading = function (oParagraph) {
		this.Heading = oParagraph;
	};
	CHyperlinkProperty.prototype.get_Heading = function () {
		return this.Heading;
	};

	window['Asc']['CHyperlinkProperty'] = window['Asc'].CHyperlinkProperty = CHyperlinkProperty;
	CHyperlinkProperty.prototype['get_Value'] = CHyperlinkProperty.prototype.get_Value;
	CHyperlinkProperty.prototype['put_Value'] = CHyperlinkProperty.prototype.put_Value;
	CHyperlinkProperty.prototype['get_ToolTip'] = CHyperlinkProperty.prototype.get_ToolTip;
	CHyperlinkProperty.prototype['put_ToolTip'] = CHyperlinkProperty.prototype.put_ToolTip;
	CHyperlinkProperty.prototype['get_Text'] = CHyperlinkProperty.prototype.get_Text;
	CHyperlinkProperty.prototype['put_Text'] = CHyperlinkProperty.prototype.put_Text;
	CHyperlinkProperty.prototype['get_InternalHyperlink'] = CHyperlinkProperty.prototype.get_InternalHyperlink;
	CHyperlinkProperty.prototype['put_InternalHyperlink'] = CHyperlinkProperty.prototype.put_InternalHyperlink;
	CHyperlinkProperty.prototype['is_TopOfDocument'] = CHyperlinkProperty.prototype.is_TopOfDocument;
	CHyperlinkProperty.prototype['put_TopOfDocument'] = CHyperlinkProperty.prototype.put_TopOfDocument;
	CHyperlinkProperty.prototype['get_Bookmark'] = CHyperlinkProperty.prototype.get_Bookmark;
	CHyperlinkProperty.prototype['put_Bookmark'] = CHyperlinkProperty.prototype.put_Bookmark;
	CHyperlinkProperty.prototype['is_Heading'] = CHyperlinkProperty.prototype.is_Heading;
	CHyperlinkProperty.prototype['put_Heading'] = CHyperlinkProperty.prototype.put_Heading;
	CHyperlinkProperty.prototype['get_Heading'] = CHyperlinkProperty.prototype.get_Heading;


	/**
	 * @property {string|null} Id
	 * @property {string|null} FullName
	 * @property {string|null} FirstName
	 * @property {string|null} LastName
	 * @property {boolean|null} IsAnonymousUser
	 * @constructor
	 *  */
	function asc_CUserInfo() {
		this.Id = null;
		this.FullName = null;
		this.FirstName = null;
		this.LastName = null;
		this.IsAnonymousUser = false;
	}
	asc_CUserInfo.prototype.clone = function () {
		let res = new asc_CUserInfo();
		res.Id = this.Id;
		res.FullName = this.FullName;
		res.FirstName = this.FirstName;
		res.LastName = this.LastName;
		res.IsAnonymousUser = this.IsAnonymousUser;
		return res;
	};
	asc_CUserInfo.prototype.asc_putId = asc_CUserInfo.prototype.put_Id = function (v) {
		this.Id = v;
	};
	asc_CUserInfo.prototype.asc_getId = asc_CUserInfo.prototype.get_Id = function () {
		return this.Id;
	};
	asc_CUserInfo.prototype.asc_putFullName = asc_CUserInfo.prototype.put_FullName = function (v) {
		this.FullName = v;
	};
	asc_CUserInfo.prototype.asc_getFullName = asc_CUserInfo.prototype.get_FullName = function () {
		return this.FullName;
	};
	asc_CUserInfo.prototype.asc_putFirstName = asc_CUserInfo.prototype.put_FirstName = function (v) {
		this.FirstName = v;
	};
	asc_CUserInfo.prototype.asc_getFirstName = asc_CUserInfo.prototype.get_FirstName = function () {
		return this.FirstName;
	};
	asc_CUserInfo.prototype.asc_putLastName = asc_CUserInfo.prototype.put_LastName = function (v) {
		this.LastName = v;
	};
	asc_CUserInfo.prototype.asc_getLastName = asc_CUserInfo.prototype.get_LastName = function () {
		return this.LastName;
	};
	asc_CUserInfo.prototype.asc_getIsAnonymousUser = asc_CUserInfo.prototype.get_IsAnonymousUser = function () {
		return this.IsAnonymousUser;
	};
	asc_CUserInfo.prototype.asc_putIsAnonymousUser = asc_CUserInfo.prototype.put_IsAnonymousUser = function (v) {
		this.IsAnonymousUser = v;
	};

	/**
	 * @property {string|null} Id
	 * @property {string|null} Url
	 * @property {string|null} Title
	 * @property {string|null} Format
	 * @property {string|null} VKey
	 * @property {string|null} Token
	 * @property {asc_CUserInfo|null} UserInfo
	 * @property {object|null} Options
	 * @property {string|null} CallbackUrl
	 * @property {object|null} TemplateReplacement
	 * @property {string|null} Mode
	 * @property {object|null} Permissions
	 * @property {string|null} Lang
	 * @property {boolean|null} OfflineApp
	 * @property {boolean|undefined} Encrypted
	 * @property {object|undefined} EncryptedInfo
	 * @property {boolean|null} IsEnabledPlugins
	 * @property {boolean|null} IsEnabledMacroses
	 * @property {boolean|null} IsWebOpening
	 * @property {boolean|null} SupportsOnSaveDocument
	 * @property {object|null} Wopi
	 * @property {string|null} shardkey
	 * @property {object|null} ReferenceData
	 * @constructor
	 * */
	function asc_CDocInfo() {
		this.Id = null;
		this.Url = null;
		this.Title = null;
		this.Format = null;
		this.VKey = null;
		this.Token = null;
		this.UserInfo = null;
		this.Options = null;
		this.CallbackUrl = null;
		this.TemplateReplacement = null;
		this.Mode = null;
		this.Permissions = null;
		this.Lang = null;
		this.OfflineApp = false;
		this.Encrypted;
		this.EncryptedInfo;
		this.IsEnabledPlugins = true;
		this.IsEnabledMacroses = true;
		this.IsWebOpening = false;
		this.SupportsOnSaveDocument = false;
		this.Wopi = null;
		this.shardkey = null;

		//for external reference
		this.ReferenceData = null;

		this.showVerticalScroll = null;
		this.showHorizontalScroll = null;
	}

	prot = asc_CDocInfo.prototype;
	prot.clone = function () {
		let res = new asc_CDocInfo();
		res.Id = this.Id;
		res.Url = this.Url;
		res.Title = this.Title;
		res.Format = this.Format;
		res.VKey = this.VKey;
		res.Token = this.Token;
		res.UserInfo = this.UserInfo ? this.UserInfo.clone() : null;
		res.Options = this.Options ? JSON.parse(JSON.stringify(this.Options)) : null;
		res.CallbackUrl = this.CallbackUrl;
		res.TemplateReplacement = this.TemplateReplacement ? JSON.parse(JSON.stringify(this.TemplateReplacement)) : null;
		res.Mode = this.Mode;
		res.Permissions = this.Permissions ? JSON.parse(JSON.stringify(this.Permissions)) : null;
		res.Lang = this.Lang;
		res.OfflineApp = this.OfflineApp;
		res.Encrypted = this.Encrypted;
		res.EncryptedInfo = this.EncryptedInfo ? JSON.parse(JSON.stringify(this.EncryptedInfo)) : undefined;
		res.IsEnabledPlugins = this.IsEnabledPlugins;
		res.IsEnabledMacroses = this.IsEnabledMacroses;
		res.IsWebOpening = this.IsWebOpening;
		res.SupportsOnSaveDocument = this.SupportsOnSaveDocument;
		res.Wopi = this.Wopi ? JSON.parse(JSON.stringify(this.Wopi)) : null;
		res.shardkey = this.shardkey;
		res.ReferenceData = this.ReferenceData ? JSON.parse(JSON.stringify(this.ReferenceData)) : null;
		return res;
	};
	prot.extendWithWopiParams = function(data) {
		let docInfo = this.clone();
		//like in web-apps/apps/api/wopi/editor-wopi.ejs and onRefreshFile(web-apps/apps/documenteditor/main/app/controller/Main.js)
		let key = data["key"];
		let userAuth = data["userAuth"];
		let fileInfo = data["fileInfo"];
		let token = data["token"];

		docInfo.put_Id(key);
		if (fileInfo["FileUrl"]) {
			docInfo.put_Url(fileInfo["FileUrl"]);
		} else if (fileInfo["TemplateSource"]) {
			docInfo.put_Url(fileInfo["TemplateSource"]);
		} else if (userAuth) {
			docInfo.put_Url(userAuth["wopiSrc"] + "/contents?access_token=" + userAuth["access_token"]);
		}
		docInfo.put_Title(fileInfo["BreadcrumbDocName"] || fileInfo["BaseFileName"]);
		docInfo.put_CallbackUrl(JSON.stringify(userAuth));
		docInfo.put_Token(token);
		//todo does userInfo can change? (IsAnonymousUser)

		let fileType = fileInfo["BaseFileName"] ? fileInfo["BaseFileName"].substr(fileInfo["BaseFileName"].lastIndexOf('.') + 1) : "";
		fileType = fileInfo["FileExtension"] ? fileInfo["FileExtension"].substr(1) : fileType;
		fileType = fileType.toLowerCase();
		docInfo.put_Format(fileType);
		docInfo.put_Mode(userAuth["mode"]);
		//todo does permissions can change? (formsubmit, dchat)
		docInfo.put_CoEditingMode(userAuth["mode"] !== "view" ? "fast" : "strict");

		docInfo.put_Wopi({
			"FileNameMaxLength": fileInfo["FileNameMaxLength"] && fileInfo["FileNameMaxLength"] > 0 ? fileInfo["FileNameMaxLength"] : 250,
			"WOPISrc": userAuth["wopiSrc"],
			"UserSessionId": userAuth["userSessionId"],
			"Version": fileInfo["Version"],
			"LastModifiedTime": fileInfo["LastModifiedTime"]
		});
		return docInfo;
	};
	prot.isFormatWithForms = function () {
		return this.Format === "oform" || this.Format === "docxf" || this.Format === "pdf";
	};
	prot.get_Id = prot.asc_getId = function () {
		return this.Id
	};
	prot.put_Id = prot.asc_putId = function (v) {
		this.Id = v;
	};
	prot.get_Url = prot.asc_getUrl = function () {
		return this.Url;
	};
	prot.put_Url = prot.asc_putUrl = function (v) {
		this.Url = v;
	};
	prot.get_DirectUrl = prot.asc_getDirectUrl = function () {
		return this.DirectUrl;
	};
	prot.put_DirectUrl = prot.asc_putDirectUrl = function (v) {
		this.DirectUrl = v;
	};
	prot.get_Title = prot.asc_getTitle = function () {
		return this.Title;
	};
	prot.put_Title = prot.asc_putTitle = function (v) {
		this.Title = v;
	};
	prot.get_Format = prot.asc_getFormat = function () {
		return this.Format;
	};
	prot.put_Format = prot.asc_putFormat = function (v) {
		this.Format = v;
	};
	prot.get_VKey = prot.asc_getVKey = function () {
		return this.VKey;
	};
	prot.put_VKey = prot.asc_putVKey = function (v) {
		this.VKey = v;
	};
	prot.get_Token = prot.asc_getToken = function () {
		return this.Token;
	};
	prot.put_Token = prot.asc_putToken = function (v) {
		this.Token = v;
	};
	prot.get_OfflineApp = function () {
		return this.OfflineApp;
	};
	prot.put_OfflineApp = function (v) {
		this.OfflineApp = v;
	};
	prot.get_UserId = prot.asc_getUserId = function () {
		return (this.UserInfo ? this.UserInfo.get_Id() : null);
	};
	prot.get_UserName = prot.asc_getUserName = function () {
		return (this.UserInfo ? this.UserInfo.get_FullName() : null);
	};
	prot.get_FirstName = prot.asc_getFirstName = function () {
		return (this.UserInfo ? this.UserInfo.get_FirstName() : null);
	};
	prot.get_LastName = prot.asc_getLastName = function () {
		return (this.UserInfo ? this.UserInfo.get_LastName() : null);
	};
	prot.get_IsAnonymousUser = prot.get_IsAnonymousUser = function () {
		return (this.UserInfo ? this.UserInfo.get_IsAnonymousUser() : null);
	};
	prot.get_Options = prot.asc_getOptions = function () {
		return this.Options;
	};
	prot.put_Options = prot.asc_putOptions = function (v) {
		this.Options = v;
	};
	prot.get_CallbackUrl = prot.asc_getCallbackUrl = function () {
		return this.CallbackUrl;
	};
	prot.put_CallbackUrl = prot.asc_putCallbackUrl = function (v) {
		this.CallbackUrl = v;
	};
	prot.get_TemplateReplacement = prot.asc_getTemplateReplacement = function () {
		return this.TemplateReplacement;
	};
	prot.put_TemplateReplacement = prot.asc_putTemplateReplacement = function (v) {
		this.TemplateReplacement = v;
	};
	prot.get_UserInfo = prot.asc_getUserInfo = function () {
		return this.UserInfo;
	};
	prot.put_UserInfo = prot.asc_putUserInfo = function (v) {
		this.UserInfo = v;
	};
	prot.get_Mode = prot.asc_getMode = function () {
		return this.Mode;
	};
	prot.put_Mode = prot.asc_putMode = function (v) {
		this.Mode = v;
	};
	prot.get_Permissions = prot.asc_getPermissions = function () {
		return this.Permissions;
	};
	prot.put_Permissions = prot.asc_putPermissions = function (v) {
		this.Permissions = v;
	};
	prot.get_Lang = prot.asc_getLang = function () {
		return this.Lang;
	};
	prot.put_Lang = prot.asc_putLang = function (v) {
		this.Lang = v;
	};
	prot.get_Encrypted = prot.asc_getEncrypted = function () {
		return this.Encrypted;
	};
	prot.put_Encrypted = prot.asc_putEncrypted = function (v) {
		this.Encrypted = v;
	};
	prot.get_EncryptedInfo = prot.asc_getEncryptedInfo = function () {
		return this.EncryptedInfo;
	};
	prot.put_EncryptedInfo = prot.asc_putEncryptedInfo = function (v) {
		this.EncryptedInfo = v;
	};
	prot.get_IsEnabledPlugins = prot.asc_getIsEnabledPlugins = function () {
		return this.IsEnabledPlugins;
	};
	prot.put_IsEnabledPlugins = prot.asc_putIsEnabledPlugins = function (v) {
		this.IsEnabledPlugins = v;
	};
	prot.get_IsEnabledMacroses = prot.asc_getIsEnabledMacroses = function () {
		return this.IsEnabledMacroses;
	};
	prot.put_IsEnabledMacroses = prot.asc_putIsEnabledMacroses = function (v) {
		this.IsEnabledMacroses = v;
	};
	prot.get_CoEditingMode = prot.asc_getCoEditingMode = function () {
		return this.coEditingMode;
	};
	prot.put_CoEditingMode = prot.asc_putCoEditingMode = function (v) {
		this.coEditingMode = v;
	};
	prot.put_ReferenceData = prot.asc_putReferenceData = function (v) {
		this.ReferenceData = v;
	};
	prot.put_IsWebOpening = prot.asc_putIsWebOpening = function (v) {
		this.IsWebOpening = v;
	};
	prot.get_IsWebOpening = prot.asc_getIsWebOpening = function () {
		return this.IsWebOpening;
	};
	prot.put_SupportsOnSaveDocument = prot.asc_putSupportsOnSaveDocument = function (v) {
		this.SupportsOnSaveDocument = v;
	};
	prot.get_SupportsOnSaveDocument = prot.asc_getSupportsOnSaveDocument = function () {
		return this.SupportsOnSaveDocument;
	};
	prot.put_Wopi = prot.asc_putWopi = function (v) {
		this.Wopi = v;
	};
	prot.get_Wopi = prot.asc_getWopi = function () {
		return this.Wopi;
	};
	prot.put_Shardkey = prot.asc_putShardkey = function (v) {
		this.shardkey = v;
	};
	prot.get_Shardkey = prot.asc_getShardkey = function () {
		return this.shardkey;
	};
	prot.put_ShowVerticalScroll = prot.asc_putShowVerticalScroll = function (v) {
		this.showVerticalScroll = v;
	};
	prot.get_ShowVerticalScroll = prot.asc_getShowVerticalScroll = function () {
		return this.showVerticalScroll;
	};
	prot.put_ShowHorizontalScroll = prot.asc_putShowHorizontalScroll = function (v) {
		this.showHorizontalScroll = v;
	};
	prot.get_ShowHorizontalScroll = prot.asc_getShowHorizontalScroll = function () {
		return this.showHorizontalScroll;
	};

	function COpenProgress() {
		this.Type = Asc.c_oAscAsyncAction.Open;

		this.FontsCount = 0;
		this.CurrentFont = 0;

		this.ImagesCount = 0;
		this.CurrentImage = 0;
	}

	COpenProgress.prototype.asc_getType = function () {
		return this.Type
	};
	COpenProgress.prototype.asc_getFontsCount = function () {
		return this.FontsCount
	};
	COpenProgress.prototype.asc_getCurrentFont = function () {
		return this.CurrentFont
	};
	COpenProgress.prototype.asc_getImagesCount = function () {
		return this.ImagesCount
	};
	COpenProgress.prototype.asc_getCurrentImage = function () {
		return this.CurrentImage
	};

	function CErrorData() {
		this.Value = 0;
	}

	CErrorData.prototype.put_Value = function (v) {
		this.Value = v;
	};
	CErrorData.prototype.get_Value = function () {
		return this.Value;
	};

	function CAscMathType() {
		this.Id = 0;

		this.X = 0;
		this.Y = 0;
	}

	CAscMathType.prototype.get_Id = function () {
		return this.Id;
	};
	CAscMathType.prototype.get_X = function () {
		return this.X;
	};
	CAscMathType.prototype.get_Y = function () {
		return this.Y;
	};

	function CAscMathCategory() {
		this.Id = 0;
		this.Data = [];

		this.W = 0;
		this.H = 0;
	}

	CAscMathCategory.prototype.get_Id = function () {
		return this.Id;
	};
	CAscMathCategory.prototype.get_Data = function () {
		return this.Data;
	};
	CAscMathCategory.prototype.get_W = function () {
		return this.W;
	};
	CAscMathCategory.prototype.get_H = function () {
		return this.H;
	};
	CAscMathCategory.prototype.private_Sort = function () {
		this.Data.sort(function (a, b) {
			return a.Id - b.Id;
		});
	};

	function CStyleImage(name, type, image, uiPriority) {
		this.name = name;
		this.displayName = null;
		this.type = type;
		this.image = image;
		this.uiPriority = uiPriority;
	}

	CStyleImage.prototype.asc_getId = CStyleImage.prototype.asc_getName = CStyleImage.prototype.get_Name = function () {
		return this.name;
	};
	CStyleImage.prototype.asc_getDisplayName = function () {
		return this.displayName;
	};
	CStyleImage.prototype.asc_getType = CStyleImage.prototype.get_Type = function () {
		return this.type;
	};
	CStyleImage.prototype.asc_getImage = function () {
		return this.image;
	};

	/** @constructor */
	function asc_CSpellCheckProperty(Word, Checked, Variants, ParaId, Element) {
		this.Word = Word;
		this.Checked = Checked;
		this.Variants = Variants;

		this.ParaId = ParaId;
		this.Element = Element;
	}

	asc_CSpellCheckProperty.prototype.get_Word = function () {
		return this.Word;
	};
	asc_CSpellCheckProperty.prototype.get_Checked = function () {
		return this.Checked;
	};
	asc_CSpellCheckProperty.prototype.get_Variants = function () {
		return this.Variants;
	};

	function CWatermarkOnDraw(htmlContent, api) {
		// example content:
		/*
		{
			"type" : "rect",
			"width" : 100, // mm
			"height" : 100, // mm
			"rotate" : -45, // degrees
			"margins" : [ 10, 10, 10, 10 ], // text margins
			"fill" : [255, 0, 0], // [] => none // "image_url"
			"stroke-width" : 1, // mm
			"stroke" : [0, 0, 255], // [] => none
			"align" : 1, // vertical text align (4 - top, 1 - center, 0 - bottom)

			"paragraphs" : [
				{
					"align" : 4, // horizontal text align [1 - left, 2 - center, 0 - right, 3 - justify]
					"fill" : [255, 0, 0], // paragraph highlight. [] => none
					"linespacing" : 0,

					"runs" : [
						{
							"text" : "some text",
							"fill" : [255, 255, 255], // text highlight. [] => none,
							"font-family" : "Arial",
							"font-size" : 24, // pt
							"bold" : true,
							"italic" : false,
							"strikeout" : "false",
							"underline" : "false"
						},
						{
							"text" : "<%br%>"
						}
					]
				}
			]
		}
		*/

		this.api = api;
		this.isFontsLoaded = false;

		this.inputContentSrc = htmlContent;
		if (typeof this.inputContentSrc === "object") this.inputContentSrc = JSON.stringify(this.inputContentSrc);

		this.replaceMap = {};

		this.image = null;
		this.imageBase64 = undefined;
		this.width = 0;
		this.height = 0;

		this.imageBackgroundUrl = "";
		this.imageBackground = null;

		this.transparent = 0.3;
		this.zoom = 1;
		this.calculatezoom = -1;

		this.isNativeGlobalAlpha = false;

		this.contentObjects = null;

		this.CheckParams = function () {
			this.replaceMap["%user_name%"] = this.api.User.userName;

			let content = this.inputContentSrc;
			for (let key in this.replaceMap) {
				if (!this.replaceMap.hasOwnProperty(key)) continue;
				content = content.replace(new RegExp(key, 'g'), this.replaceMap[key]);
			}
			this.contentObjects = {};
			try {
				let _objTmp = JSON.parse(content);
				this.contentObjects = _objTmp;
			} catch (err) {
			}

			this.transparent = (undefined == this.contentObjects['transparent']) ? 0.3 : this.contentObjects['transparent'];
		};

		this.Generate = function () {
			if (!this.isFontsLoaded) return;

			if (this.zoom == this.calculatezoom) return;

			this.calculatezoom = this.zoom;
			this.privateGenerateShape(this.contentObjects);
			//console.log( this.image.toDataURL("image/png"));
		};

		this.getCorrectedInputContentSrc = function() {
			let content = this.inputContentSrc;
			for (let key in this.replaceMap) {
				if (!this.replaceMap.hasOwnProperty(key)) continue;
				content = content.replace(new RegExp(key, 'g'), this.replaceMap[key]);
			}
			return content;
		};

		this.Draw = function (context, dw_or_dx, dh_or_dy, dw, dh) {
			if (!this.image || !this.isFontsLoaded) return;

			let x = 0;
			let y = 0;

			if (undefined == dw) {
				x = (dw_or_dx - this.width) >> 1;
				y = (dh_or_dy - this.height) >> 1;
			}
			else {
				x = (dw_or_dx + ((dw - this.width) / 2)) >> 0;
				y = (dh_or_dy + ((dh - this.height) / 2)) >> 0;
			}
			let oldGlobalAlpha = context.globalAlpha;
			context.globalAlpha = this.transparent;
			context.drawImage(this.image, x, y);
			context.globalAlpha = oldGlobalAlpha;
		};

		this.StartRenderer = function () {
			if (window["NATIVE_EDITOR_ENJINE"]) return;

			let canvasTransparent = document.createElement("canvas");
			canvasTransparent.width = this.image.width;
			canvasTransparent.height = this.image.height;
			let ctx = canvasTransparent.getContext("2d");
			ctx.globalAlpha = this.transparent;
			ctx.drawImage(this.image, 0, 0);
			try {
				this.imageBase64 = canvasTransparent.toDataURL("image/png");
			}
			catch (e) {
				this.imageBase64 = undefined;
				this.api.sendEvent("asc_onError", Asc.c_oAscError.ID.CannotSaveWatermark, Asc.c_oAscError.Level.NoCritical);
			}
			canvasTransparent = null;
		};
		this.EndRenderer = function () {
			if (window["NATIVE_EDITOR_ENJINE"]) return;

			delete this.imageBase64;
			this.imageBase64 = undefined;
		};
		this.DrawOnRenderer = function (renderer, w, h) {
			if(!this.imageBase64) {
				return;
			}
			let wMM = this.width * AscCommon.g_dKoef_pix_to_mm / this.zoom;
			let hMM = this.height * AscCommon.g_dKoef_pix_to_mm / this.zoom;
			let x = (w - wMM) / 2;
			let y = (h - hMM) / 2;

			if (window["NATIVE_EDITOR_ENJINE"]) {
				renderer.put_brushTexture(this.imageBase64, 0);
				renderer.put_BrushTextureAlpha((255 * this.transparent) >> 0);
				renderer._e();
				renderer.rect(x, y, wMM, hMM);
				renderer.df();
				renderer._e();
			}
			else {
				renderer.UseOriginImageUrl = true;
				renderer.drawImage(this.imageBase64, x, y, wMM, hMM);
				renderer.UseOriginImageUrl = false;
			}
		};

		this.privateGenerateShape = function (obj) {

			AscFormat.ExecuteNoHistory(function (obj) {

				let oShape = new AscFormat.CShape();
				let bWord = false;
				let oApi = Asc['editor'] || editor;
				if (!oApi) {
					return null;
				}
				switch (oApi.getEditorId()) {
					case AscCommon.c_oEditorId.Word: {
						bWord = true && !oApi.isPdfEditor();
						oShape.setWordShape(bWord);
						break;
					}
					case AscCommon.c_oEditorId.Presentation: {
						oShape.setWordShape(false);
						oShape.setParent(oApi.WordControl.m_oLogicDocument.GetCurrentSlide());
						break;
					}
					case AscCommon.c_oEditorId.Spreadsheet: {
						oShape.setWordShape(false);
						oShape.setWorksheet(oApi.wb.getWorksheet().model);
						break;
					}
					case AscCommon.c_oEditorId.Visio: {
						oShape.setWordShape(false);
						oShape.setParent(oApi.WordControl.m_oLogicDocument);
						break;
					}
				}

				let _oldTrackRevision = false;
				if (oApi.getEditorId() === AscCommon.c_oEditorId.Word && oApi.WordControl && oApi.WordControl.m_oLogicDocument && !oApi.isPdfEditor())
					_oldTrackRevision = oApi.WordControl.m_oLogicDocument.GetLocalTrackRevisions();

				if (false !== _oldTrackRevision)
					oApi.WordControl.m_oLogicDocument.SetLocalTrackRevisions(false);

				let bRemoveDocument = false;
				if (oApi.WordControl && !oApi.WordControl.m_oLogicDocument) {
					// TODO: Зачем это здесь вообще?
					bRemoveDocument = true;
					oApi.WordControl.m_oLogicDocument = new AscWord.CDocument(null, false);
					oApi.WordControl.m_oDrawingDocument.m_oLogicDocument = oApi.WordControl.m_oLogicDocument;
				}
				oShape.setBDeleted(false);
				oShape.spPr = new AscFormat.CSpPr();
				oShape.spPr.setParent(oShape);
				oShape.spPr.setXfrm(new AscFormat.CXfrm());
				oShape.spPr.xfrm.setParent(oShape.spPr);
				oShape.spPr.xfrm.setOffX(0);
				oShape.spPr.xfrm.setOffY(0);
				oShape.spPr.xfrm.setExtX(obj['width']);
				oShape.spPr.xfrm.setExtY(obj['height']);
				oShape.spPr.xfrm.setRot(AscFormat.normalizeRotate(obj['rotate'] ? (obj['rotate'] * Math.PI / 180) : 0));
				oShape.spPr.setGeometry(AscFormat.CreateGeometry(obj['type'] || "rect"));
				if (obj['fill'] && obj['fill'].length === 3) {
					oShape.spPr.setFill(AscFormat.CreateSolidFillRGB(obj['fill'][0], obj['fill'][1], obj['fill'][2]));
				}
				else if (this.imageBackground) {
					oApi.ImageLoader.map_image_index[this.imageBackgroundUrl] = {
						Image: this.imageBackground, Status: AscFonts.ImageLoadStatus.Complete
					};
					oShape.spPr.setFill(AscFormat.builder_CreateBlipFill(this.imageBackgroundUrl, "stretch"));
				}
				if (AscFormat.isRealNumber(obj['stroke-width']) || Array.isArray(obj['stroke']) && obj['stroke'].length === 3) {
					let oUnifill;
					if (Array.isArray(obj['stroke']) && obj['stroke'].length === 3) {
						oUnifill = AscFormat.CreateSolidFillRGB(obj['stroke'][0], obj['stroke'][1], obj['stroke'][2]);
					}
					else {
						oUnifill = AscFormat.CreateSolidFillRGB(0, 0, 0);
					}
					oShape.spPr.setLn(AscFormat.CreatePenFromParams(oUnifill, undefined, undefined, undefined, undefined, AscFormat.isRealNumber(obj['stroke-width']) ? obj['stroke-width'] : 12700.0 / 36000.0));
				}

				if (bWord) {
					oShape.createTextBoxContent();
				}
				else {
					oShape.createTextBody();
				}
				let align = obj['align'];
				if (undefined != align) {
					oShape.setVerticalAlign(align);
				}
				else {

					oShape.setVerticalAlign(1);//ctr
				}
				oShape.setVertOverflowType(AscFormat.nVOTOverflow);
				if (Array.isArray(obj['margins']) && obj['margins'].length === 4) {
					oShape.setPaddings({
						Left: obj['margins'][0],
						Top: obj['margins'][1],
						Right: obj['margins'][2],
						Bottom: obj['margins'][3]
					});
				}
				let oContent = oShape.getDocContent();
				let aParagraphsS = obj['paragraphs'] || [];
				if (aParagraphsS.length > 0) {
					oContent.Content.length = 0;
				}
				for (let i = 0; i < aParagraphsS.length; ++i) {
					let oCurParS = aParagraphsS[i];
					let oNewParagraph = new AscWord.Paragraph(oContent, !bWord);
					if (AscFormat.isRealNumber(oCurParS['align'])) {
						oNewParagraph.Set_Align(oCurParS['align'])
					}
					if (Array.isArray(oCurParS['fill']) && oCurParS['fill'].length === 3) {
						let oShd = new AscCommonWord.CDocumentShd();
						oShd.Value = Asc.c_oAscShdClear;
						oShd.Color.r = oCurParS['fill'][0];
						oShd.Color.g = oCurParS['fill'][1];
						oShd.Color.b = oCurParS['fill'][2];
						oShd.Fill = new AscCommonWord.CDocumentColor();
						oShd.Fill.r = oCurParS['fill'][0];
						oShd.Fill.g = oCurParS['fill'][1];
						oShd.Fill.b = oCurParS['fill'][2];
						oNewParagraph.Set_Shd(oShd, true);
					}
					if (AscFormat.isRealNumber(oCurParS['linespacing'])) {
						oNewParagraph.Set_Spacing({
							Line: oCurParS['linespacing'], Before: 0, After: 0, LineRule: Asc.linerule_Auto
						}, true);
					}
					let aRunsS = oCurParS['runs'];
					for (let j = 0; j < aRunsS.length; ++j) {
						let oRunS = aRunsS[j];
						let oRun = new AscCommonWord.ParaRun(oNewParagraph, false);
						if (Array.isArray(oRunS['fill']) && oRunS['fill'].length === 3) {
							oRun.Set_Unifill(AscFormat.CreateSolidFillRGB(oRunS['fill'][0], oRunS['fill'][1], oRunS['fill'][2]));
						}
						let fontFamilyName = oRunS['font-family'] ? oRunS['font-family'] : "Arial";
						let fontSize = (oRunS['font-size'] != null) ? oRunS['font-size'] : 50;

						oRun.SetRFontsAscii({Name: fontFamilyName, Index: -1});
						oRun.SetRFontsCS({Name: fontFamilyName, Index: -1});
						oRun.SetRFontsEastAsia({Name: fontFamilyName, Index: -1});
						oRun.SetRFontsHAnsi({Name: fontFamilyName, Index: -1});

						oRun.SetFontSize(fontSize);

						oRun.SetBold(oRunS['bold'] === true);
						oRun.SetItalic(oRunS['italic'] === true);
						oRun.SetStrikeout(oRunS['strikeout'] === true);
						oRun.SetUnderline(oRunS['underline'] === true);

						let sCustomText = oRunS['text'];
						if (sCustomText === "<%br%>") {
							oRun.AddToContent(0, new AscWord.CRunBreak(AscWord.break_Line), false);
						}
						else {
							oRun.AddText(sCustomText);
						}

						oNewParagraph.Internal_Content_Add(j, oRun, false);
					}
					oContent.Internal_Content_Add(oContent.Content.length, oNewParagraph);
				}

				let bLoad = AscCommon.g_oIdCounter.m_bLoad;
				AscCommon.g_oIdCounter.Set_Load(false);
				oShape.recalculate();
				if (oShape.bWordShape) {
					oShape.recalculateText();
				}

				AscCommon.g_oIdCounter.Set_Load(bLoad);
				let oldShowParaMarks;
				if (window.editor) {
					oldShowParaMarks = oApi.ShowParaMarks;
					oApi.ShowParaMarks = false;
				}

				AscCommon.IsShapeToImageConverter = true;
				let _bounds_cheker = new AscFormat.CSlideBoundsChecker();

				let w_mm = 210;
				let h_mm = 297;
				let w_px = AscCommon.AscBrowser.convertToRetinaValue(w_mm * AscCommon.g_dKoef_mm_to_pix * this.zoom, true);
				let h_px = AscCommon.AscBrowser.convertToRetinaValue(h_mm * AscCommon.g_dKoef_mm_to_pix * this.zoom, true);

				_bounds_cheker.init(w_px, h_px, w_mm, h_mm);
				_bounds_cheker.transform(1, 0, 0, 1, 0, 0);

				_bounds_cheker.AutoCheckLineWidth = true;
				_bounds_cheker.CheckLineWidth(oShape);
				oShape.draw(_bounds_cheker, 0);
				_bounds_cheker.CorrectBounds2();

				let _need_pix_width = _bounds_cheker.Bounds.max_x - _bounds_cheker.Bounds.min_x + 1;
				let _need_pix_height = _bounds_cheker.Bounds.max_y - _bounds_cheker.Bounds.min_y + 1;

				if (_need_pix_width <= 0 || _need_pix_height <= 0) return;

				if (!this.image) this.image = document.createElement("canvas");

				this.image.width = _need_pix_width;
				this.image.height = _need_pix_height;
				this.width = _need_pix_width;
				this.height = _need_pix_height;

				let _ctx = this.image.getContext('2d');

				let g = null;

				if (window["NATIVE_EDITOR_ENJINE"]) {
					g = new AscCommon.CNativeGraphics();
					g.width = _need_pix_width;
					g.height = _need_pix_height;
					g.create(window["native"], _need_pix_width, _need_pix_height, _need_pix_width / AscCommon.g_dKoef_mm_to_pix, _need_pix_height / AscCommon.g_dKoef_mm_to_pix);
					g.CoordTransformOffset(-_bounds_cheker.Bounds.min_x, -_bounds_cheker.Bounds.min_y);
					g.transform(1, 0, 0, 1, 0, 0);

					if (this.isNativeGlobalAlpha)
						g.CreateLayer(this.transparent);
				}
				else {
					g = new AscCommon.CGraphics();
					g.init(_ctx, w_px, h_px, w_mm, h_mm);
					g.m_oFontManager = AscCommon.g_fontManager;

					g.m_oCoordTransform.tx = -_bounds_cheker.Bounds.min_x;
					g.m_oCoordTransform.ty = -_bounds_cheker.Bounds.min_y;
					g.transform(1, 0, 0, 1, 0, 0);
				}

				oShape.draw(g, 0);

				if (window["NATIVE_EDITOR_ENJINE"])
				{
					if (this.isNativeGlobalAlpha)
						g.BlendLayer();
					this.imageBase64 = g.toDataURL("image/png");
				}

				AscCommon.IsShapeToImageConverter = false;

				if (bRemoveDocument) {
					oApi.WordControl.m_oLogicDocument = null;
					oApi.WordControl.m_oDrawingDocument.m_oLogicDocument = null;
				}
				if (window.editor) {
					oApi.ShowParaMarks = oldShowParaMarks;
				}

				if (false !== _oldTrackRevision)
					oApi.WordControl.m_oLogicDocument.SetLocalTrackRevisions(_oldTrackRevision);

				if (this.imageBackground)
					delete oApi.ImageLoader.map_image_index[this.imageBackgroundUrl];

			}, this, [obj]);

		};

		this.onReady = function () {
			this.isFontsLoaded = true;
			let oApi = this.api;

			switch (oApi.editorId) {
				case AscCommon.c_oEditorId.Word: {
					if (oApi.WordControl) {
						if (oApi.watermarkDraw) {
							oApi.watermarkDraw.zoom = oApi.WordControl.m_nZoomValue / 100;
							oApi.watermarkDraw.Generate();
						}

						oApi.WordControl.OnRePaintAttack();
					}

					break;
				}
				case AscCommon.c_oEditorId.Presentation:
				case AscCommon.c_oEditorId.Visio: {
					if (oApi.WordControl) {
						if (oApi.watermarkDraw) {
							oApi.watermarkDraw.zoom = oApi.WordControl.m_nZoomValue / 100;
							oApi.watermarkDraw.Generate();
						}

						oApi.WordControl.OnRePaintAttack();
					}
					break;
				}
				case AscCommon.c_oEditorId.Spreadsheet: {
					let ws = oApi.wb && oApi.wb.getWorksheet();
					if (ws && ws.objectRender && ws.objectRender) {
						ws.objectRender.OnUpdateOverlay();
					}
					break;
				}
			}
		};

		this.checkOnReady = function () {
			this.CheckParams();

			let fonts = [];
			let pars = this.contentObjects['paragraphs'] || [];
			let i, j;
			for (i = 0; i < pars.length; i++) {
				let runs = pars[i]['runs'];
				for (j = 0; j < runs.length; j++) {
					if (undefined === runs[j]["font-family"]) runs[j]["font-family"] = "Arial";
					fonts.push(runs[j]["font-family"]);
				}
			}

			for (i = 0; i < fonts.length; i++) {
				fonts[i] = new AscFonts.CFont(AscFonts.g_fontApplication.GetFontInfoName(fonts[i]));
			}

			if ("string" === typeof this.contentObjects["fill"]) this.imageBackgroundUrl = this.contentObjects["fill"];

			if (false === AscCommon.g_font_loader.CheckFontsNeedLoading(fonts)) {
				this.loadBackgroundImage();
				return;
			}

			this.api.asyncMethodCallback = function () {
				let oApi = Asc['editor'] || editor;
				oApi.watermarkDraw.loadBackgroundImage();
			};

			AscCommon.g_font_loader.LoadDocumentFonts2(fonts);
		};

		this.loadBackgroundImage = function () {
			if ("" === this.imageBackgroundUrl) {
				this.onReady();
				return;
			}

			this.imageBackground = new Image();
			this.imageBackground.onload = function () {
				Asc["editor"].watermarkDraw.onReady();
			};
			this.imageBackground.onerror = function () {
				Asc["editor"].watermarkDraw.imageBackground = null;
				Asc["editor"].watermarkDraw.onReady();
			};
			this.imageBackground.src = this.imageBackgroundUrl;
		};

		this.generateNative = function () {
			this.isFontsLoaded = true;
			this.zoom = 1;
			this.calculatezoom = 0;
			this.CheckParams();

			if (this.contentObjects && "string" === typeof this.contentObjects["fill"])
			{
				this.imageBackgroundUrl = this.contentObjects["fill"];
				this.imageBackground = {};
			}

			this.Generate();
		};
	}

	// ----------------------------- plugins ------------------------------- //
	let PluginType = {
		System: 0,      // Системный, неотключаемый плагин.
		Background: 1,  // Фоновый плагин. Тоже самое, что и системный, но отключаемый.
		Window: 2,      // Окно
		Panel: 3,       // Панель
		Invisible : 4,  // Невидимый
		PanelRight: 5   // Панель справа
	};

	PluginType["System"] = PluginType.System;
	PluginType["Background"] = PluginType.Background;
	PluginType["Window"] = PluginType.Window;
	PluginType["Panel"] = PluginType.Panel;
	PluginType["PanelRight"] = PluginType.PanelRight;
	PluginType["Unvisible"] = PluginType.Unvisible;

	PluginType["getType"] = PluginType.getType = function(type) {
		if (undefined === type)
			return undefined;

		if (typeof type !== "string")
			return type;

		switch (type) {
			case "system" : return this.System;
			case "background" : return this.Background;
			case "window" : return this.Window;
			case "panel" : return this.Panel;
			case "panelRight" : return this.PanelRight;
			case "invisible" : return this.Invisible;
			default: break;
		}

		return this.Background;
	};

	function CPluginVariation() {
		this.description = "";
		this.url = "";
		this.help = "";
		this.baseUrl = "";
		this.index = 0;     // сверху не выставляем. оттуда в каком порядке пришли - в таком порядке и работают

		this.descriptionLocale = undefined;
		this.icons = ["1x", "2x"];
		this.isViewer = false;
		this.isDisplayedInViewer = undefined;
		this.EditorsSupport = ["word", "cell", "slide"];

		this.type = PluginType.Background;

		this.isCustomWindow = false;	// используется только если this.type === PluginType.Window
		this.isModal = true;     // используется только если this.type === PluginType.Window

		this.isCanDocked = false;

		this.initDataType = EPluginDataType.none;
		this.initData = "";

		this.isUpdateOleOnResize = false;

		this.buttons = [{"text": "Ok", "primary": true}, {"text": "Cancel", "primary": false}];

		this.size = undefined;
		this.initOnSelectionChanged = undefined;

		this.store = undefined;

		this.events = [];
		this.eventsMap = {};
	}

	CPluginVariation.prototype["get_Description"] = function () {
		return this.description;
	};
	CPluginVariation.prototype["get_Url"] = function () {
		return this.url;
	};
	CPluginVariation.prototype["get_Help"] = function () {
		return this.help;
	};

	CPluginVariation.prototype["get_Icons"] = function () {
		return this.icons;
	};

	CPluginVariation.prototype["get_Type"] = function () {
		return this.type;
	};

	CPluginVariation.prototype["get_Visual"] = function () {
		return (this.type === PluginType.Window || this.type === PluginType.Panel || this.type === PluginType.PanelRight) ? true : false;
	};

	CPluginVariation.prototype["get_Viewer"] = function () {
		return this.isViewer;
	};
	CPluginVariation.prototype["get_EditorsSupport"] = function () {
		return this.EditorsSupport;
	};

	CPluginVariation.prototype["get_Modal"] = function () {
		return this.isModal;
	};
	CPluginVariation.prototype["get_InsideMode"] = function () {
		return (this.type === PluginType.Panel || this.type === PluginType.PanelRight) ? true : false;
	};
	CPluginVariation.prototype["get_CustomWindow"] = function () {
		return this.isCustomWindow;
	};

	CPluginVariation.prototype["get_IsCanDocked"] = function () {
		return this.isCanDocked;
	};

	CPluginVariation.prototype["get_Buttons"] = function () {
		return this.buttons;
	};
	CPluginVariation.prototype["get_Size"] = function () {
		return this.size;
	};
	CPluginVariation.prototype["get_Events"] = function () {
		return this.events;
	};
	CPluginVariation.prototype["set_Events"] = function (value) {
		if (!value) return;

		this.events = value.slice(0, value.length);
		this.eventsMap = {};
		for (let i = 0; i < this.events.length; i++) this.eventsMap[this.events[i]] = true;
	};

	CPluginVariation.prototype["serialize"] = function () {
		let _object = {};
		_object["description"] = this.description;
		_object["url"] = this.url;
		_object["help"] = this.help;
		_object["index"] = this.index;

		_object["descriptionLocale"] = this.descriptionLocale;

		_object["icons"] = this.icons;
		_object["icons2"] = this.icons2;

		_object["isViewer"] = this.isViewer;
		_object["isDisplayedInViewer"] = this.isDisplayedInViewer;
		_object["EditorsSupport"] = this.EditorsSupport;

		_object["type"] = this.type;

		_object["isCustomWindow"] = this.isCustomWindow;
		_object["isModal"] = this.isModal;

		_object["isCanDocked"] = this.isCanDocked;

		_object["initDataType"] = this.initDataType;
		_object["initData"] = this.initData;

		_object["isUpdateOleOnResize"] = this.isUpdateOleOnResize;

		_object["buttons"] = this.buttons;

		_object["size"] = this.size;
		_object["initOnSelectionChanged"] = this.initOnSelectionChanged;

		_object["store"] = this.store;

		if (this.events)
			_object["events"] = this.events.slice(0, this.events.length);

		return _object;
	};
	CPluginVariation.prototype["deserialize"] = function (_object) {
		this.description = (_object["description"] != null) ? _object["description"] : this.description;
		this.url = (_object["url"] != null) ? _object["url"] : this.url;
		this.help = (_object["help"] != null) ? _object["help"] : this.help;
		this.index = (_object["index"] != null) ? _object["index"] : this.index;

		this.descriptionLocale = (_object["descriptionLocale"] != null) ? _object["descriptionLocale"] : this.descriptionLocale;
		this.icons = (_object["icons"] != null) ? _object["icons"] : this.icons;
		this.icons2 = (_object["icons2"] != null) ? _object["icons2"] : this.icons2;
		this.isViewer = (_object["isViewer"] != null) ? _object["isViewer"] : this.isViewer;
		this.isDisplayedInViewer = (_object["isDisplayedInViewer"] != null) ? _object["isDisplayedInViewer"] : this.isDisplayedInViewer;
		this.EditorsSupport = (_object["EditorsSupport"] != null) ? _object["EditorsSupport"] : this.EditorsSupport;

		// default: background
		this.type = PluginType.Background;

		let _type = PluginType.getType(_object["type"]);
		if (undefined !== _type) {
			this.type = _type;
		}
		else {
			// old version: not support background plugins
			if (true === _object["isSystem"])
				this.type = PluginType.System;
			else if (true === _object["isVisual"])
				this.type = (true === _object["isInsideMode"]) ? PluginType.Panel : PluginType.Window;
			else
				this.type = PluginType.Invisible;
		}

		this.isCustomWindow = (_object["isCustomWindow"] != null) ? _object["isCustomWindow"] : this.isCustomWindow;
		this.isModal = (_object["isModal"] != null) ? _object["isModal"] : this.isModal;

		this.isCanDocked = (_object["isCanDocked"] != null) ? _object["isCanDocked"] : this.isCanDocked;

		this.initDataType = (_object["initDataType"] != null) ? _object["initDataType"] : this.initDataType;
		this.initData = (_object["initData"] != null) ? _object["initData"] : this.initData;

		this.isUpdateOleOnResize = (_object["isUpdateOleOnResize"] != null) ? _object["isUpdateOleOnResize"] : this.isUpdateOleOnResize;

		this.buttons = (_object["buttons"] != null) ? _object["buttons"] : this.buttons;

		this.store = (_object["store"] != null) ? _object["store"] : this.store;

		if (_object["events"] != null) this["set_Events"](_object["events"]);

		this.size = (_object["size"] != null) ? _object["size"] : this.size;
		this.initOnSelectionChanged = (_object["initOnSelectionChanged"] != null) ? _object["initOnSelectionChanged"] : this.initOnSelectionChanged;
	};

	function CPlugin() {
		this.name = "";
		this.nameLocale = {};
		this.guid = "";
		this.baseUrl = "";
		this.minVersion = "";
		this.version = "";
		this.isConnector = false;
		this.loader;

		this.variations = [];
	}

	CPlugin.prototype["get_Name"] = function (locale) {
		if (locale && this.nameLocale && this.nameLocale[locale]) return this.nameLocale[locale];
		return this.name;
	};
	CPlugin.prototype["set_Name"] = function (value) {
		this.name = value;
	};
	CPlugin.prototype["get_NameLocale"] = function () {
		return this.nameLocale;
	};
	CPlugin.prototype["set_NameLocale"] = function (value) {
		this.nameLocale = value;
	};
	CPlugin.prototype["get_Guid"] = function () {
		return this.guid;
	};
	CPlugin.prototype["set_Guid"] = function (value) {
		this.guid = value;
	};
	CPlugin.prototype["get_BaseUrl"] = function () {
		return this.baseUrl;
	};
	CPlugin.prototype["set_BaseUrl"] = function (value) {
		this.baseUrl = value;
	};
	CPlugin.prototype["get_MinVersion"] = function () {
		return this.minVersion;
	};
	CPlugin.prototype["set_MinVersion"] = function (value) {
		this.minVersion = value;
	};
	CPlugin.prototype["get_Version"] = function () {
		return this.version;
	};
	CPlugin.prototype["set_Version"] = function (value) {
		this.version = value;
	};

	CPlugin.prototype["get_Variations"] = function () {
		return this.variations;
	};
	CPlugin.prototype["set_Variations"] = function (value) {
		this.variations = value;
	};

	CPlugin.prototype["get_Loader"] = function () {
		return this.loader;
	};
	CPlugin.prototype["set_Loader"] = function (value) {
		this.loader = value;
	};

	CPlugin.prototype["serialize"] = function () {
		let _object = {};
		_object["name"] = this.name;
		_object["nameLocale"] = this.nameLocale;
		_object["guid"] = this.guid;
		_object["version"] = this.version;
		_object["baseUrl"] = this.baseUrl;
		_object["minVersion"] = this.minVersion;
		_object["isConnector"] = this.isConnector;
		_object["loader"] = this.loader;

		if (this.group) {
			_object["group"] = {};
			_object["group"]["name"] = this.group.name;
			_object["group"]["rank"] = this.group.rank;
		}

		_object["variations"] = [];
		for (let i = 0; i < this.variations.length; i++) {
			_object["variations"].push(this.variations[i].serialize());
		}
		return _object;
	};
	CPlugin.prototype["deserialize"] = function (_object) {
		this.name = (_object["name"] != null) ? _object["name"] : this.name;
		this.nameLocale = (_object["nameLocale"] != null) ? _object["nameLocale"] : this.nameLocale;
		this.guid = (_object["guid"] != null) ? _object["guid"] : this.guid;
		this.version = (_object["version"] != null) ? _object["version"] : this.version;
		this.baseUrl = (_object["baseUrl"] != null) ? _object["baseUrl"] : this.baseUrl;
		this.minVersion = (_object["minVersion"] != null) ? _object["minVersion"] : this.minVersion;
		this.isConnector = (_object["isConnector"] != null) ? _object["isConnector"] : this.isConnector;
		this.loader = (_object["loader"] != null) ? _object["loader"] : this.loader;

		if (true) {
			// удалим этот if, как передем на просто прокидку объекта в интерфейсе
			if (_object["groupName"] || _object["groupRank"]) this.group = {};

			if (_object["groupName"]) this.group.name = _object["groupName"];
			if (_object["groupRank"]) this.group.rank = _object["groupRank"];
		}

		if (_object["group"]) {
			this.group = {};
			this.group.name = (_object["group"]["name"] != null) ? _object["group"]["name"] : "";
			this.group.rank = (_object["group"]["rank"] != null) ? _object["group"]["rank"] : 0;
		}

		this.variations = [];
		for (let i = 0; i < _object["variations"].length; i++) {
			let _variation = new CPluginVariation();
			_variation["deserialize"](_object["variations"][i]);
			this.variations.push(_variation);
		}
	};

	// no export
	CPlugin.prototype.isType = function (type) {
		if (this.variations && this.variations[0] && this.variations[0].type === type) return true;
		return false;
	};
	CPlugin.prototype.isSystem = function () {
		return this.isType(PluginType.System);
	};
	CPlugin.prototype.isBackground = function () {
		return this.isType(PluginType.Background);
	};
	CPlugin.prototype.getIntVersion = function () {
		if (!this.version) return 0;
		let arrayVersion = this.version.split(".");

		while (arrayVersion.length < 3) arrayVersion.push("0");

		try {
			let intVer = parseInt(arrayVersion[0]) * 10000 + parseInt(arrayVersion[1]) * 100 + parseInt(arrayVersion[2]);
			return intVer;
		} catch (e) {
		}
		return 0;
	};

	/**
	 * @constructor
	 */
	function CDocInfoProp(obj) {
		if (obj) {
			this.PageCount = obj.PageCount;
			this.WordsCount = obj.WordsCount;
			this.ParagraphCount = obj.ParagraphCount;
			this.SymbolsCount = obj.SymbolsCount;
			this.SymbolsWSCount = obj.SymbolsWSCount;
		}
		else {
			this.PageCount = -1;
			this.WordsCount = -1;
			this.ParagraphCount = -1;
			this.SymbolsCount = -1;
			this.SymbolsWSCount = -1;
		}
	}

	CDocInfoProp.prototype.get_PageCount = function () {
		return this.PageCount;
	};
	CDocInfoProp.prototype.put_PageCount = function (v) {
		this.PageCount = v;
	};
	CDocInfoProp.prototype.get_WordsCount = function () {
		return this.WordsCount;
	};
	CDocInfoProp.prototype.put_WordsCount = function (v) {
		this.WordsCount = v;
	};
	CDocInfoProp.prototype.get_ParagraphCount = function () {
		return this.ParagraphCount;
	};
	CDocInfoProp.prototype.put_ParagraphCount = function (v) {
		this.ParagraphCount = v;
	};
	CDocInfoProp.prototype.get_SymbolsCount = function () {
		return this.SymbolsCount;
	};
	CDocInfoProp.prototype.put_SymbolsCount = function (v) {
		this.SymbolsCount = v;
	};
	CDocInfoProp.prototype.get_SymbolsWSCount = function () {
		return this.SymbolsWSCount;
	};
	CDocInfoProp.prototype.put_SymbolsWSCount = function (v) {
		this.SymbolsWSCount = v;
	};
	
	/**
	 * @constructor
	 */
	function RangePermProp(obj) {
		if (obj) {
			this.editText      = undefined !== obj.editText ? obj.editText : true;
			this.editParagraph = undefined !== obj.editParagraph ? obj.editParagraph : true;
			this.insertObject  = undefined !== obj.insertObject ? obj.insertObject : true;
		} else {
			this.editText      = true;
			this.editParagraph = true;
			this.insertObject  = true;
		}
	}
	RangePermProp.prototype.get_canEditText = function() {
		return this.editText;
	};
	RangePermProp.prototype.get_canEditPara = function() {
		return this.editParagraph;
	};
	RangePermProp.prototype.get_canInsObject = function() {
		return this.insertObject;
	};


	function CButtonData(oData) {
		this["obj"] = oData["obj"];
		this["type"] = oData["type"];
		this["button"] = oData["button"];
		this["isForm"] = oData["isForm"];
		this["pr"] = oData["pr"];
	}
	CButtonData.prototype.get_Obj = function() {
		return this["obj"];
	};
	CButtonData.prototype.get_ObjId = function() {
		if(!this["obj"]) return null;
		return this["obj"].Id;
	};
	CButtonData.prototype.get_Type = function() {
		return this["type"];
	};
	CButtonData.prototype.get_Button = function() {
		return this["button"];
	};
	CButtonData.prototype.get_IsForm = function() {
		return this["isForm"];
	};
	CButtonData.prototype.get_Properties = function() {
		return this["pr"];
	};

	/*
	 * Export
	 * -----------------------------------------------------------------------------
	 */
	window['AscCommon'] = window['AscCommon'] || {};
	window['Asc'] = window['Asc'] || {};

	window['Asc']['c_oAscArrUserColors'] = window['Asc'].c_oAscArrUserColors = c_oAscArrUserColors;

	window["AscCommon"].CreateAscColorCustom = CreateAscColorCustom;
	window["AscCommon"].CreateAscColor = CreateAscColor;
	window["AscCommon"].CreateGUID = CreateGUID;
	window["AscCommon"].CreateUUID = CreateUUID;
	window["AscCommon"].CreateUInt32 = CreateUInt32;
	window["AscCommon"].CreateDurableId = CreateDurableId;
	window["AscCommon"].FixDurableId = FixDurableId;
	window["AscCommon"].ExtendPrototype = ExtendPrototype;

	window['Asc']['c_oLicenseResult'] = window['Asc'].c_oLicenseResult = c_oLicenseResult;
	prot = c_oLicenseResult;
	prot['Error'] = prot.Error;
	prot['Expired'] = prot.Expired;
	prot['Success'] = prot.Success;
	prot['UnknownUser'] = prot.UnknownUser;
	prot['Connections'] = prot.Connections;
	prot['ExpiredTrial'] = prot.ExpiredTrial;
	prot['SuccessLimit'] = prot.SuccessLimit;
	prot['UsersCount'] = prot.UsersCount;
	prot['ConnectionsOS'] = prot.ConnectionsOS;
	prot['UsersCountOS'] = prot.UsersCountOS;
	prot['ExpiredLimited'] = prot.ExpiredLimited;
	prot['ConnectionsLiveOS'] = prot.ConnectionsLiveOS;
	prot['ConnectionsLive'] = prot.ConnectionsLive;
	prot['UsersViewCount'] = prot.UsersViewCount;
	prot['UsersViewCountOS'] = prot.UsersViewCountOS;
	prot['NotBefore'] = prot.NotBefore;

	window['Asc']['c_oRights'] = window['Asc'].c_oRights = c_oRights;
	prot = c_oRights;
	prot['None'] = prot.None;
	prot['Edit'] = prot.Edit;
	prot['Review'] = prot.Review;
	prot['Comment'] = prot.Comment;
	prot['View'] = prot.View;

	window['Asc']['c_oLicenseMode'] = window['Asc'].c_oLicenseMode = c_oLicenseMode;
	prot = c_oLicenseMode;
	prot['None'] = prot.None;
	prot['Trial'] = prot.Trial;
	prot['Developer'] = prot.Developer;
	prot['Limited'] = prot.Limited;

	window["Asc"]["EPluginDataType"] = window["Asc"].EPluginDataType = EPluginDataType;
	prot = EPluginDataType;
	prot['none'] = prot.none;
	prot['text'] = prot.text;
	prot['ole'] = prot.ole;
	prot['html'] = prot.html;

	window["AscCommon"]["asc_CSignatureLine"] = window["AscCommon"].asc_CSignatureLine = asc_CSignatureLine;
	prot = asc_CSignatureLine.prototype;
	prot["asc_getId"] = prot.asc_getId;
	prot["asc_setId"] = prot.asc_setId;
	prot["asc_getGuid"] = prot.asc_getGuid;
	prot["asc_setGuid"] = prot.asc_setGuid;
	prot["asc_getSigner1"] = prot.asc_getSigner1;
	prot["asc_setSigner1"] = prot.asc_setSigner1;
	prot["asc_getSigner2"] = prot.asc_getSigner2;
	prot["asc_setSigner2"] = prot.asc_setSigner2;
	prot["asc_getEmail"] = prot.asc_getEmail;
	prot["asc_setEmail"] = prot.asc_setEmail;
	prot["asc_getInstructions"] = prot.asc_getInstructions;
	prot["asc_setInstructions"] = prot.asc_setInstructions;
	prot["asc_getShowDate"] = prot.asc_getShowDate;
	prot["asc_setShowDate"] = prot.asc_setShowDate;
	prot["asc_getValid"] = prot.asc_getValid;
	prot["asc_setValid"] = prot.asc_setValid;
	prot["asc_getDate"] = prot.asc_getDate;
	prot["asc_setDate"] = prot.asc_setDate;
	prot["asc_getVisible"] = prot.asc_getVisible;
	prot["asc_setVisible"] = prot.asc_setVisible;
	prot["asc_getRequested"] = prot.asc_getRequested;
	prot["asc_setRequested"] = prot.asc_setRequested;

	window["AscCommon"].asc_CAscEditorPermissions = asc_CAscEditorPermissions;
	prot = asc_CAscEditorPermissions.prototype;
	prot["asc_getLicenseType"] = prot.asc_getLicenseType;
	prot["asc_getCanCoAuthoring"] = prot.asc_getCanCoAuthoring;
	prot["asc_getCanReaderMode"] = prot.asc_getCanReaderMode;
	prot["asc_getCanBranding"] = prot.asc_getCanBranding;
	prot["asc_getCustomization"] = prot.asc_getCustomization;
	prot["asc_getIsAutosaveEnable"] = prot.asc_getIsAutosaveEnable;
	prot["asc_getAutosaveMinInterval"] = prot.asc_getAutosaveMinInterval;
	prot["asc_getIsAnalyticsEnable"] = prot.asc_getIsAnalyticsEnable;
	prot["asc_getIsLight"] = prot.asc_getIsLight;
	prot["asc_getLicenseMode"] = prot.asc_getLicenseMode;
	prot["asc_getRights"] = prot.asc_getRights;
	prot["asc_getBuildVersion"] = prot.asc_getBuildVersion;
	prot["asc_getBuildNumber"] = prot.asc_getBuildNumber;
	prot["asc_getLiveViewerSupport"] = prot.asc_getLiveViewerSupport;
	prot["asc_getIsBeta"] = prot.asc_getIsBeta;

	window["AscCommon"].asc_CAxNumFmt = asc_CAxNumFmt;
	prot = asc_CAxNumFmt.prototype;
	prot["getFormatCode"] = prot.getFormatCode;
	prot["putFormatCode"] = prot.putFormatCode;
	prot["getFormatCellsInfo"] = prot.getFormatCellsInfo;
	prot["getSourceLinked"] = prot.getSourceLinked;
	prot["putSourceLinked"] = prot.putSourceLinked;

	window["AscCommon"].asc_ValAxisSettings = asc_ValAxisSettings;
	prot = asc_ValAxisSettings.prototype;
	prot["putMinValRule"] = prot.putMinValRule;
	prot["putMinVal"] = prot.putMinVal;
	prot["putMaxValRule"] = prot.putMaxValRule;
	prot["putMaxVal"] = prot.putMaxVal;
	prot["putInvertValOrder"] = prot.putInvertValOrder;
	prot["putLogScale"] = prot.putLogScale;
	prot["putLogBase"] = prot.putLogBase;
	prot["putUnits"] = prot.putUnits;
	prot["putShowUnitsOnChart"] = prot.putShowUnitsOnChart;
	prot["putMajorTickMark"] = prot.putMajorTickMark;
	prot["putMinorTickMark"] = prot.putMinorTickMark;
	prot["putTickLabelsPos"] = prot.putTickLabelsPos;
	prot["putCrossesRule"] = prot.putCrossesRule;
	prot["putCrosses"] = prot.putCrosses;
	prot["putDispUnitsRule"] = prot.putDispUnitsRule;
	prot["getDispUnitsRule"] = prot.getDispUnitsRule;
	prot["putAxisType"] = prot.putAxisType;
	prot["getAxisType"] = prot.getAxisType;
	prot["getMinValRule"] = prot.getMinValRule;
	prot["getMinVal"] = prot.getMinVal;
	prot["getMaxValRule"] = prot.getMaxValRule;
	prot["getMaxVal"] = prot.getMaxVal;
	prot["getInvertValOrder"] = prot.getInvertValOrder;
	prot["getLogScale"] = prot.getLogScale;
	prot["getLogBase"] = prot.getLogBase;
	prot["getUnits"] = prot.getUnits;
	prot["getShowUnitsOnChart"] = prot.getShowUnitsOnChart;
	prot["getMajorTickMark"] = prot.getMajorTickMark;
	prot["getMinorTickMark"] = prot.getMinorTickMark;
	prot["getTickLabelsPos"] = prot.getTickLabelsPos;
	prot["getCrossesRule"] = prot.getCrossesRule;
	prot["getCrosses"] = prot.getCrosses;
	prot["setDefault"] = prot.setDefault;
	prot["getShow"] = prot.getShow;
	prot["putShow"] = prot.putShow;
	prot["putLabel"] = prot.putLabel;
	prot["getLabel"] = prot.getLabel;
	prot["putGridlines"] = prot.putGridlines;
	prot["getGridlines"] = prot.getGridlines;
	prot["putNumFmt"] = prot.putNumFmt;
	prot["getNumFmt"] = prot.getNumFmt;
	prot["isRadarAxis"] = prot.isRadarAxis;

	window["AscCommon"].asc_CatAxisSettings = asc_CatAxisSettings;
	prot = asc_CatAxisSettings.prototype;
	prot["putIntervalBetweenTick"] = prot.putIntervalBetweenTick;
	prot["putIntervalBetweenLabelsRule"] = prot.putIntervalBetweenLabelsRule;
	prot["putIntervalBetweenLabels"] = prot.putIntervalBetweenLabels;
	prot["putInvertCatOrder"] = prot.putInvertCatOrder;
	prot["putLabelsAxisDistance"] = prot.putLabelsAxisDistance;
	prot["putMajorTickMark"] = prot.putMajorTickMark;
	prot["putMinorTickMark"] = prot.putMinorTickMark;
	prot["putTickLabelsPos"] = prot.putTickLabelsPos;
	prot["putCrossesRule"] = prot.putCrossesRule;
	prot["putCrosses"] = prot.putCrosses;
	prot["putAxisType"] = prot.putAxisType;
	prot["putLabelsPosition"] = prot.putLabelsPosition;
	prot["putCrossMaxVal"] = prot.putCrossMaxVal;
	prot["putCrossMinVal"] = prot.putCrossMinVal;
	prot["getIntervalBetweenTick"] = prot.getIntervalBetweenTick;
	prot["getIntervalBetweenLabelsRule"] = prot.getIntervalBetweenLabelsRule;
	prot["getIntervalBetweenLabels"] = prot.getIntervalBetweenLabels;
	prot["getInvertCatOrder"] = prot.getInvertCatOrder;
	prot["getLabelsAxisDistance"] = prot.getLabelsAxisDistance;
	prot["getMajorTickMark"] = prot.getMajorTickMark;
	prot["getMinorTickMark"] = prot.getMinorTickMark;
	prot["getTickLabelsPos"] = prot.getTickLabelsPos;
	prot["getCrossesRule"] = prot.getCrossesRule;
	prot["getCrosses"] = prot.getCrosses;
	prot["getAxisType"] = prot.getAxisType;
	prot["getLabelsPosition"] = prot.getLabelsPosition;
	prot["getCrossMaxVal"] = prot.getCrossMaxVal;
	prot["getCrossMinVal"] = prot.getCrossMinVal;
	prot["setDefault"] = prot.setDefault;
	prot["getShow"] = prot.getShow;
	prot["putShow"] = prot.putShow;
	prot["getLabel"] = prot.getLabel;
	prot["putLabel"] = prot.putLabel;
	prot["putGridlines"] = prot.putGridlines;
	prot["getGridlines"] = prot.getGridlines;
	prot["putNumFmt"] = prot.putNumFmt;
	prot["getNumFmt"] = prot.getNumFmt;
	prot["getAuto"] = prot.getAuto;
	prot["putAuto"] = prot.putAuto;
	prot["isRadarAxis"] = prot.isRadarAxis;

	window["Asc"]["asc_ChartSettings"] = window["Asc"].asc_ChartSettings = asc_ChartSettings;
	prot = asc_ChartSettings.prototype;
	prot["putStyle"] = prot.putStyle;
	prot["putTitle"] = prot.putTitle;
	prot["putRowCols"] = prot.putRowCols;
	prot["putHorAxisLabel"] = prot.putHorAxisLabel;
	prot["putVertAxisLabel"] = prot.putVertAxisLabel;
	prot["putLegendPos"] = prot.putLegendPos;
	prot["putDataLabelsPos"] = prot.putDataLabelsPos;
	prot["putCatAx"] = prot.putCatAx;
	prot["putValAx"] = prot.putValAx;
	prot["getStyle"] = prot.getStyle;
	prot["getTitle"] = prot.getTitle;
	prot["getRowCols"] = prot.getRowCols;
	prot["getHorAxisLabel"] = prot.getHorAxisLabel;
	prot["getVertAxisLabel"] = prot.getVertAxisLabel;
	prot["getLegendPos"] = prot.getLegendPos;
	prot["getDataLabelsPos"] = prot.getDataLabelsPos;
	prot["getHorGridLines"] = prot.getHorGridLines;
	prot["putHorGridLines"] = prot.putHorGridLines;
	prot["getVertGridLines"] = prot.getVertGridLines;
	prot["putVertGridLines"] = prot.putVertGridLines;
	prot["getType"] = prot.getType;
	prot["putType"] = prot.putType;
	prot["putShowSerName"] = prot.putShowSerName;
	prot["getShowSerName"] = prot.getShowSerName;
	prot["putShowCatName"] = prot.putShowCatName;
	prot["getShowCatName"] = prot.getShowCatName;
	prot["putShowVal"] = prot.putShowVal;
	prot["getShowVal"] = prot.getShowVal;
	prot["putSeparator"] = prot.putSeparator;
	prot["getSeparator"] = prot.getSeparator;
	prot["putHorAxisProps"] = prot.putHorAxisProps;
	prot["getHorAxisProps"] = prot.getHorAxisProps;
	prot["putVertAxisProps"] = prot.putVertAxisProps;
	prot["getVertAxisProps"] = prot.getVertAxisProps;
	prot["putRange"] = prot.putRange;
	prot["getRange"] = prot.getRange;
	prot["putRanges"] = prot.putRanges;
	prot["getRanges"] = prot.getRanges;
	prot["putInColumns"] = prot.putInColumns;
	prot["getInColumns"] = prot.getInColumns;
	prot["getInRows"] = prot.getInRows;
	prot["putShowMarker"] = prot.putShowMarker;
	prot["getShowMarker"] = prot.getShowMarker;
	prot["putLine"] = prot.putLine;
	prot["getLine"] = prot.getLine;
	prot["putSmooth"] = prot.putSmooth;
	prot["getSmooth"] = prot.getSmooth;
	prot["changeType"] = prot.changeType;
	prot["putShowHorAxis"] = prot.putShowHorAxis;
	prot["getShowHorAxis"] = prot.getShowHorAxis;
	prot["putShowVerAxis"] = prot.putShowVerAxis;
	prot["getShowVerAxis"] = prot.getShowVerAxis;
	prot["getSeries"] = prot.getSeries;
	prot["getCatValues"] = prot.getCatValues;
	prot["switchRowCol"] = prot.switchRowCol;
	prot["addSeries"] = prot.addSeries;
	prot["addScatterSeries"] = prot.addScatterSeries;
	prot["getCatFormula"] = prot.getCatFormula;
	prot["setCatFormula"] = prot.setCatFormula;
	prot["isValidCatFormula"] = prot.isValidCatFormula;
	prot["setRange"] = prot.setRange;
	prot["isValidRange"] = prot.isValidRange;
	prot["startEdit"] = prot.startEdit;
	prot["endEdit"] = prot.endEdit;
	prot["cancelEdit"] = prot.cancelEdit;
	prot["startEditData"] = prot.startEditData;
	prot["cancelEditData"] = prot.cancelEditData;
	prot["endEditData"] = prot.endEditData;
	prot["getHorAxesProps"] = prot.getHorAxesProps;
	prot["getVertAxesProps"] = prot.getVertAxesProps;
	prot["getDepthAxesProps"] = prot.getDepthAxesProps;
	prot["getView3d"] = prot.getView3d;
	prot["putView3d"] = prot.putView3d;
	prot["setView3d"] = prot.setView3d;
	prot["getDisplayTrendlinesEquation"] = prot.getDisplayTrendlinesEquation;
	prot["putDisplayTrendlinesEquation"] = prot.putDisplayTrendlinesEquation;

	window["AscCommon"].asc_CRect = asc_CRect;
	prot = asc_CRect.prototype;
	prot["asc_getX"] = prot.asc_getX;
	prot["asc_getY"] = prot.asc_getY;
	prot["asc_getWidth"] = prot.asc_getWidth;
	prot["asc_getHeight"] = prot.asc_getHeight;

	window["AscCommon"].CColor = CColor;
	prot = CColor.prototype;
	prot["getR"] = prot.getR;
	prot["get_r"] = prot.get_r;
	prot["put_r"] = prot.put_r;
	prot["getG"] = prot.getG;
	prot["get_g"] = prot.get_g;
	prot["put_g"] = prot.put_g;
	prot["getB"] = prot.getB;
	prot["get_b"] = prot.get_b;
	prot["put_b"] = prot.put_b;
	prot["getA"] = prot.getA;
	prot["get_hex"] = prot.get_hex;

	window["Asc"]["asc_CColor"] = window["Asc"].asc_CColor = asc_CColor;
	prot = asc_CColor.prototype;
	prot["get_r"] = prot["asc_getR"] = prot.get_r = prot.asc_getR;
	prot["put_r"] = prot["asc_putR"] = prot.put_r = prot.asc_putR;
	prot["get_g"] = prot["asc_getG"] = prot.get_g = prot.asc_getG;
	prot["put_g"] = prot["asc_putG"] = prot.put_g = prot.asc_putG;
	prot["get_b"] = prot["asc_getB"] = prot.get_b = prot.asc_getB;
	prot["put_b"] = prot["asc_putB"] = prot.put_b = prot.asc_putB;
	prot["get_a"] = prot["asc_getA"] = prot.get_a = prot.asc_getA;
	prot["put_a"] = prot["asc_putA"] = prot.put_a = prot.asc_putA;
	prot["get_auto"] = prot["asc_getAuto"] = prot.get_auto = prot.asc_getAuto;
	prot["put_auto"] = prot["asc_putAuto"] = prot.put_auto = prot.asc_putAuto;
	prot["get_type"] = prot["asc_getType"] = prot.get_type = prot.asc_getType;
	prot["put_type"] = prot["asc_putType"] = prot.put_type = prot.asc_putType;
	prot["get_value"] = prot["asc_getValue"] = prot.get_value = prot.asc_getValue;
	prot["put_value"] = prot["asc_putValue"] = prot.put_value = prot.asc_putValue;
	prot["get_hex"] = prot["asc_getHex"] = prot.get_hex = prot.asc_getHex;
	prot["get_color"] = prot["asc_getColor"] = prot.get_color = prot.asc_getColor;
	prot["get_name"] = prot["asc_getName"] = prot.get_name = prot.asc_getName;
	prot["get_effectValue"] = prot["asc_getEffectValue"] = prot.get_effectValue = prot.asc_getEffectValue;
	prot["put_effectValue"] = prot["asc_putEffectValue"] = prot.put_effectValue = prot.asc_putEffectValue;
	prot["get_nameInColorScheme"] = prot["asc_getNameInColorScheme"] = prot.get_nameInColorScheme = prot.asc_getNameInColorScheme;


	window["Asc"]["asc_CTextBorder"] = window["Asc"].asc_CTextBorder = asc_CTextBorder;
	prot = asc_CTextBorder.prototype;
	prot["get_Color"] = prot["asc_getColor"] = prot.asc_getColor;
	prot["put_Color"] = prot["asc_putColor"] = prot.asc_putColor;
	prot["get_Size"] = prot["asc_getSize"] = prot.asc_getSize;
	prot["put_Size"] = prot["asc_putSize"] = prot.asc_putSize;
	prot["get_Value"] = prot["asc_getValue"] = prot.asc_getValue;
	prot["put_Value"] = prot["asc_putValue"] = prot.asc_putValue;
	prot["get_Space"] = prot["asc_getSpace"] = prot.asc_getSpace;
	prot["put_Space"] = prot["asc_putSpace"] = prot.asc_putSpace;
	prot["get_ForSelectedCells"] = prot["asc_getForSelectedCells"] = prot.asc_getForSelectedCells;
	prot["put_ForSelectedCells"] = prot["asc_putForSelectedCells"] = prot.asc_putForSelectedCells;

	window["Asc"]["asc_CParagraphBorders"] = window["Asc"].asc_CParagraphBorders = asc_CParagraphBorders;
	prot = asc_CParagraphBorders.prototype;
	prot["get_Left"] = prot["asc_getLeft"] = prot.asc_getLeft;
	prot["put_Left"] = prot["asc_putLeft"] = prot.asc_putLeft;
	prot["get_Top"] = prot["asc_getTop"] = prot.asc_getTop;
	prot["put_Top"] = prot["asc_putTop"] = prot.asc_putTop;
	prot["get_Right"] = prot["asc_getRight"] = prot.asc_getRight;
	prot["put_Right"] = prot["asc_putRight"] = prot.asc_putRight;
	prot["get_Bottom"] = prot["asc_getBottom"] = prot.asc_getBottom;
	prot["put_Bottom"] = prot["asc_putBottom"] = prot.asc_putBottom;
	prot["get_Between"] = prot["asc_getBetween"] = prot.asc_getBetween;
	prot["put_Between"] = prot["asc_putBetween"] = prot.asc_putBetween;

	window["AscCommon"].asc_CCustomListType = window["Asc"]["asc_CCustomListType"] = window["Asc"].asc_CCustomListType = asc_CCustomListType;
	prot = asc_CCustomListType.prototype;
	prot["setType"] = prot["asc_setType"] = prot.setType;
	prot["setImageId"] = prot["asc_setImageId"] = prot.setImageId;
	prot["setToken"] = prot["asc_setToken"] = prot.setToken;
	prot["setChar"] = prot["asc_setChar"] = prot.setChar;
	prot["setSpecialFont"] = prot["asc_setSpecialFont"] = prot.setSpecialFont;
	prot["setNumberingType"] = prot["asc_setNumberingType"] = prot.setNumberingType;
	prot["getType"] = prot["asc_getType"] = prot.getType;
	prot["getImageId"] = prot["asc_getImageId"] = prot.getImageId;
	prot["getToken"] = prot["asc_getToken"] = prot.getToken;
	prot["getChar"] = prot["asc_getChar"] = prot.getChar;
	prot["getSpecialFont"] = prot["asc_getSpecialFont"] = prot.getSpecialFont;
	prot["getNumberingType"] = prot["asc_getNumberingType"] = prot.getNumberingType;

	window["AscCommon"].asc_CListType = asc_CListType;
	prot = asc_CListType.prototype;
	prot["get_ListType"] = prot["asc_getListType"] = prot.asc_getListType;
	prot["get_ListSubType"] = prot["asc_getListSubType"] = prot.asc_getListSubType;
	prot["get_ListCustom"] = prot["asc_getListCustom"] = prot.asc_getListCustom;

	window["AscCommon"].asc_CTextFontFamily = asc_CTextFontFamily;
	window["AscCommon"]["asc_CTextFontFamily"] = asc_CTextFontFamily;
	prot = asc_CTextFontFamily.prototype;
	prot["get_Name"] = prot["asc_getName"] = prot.get_Name = prot.asc_getName;
	prot["get_Index"] = prot["asc_getIndex"] = prot.get_Index = prot.asc_getIndex;
	prot["put_Name"] = prot["asc_putName"] = prot.put_Name = prot.asc_putName;
	prot["put_Index"] = prot["asc_putIndex"] = prot.put_Index = prot.asc_putIndex;

	window["Asc"]["asc_CParagraphTab"] = window["Asc"].asc_CParagraphTab = asc_CParagraphTab;
	prot = asc_CParagraphTab.prototype;
	prot["get_Value"] = prot["asc_getValue"] = prot.asc_getValue;
	prot["put_Value"] = prot["asc_putValue"] = prot.asc_putValue;
	prot["get_Pos"] = prot["asc_getPos"] = prot.asc_getPos;
	prot["put_Pos"] = prot["asc_putPos"] = prot.asc_putPos;
	prot["get_Leader"] = prot["asc_getLeader"] = prot.asc_getLeader;
	prot["put_Leader"] = prot["asc_putLeader"] = prot.asc_putLeader;

	window["Asc"]["asc_CParagraphTabs"] = window["Asc"].asc_CParagraphTabs = asc_CParagraphTabs;
	prot = asc_CParagraphTabs.prototype;
	prot["get_Count"] = prot["asc_getCount"] = prot.asc_getCount;
	prot["get_Tab"] = prot["asc_getTab"] = prot.asc_getTab;
	prot["add_Tab"] = prot["asc_addTab"] = prot.asc_addTab;
	prot["clear"] = prot.clear = prot["asc_clear"] = prot.asc_clear;

	window["Asc"]["asc_CParagraphShd"] = window["Asc"].asc_CParagraphShd = asc_CParagraphShd;
	prot = asc_CParagraphShd.prototype;
	prot["get_Value"] = prot["asc_getValue"] = prot.asc_getValue;
	prot["put_Value"] = prot["asc_putValue"] = prot.asc_putValue;
	prot["get_Color"] = prot["asc_getColor"] = prot.asc_getColor;
	prot["put_Color"] = prot["asc_putColor"] = prot.asc_putColor;

	window["Asc"]["asc_CParagraphFrame"] = window["Asc"].asc_CParagraphFrame = asc_CParagraphFrame;
	prot = asc_CParagraphFrame.prototype;
	prot["asc_getDropCap"] = prot["get_DropCap"] = prot.asc_getDropCap;
	prot["asc_putDropCap"] = prot["put_DropCap"] = prot.asc_putDropCap;
	prot["asc_getH"] = prot["get_H"] = prot.asc_getH;
	prot["asc_putH"] = prot["put_H"] = prot.asc_putH;
	prot["asc_getHAnchor"] = prot["get_HAnchor"] = prot.asc_getHAnchor;
	prot["asc_putHAnchor"] = prot["put_HAnchor"] = prot.asc_putHAnchor;
	prot["asc_getHRule"] = prot["get_HRule"] = prot.asc_getHRule;
	prot["asc_putHRule"] = prot["put_HRule"] = prot.asc_putHRule;
	prot["asc_getHSpace"] = prot["get_HSpace"] = prot.asc_getHSpace;
	prot["asc_putHSpace"] = prot["put_HSpace"] = prot.asc_putHSpace;
	prot["asc_getLines"] = prot["get_Lines"] = prot.asc_getLines;
	prot["asc_putLines"] = prot["put_Lines"] = prot.asc_putLines;
	prot["asc_getVAnchor"] = prot["get_VAnchor"] = prot.asc_getVAnchor;
	prot["asc_putVAnchor"] = prot["put_VAnchor"] = prot.asc_putVAnchor;
	prot["asc_getVSpace"] = prot["get_VSpace"] = prot.asc_getVSpace;
	prot["asc_putVSpace"] = prot["put_VSpace"] = prot.asc_putVSpace;
	prot["asc_getW"] = prot["get_W"] = prot.asc_getW;
	prot["asc_putW"] = prot["put_W"] = prot.asc_putW;
	prot["asc_getWrap"] = prot["get_Wrap"] = prot.asc_getWrap;
	prot["asc_putWrap"] = prot["put_Wrap"] = prot.asc_putWrap;
	prot["asc_getX"] = prot["get_X"] = prot.asc_getX;
	prot["asc_putX"] = prot["put_X"] = prot.asc_putX;
	prot["asc_getXAlign"] = prot["get_XAlign"] = prot.asc_getXAlign;
	prot["asc_putXAlign"] = prot["put_XAlign"] = prot.asc_putXAlign;
	prot["asc_getY"] = prot["get_Y"] = prot.asc_getY;
	prot["asc_putY"] = prot["put_Y"] = prot.asc_putY;
	prot["asc_getYAlign"] = prot["get_YAlign"] = prot.asc_getYAlign;
	prot["asc_putYAlign"] = prot["put_YAlign"] = prot.asc_putYAlign;
	prot["asc_getBorders"] = prot["get_Borders"] = prot.asc_getBorders;
	prot["asc_putBorders"] = prot["put_Borders"] = prot.asc_putBorders;
	prot["asc_getShade"] = prot["get_Shade"] = prot.asc_getShade;
	prot["asc_putShade"] = prot["put_Shade"] = prot.asc_putShade;
	prot["asc_getFontFamily"] = prot["get_FontFamily"] = prot.asc_getFontFamily;
	prot["asc_putFontFamily"] = prot["put_FontFamily"] = prot.asc_putFontFamily;
	prot["asc_putFromDropCapMenu"] = prot["put_FromDropCapMenu"] = prot.asc_putFromDropCapMenu;

	window["AscCommon"].asc_CParagraphSpacing = asc_CParagraphSpacing;
	prot = asc_CParagraphSpacing.prototype;
	prot["get_Line"] = prot["asc_getLine"] = prot.asc_getLine;
	prot["put_Line"] = prot["asc_putLine"] = prot.asc_putLine;
	prot["get_LineRule"] = prot["asc_getLineRule"] = prot.asc_getLineRule;
	prot["put_LineRule"] = prot["asc_putLineRule"] = prot.asc_putLineRule;
	prot["get_Before"] = prot["asc_getBefore"] = prot.asc_getBefore;
	prot["put_Before"] = prot["asc_putBefore"] = prot.asc_putBefore;
	prot["get_After"] = prot["asc_getAfter"] = prot.asc_getAfter;
	prot["put_After"] = prot["asc_putAfter"] = prot.asc_putAfter;

	window["Asc"]["asc_CParagraphInd"] = window["Asc"].asc_CParagraphInd = asc_CParagraphInd;
	prot = asc_CParagraphInd.prototype;
	prot["get_Left"] = prot["asc_getLeft"] = prot.asc_getLeft;
	prot["put_Left"] = prot["asc_putLeft"] = prot.asc_putLeft;
	prot["get_Right"] = prot["asc_getRight"] = prot.asc_getRight;
	prot["put_Right"] = prot["asc_putRight"] = prot.asc_putRight;
	prot["get_FirstLine"] = prot["asc_getFirstLine"] = prot.asc_getFirstLine;
	prot["put_FirstLine"] = prot["asc_putFirstLine"] = prot.asc_putFirstLine;

	window["Asc"]["asc_CParagraphProperty"] = window["Asc"].asc_CParagraphProperty = asc_CParagraphProperty;
	prot = asc_CParagraphProperty.prototype;
	prot["get_RtlDirection"] = prot["asc_getRtlDirection"] = prot.asc_getRtlDirection;
	prot["put_RtlDirection"] = prot["asc_putRtlDirection"] = prot.asc_putRtlDirection;
	prot["get_ContextualSpacing"] = prot["asc_getContextualSpacing"] = prot.asc_getContextualSpacing;
	prot["put_ContextualSpacing"] = prot["asc_putContextualSpacing"] = prot.asc_putContextualSpacing;
	prot["get_Ind"] = prot["asc_getInd"] = prot.asc_getInd;
	prot["put_Ind"] = prot["asc_putInd"] = prot.asc_putInd;
	prot["get_Jc"] = prot["asc_getJc"] = prot.asc_getJc;
	prot["put_Jc"] = prot["asc_putJc"] = prot.asc_putJc;
	prot["get_KeepLines"] = prot["asc_getKeepLines"] = prot.asc_getKeepLines;
	prot["put_KeepLines"] = prot["asc_putKeepLines"] = prot.asc_putKeepLines;
	prot["get_KeepNext"] = prot["asc_getKeepNext"] = prot.asc_getKeepNext;
	prot["put_KeepNext"] = prot["asc_putKeepNext"] = prot.asc_putKeepNext;
	prot["get_PageBreakBefore"] = prot["asc_getPageBreakBefore"] = prot.asc_getPageBreakBefore;
	prot["put_PageBreakBefore"] = prot["asc_putPageBreakBefore"] = prot.asc_putPageBreakBefore;
	prot["get_WidowControl"] = prot["asc_getWidowControl"] = prot.asc_getWidowControl;
	prot["put_WidowControl"] = prot["asc_putWidowControl"] = prot.asc_putWidowControl;
	prot["get_Spacing"] = prot["asc_getSpacing"] = prot.asc_getSpacing;
	prot["put_Spacing"] = prot["asc_putSpacing"] = prot.asc_putSpacing;
	prot["get_Borders"] = prot["asc_getBorders"] = prot.asc_getBorders;
	prot["put_Borders"] = prot["asc_putBorders"] = prot.asc_putBorders;
	prot["get_Shade"] = prot["asc_getShade"] = prot.asc_getShade;
	prot["put_Shade"] = prot["asc_putShade"] = prot.asc_putShade;
	prot["get_Locked"] = prot["asc_getLocked"] = prot.asc_getLocked;
	prot["get_CanAddTable"] = prot["asc_getCanAddTable"] = prot.asc_getCanAddTable;
	prot["get_Subscript"] = prot["asc_getSubscript"] = prot.asc_getSubscript;
	prot["put_Subscript"] = prot["asc_putSubscript"] = prot.asc_putSubscript;
	prot["get_Superscript"] = prot["asc_getSuperscript"] = prot.asc_getSuperscript;
	prot["put_Superscript"] = prot["asc_putSuperscript"] = prot.asc_putSuperscript;
	prot["get_SmallCaps"] = prot["asc_getSmallCaps"] = prot.asc_getSmallCaps;
	prot["put_SmallCaps"] = prot["asc_putSmallCaps"] = prot.asc_putSmallCaps;
	prot["get_AllCaps"] = prot["asc_getAllCaps"] = prot.asc_getAllCaps;
	prot["put_AllCaps"] = prot["asc_putAllCaps"] = prot.asc_putAllCaps;
	prot["get_Strikeout"] = prot["asc_getStrikeout"] = prot.asc_getStrikeout;
	prot["put_Strikeout"] = prot["asc_putStrikeout"] = prot.asc_putStrikeout;
	prot["get_DStrikeout"] = prot["asc_getDStrikeout"] = prot.asc_getDStrikeout;
	prot["put_DStrikeout"] = prot["asc_putDStrikeout"] = prot.asc_putDStrikeout;
	prot["get_TextSpacing"] = prot["asc_getTextSpacing"] = prot.asc_getTextSpacing;
	prot["put_TextSpacing"] = prot["asc_putTextSpacing"] = prot.asc_putTextSpacing;
	prot["get_Position"] = prot["asc_getPosition"] = prot.asc_getPosition;
	prot["put_Position"] = prot["asc_putPosition"] = prot.asc_putPosition;
	prot["get_Tabs"] = prot["asc_getTabs"] = prot.asc_getTabs;
	prot["put_Tabs"] = prot["asc_putTabs"] = prot.asc_putTabs;
	prot["get_DefaultTab"] = prot["asc_getDefaultTab"] = prot.asc_getDefaultTab;
	prot["put_DefaultTab"] = prot["asc_putDefaultTab"] = prot.asc_putDefaultTab;
	prot["get_FramePr"] = prot["asc_getFramePr"] = prot.asc_getFramePr;
	prot["put_FramePr"] = prot["asc_putFramePr"] = prot.asc_putFramePr;
	prot["get_CanAddDropCap"] = prot["asc_getCanAddDropCap"] = prot.asc_getCanAddDropCap;
	prot["get_CanAddImage"] = prot["asc_getCanAddImage"] = prot.asc_getCanAddImage;
	prot["get_OutlineLvl"] = prot["asc_getOutlineLvl"] = prot.asc_getOutlineLvl;
	prot["put_OutlineLvl"] = prot["asc_putOutLineLvl"] = prot.asc_putOutLineLvl;
	prot["get_OutlineLvlStyle"] = prot["asc_getOutlineLvlStyle"] = prot.asc_getOutlineLvlStyle;
	prot["get_SuppressLineNumbers"] = prot["asc_getSuppressLineNumbers"] = prot.asc_getSuppressLineNumbers;
	prot["put_SuppressLineNumbers"] = prot["asc_putSuppressLineNumbers"] = prot.asc_putSuppressLineNumbers;
	prot["put_Bullet"] = prot["asc_putBullet"] = prot.asc_putBullet;
	prot["get_Bullet"] = prot["asc_getBullet"] = prot.asc_getBullet;
	prot["put_BulletSize"] = prot["asc_putBulletSize"] = prot.asc_putBulletSize;
	prot["get_BulletSize"] = prot["asc_getBulletSize"] = prot.asc_getBulletSize;
	prot["put_BulletColor"] = prot["asc_putBulletColor"] = prot.asc_putBulletColor;
	prot["get_BulletColor"] = prot["asc_getBulletColor"] = prot.asc_getBulletColor;
	prot["put_NumStartAt"] = prot["asc_putNumStartAt"] = prot.asc_putNumStartAt;
	prot["get_NumStartAt"] = prot["asc_getNumStartAt"] = prot.asc_getNumStartAt;
	prot["get_BulletFont"] = prot["asc_getBulletFont"] = prot.asc_getBulletFont;
	prot["put_BulletFont"] = prot["asc_putBulletFont"] = prot.asc_putBulletFont;
	prot["get_BulletSymbol"] = prot["asc_getBulletSymbol"] = prot.asc_getBulletSymbol;
	prot["put_BulletSymbol"] = prot["asc_putBulletSymbol"] = prot.asc_putBulletSymbol;
	prot["can_DeleteBlockContentControl"] = prot["asc_canDeleteBlockContentControl"] = prot.asc_canDeleteBlockContentControl;
	prot["can_EditBlockContentControl"] = prot["asc_canEditBlockContentControl"] = prot.asc_canEditBlockContentControl;
	prot["can_DeleteInlineContentControl"] = prot["asc_canDeleteInlineContentControl"] = prot.asc_canDeleteInlineContentControl;
	prot["can_EditInlineContentControl"] = prot["asc_canEditInlineContentControl"] = prot.asc_canEditInlineContentControl;
	prot["get_Ligatures"] = prot["asc_getLigatures"] = prot.asc_getLigatures;
	prot["put_Ligatures"] = prot["asc_putLigatures"] = prot.asc_putLigatures;

	window["AscCommon"].asc_CTexture = asc_CTexture;
	prot = asc_CTexture.prototype;
	prot["get_id"] = prot["asc_getId"] = prot.asc_getId;
	prot["get_image"] = prot["asc_getImage"] = prot.asc_getImage;

	window["AscCommon"].asc_CImageSize = asc_CImageSize;
	prot = asc_CImageSize.prototype;
	prot["get_ImageWidth"] = prot["asc_getImageWidth"] = prot.asc_getImageWidth;
	prot["get_ImageHeight"] = prot["asc_getImageHeight"] = prot.asc_getImageHeight;
	prot["get_IsCorrect"] = prot["asc_getIsCorrect"] = prot.asc_getIsCorrect;

	window["Asc"]["asc_CPaddings"] = window["Asc"].asc_CPaddings = asc_CPaddings;
	prot = asc_CPaddings.prototype;
	prot["get_Left"] = prot["asc_getLeft"] = prot.asc_getLeft;
	prot["put_Left"] = prot["asc_putLeft"] = prot.asc_putLeft;
	prot["get_Top"] = prot["asc_getTop"] = prot.asc_getTop;
	prot["put_Top"] = prot["asc_putTop"] = prot.asc_putTop;
	prot["get_Bottom"] = prot["asc_getBottom"] = prot.asc_getBottom;
	prot["put_Bottom"] = prot["asc_putBottom"] = prot.asc_putBottom;
	prot["get_Right"] = prot["asc_getRight"] = prot.asc_getRight;
	prot["put_Right"] = prot["asc_putRight"] = prot.asc_putRight;

	window["Asc"]["asc_CShapeProperty"] = window["Asc"].asc_CShapeProperty = asc_CShapeProperty;
	prot = asc_CShapeProperty.prototype;
	prot["get_type"] = prot["asc_getType"] = prot.asc_getType;
	prot["put_type"] = prot["asc_putType"] = prot.asc_putType;
	prot["get_fill"] = prot["asc_getFill"] = prot.asc_getFill;
	prot["put_fill"] = prot["asc_putFill"] = prot.asc_putFill;
	prot["get_stroke"] = prot["asc_getStroke"] = prot.asc_getStroke;
	prot["put_stroke"] = prot["asc_putStroke"] = prot.asc_putStroke;
	prot["get_paddings"] = prot["asc_getPaddings"] = prot.asc_getPaddings;
	prot["put_paddings"] = prot["asc_putPaddings"] = prot.asc_putPaddings;
	prot["get_CanFill"] = prot["asc_getCanFill"] = prot.asc_getCanFill;
	prot["put_CanFill"] = prot["asc_putCanFill"] = prot.asc_putCanFill;
	prot["get_CanChangeArrows"] = prot["asc_getCanChangeArrows"] = prot.asc_getCanChangeArrows;
	prot["set_CanChangeArrows"] = prot["asc_setCanChangeArrows"] = prot.asc_setCanChangeArrows;
	prot["get_FromChart"] = prot["asc_getFromChart"] = prot.asc_getFromChart;
	prot["set_FromChart"] = prot["asc_setFromChart"] = prot.asc_setFromChart;
	prot["set_FromSmartArt"] = prot["asc_setFromSmartArt"] = prot.asc_setFromSmartArt;
	prot["get_FromSmartArt"] = prot["asc_getFromSmartArt"] = prot.asc_getFromSmartArt;
	prot["set_FromSmartArtInternal"] = prot["asc_setFromSmartArtInternal"] = prot.asc_setFromSmartArtInternal;
	prot["get_FromSmartArtInternal"] = prot["asc_getFromSmartArtInternal"] = prot.asc_getFromSmartArtInternal;
	prot["get_FromGroup"] = prot["asc_getFromGroup"] = prot.asc_getFromGroup;
	prot["set_FromGroup"] = prot["asc_setFromGroup"] = prot.asc_setFromGroup;
	prot["get_Locked"] = prot["asc_getLocked"] = prot.asc_getLocked;
	prot["set_Locked"] = prot["asc_setLocked"] = prot.asc_setLocked;
	prot["get_Width"] = prot["asc_getWidth"] = prot.asc_getWidth;
	prot["put_Width"] = prot["asc_putWidth"] = prot.asc_putWidth;
	prot["get_Height"] = prot["asc_getHeight"] = prot.asc_getHeight;
	prot["put_Height"] = prot["asc_putHeight"] = prot.asc_putHeight;
	prot["get_VerticalTextAlign"] = prot["asc_getVerticalTextAlign"] = prot.asc_getVerticalTextAlign;
	prot["put_VerticalTextAlign"] = prot["asc_putVerticalTextAlign"] = prot.asc_putVerticalTextAlign;
	prot["get_Vert"] = prot["asc_getVert"] = prot.asc_getVert;
	prot["put_Vert"] = prot["asc_putVert"] = prot.asc_putVert;
	prot["get_TextArtProperties"] = prot["asc_getTextArtProperties"] = prot.asc_getTextArtProperties;
	prot["put_TextArtProperties"] = prot["asc_putTextArtProperties"] = prot.asc_putTextArtProperties;
	prot["get_LockAspect"] = prot["asc_getLockAspect"] = prot.asc_getLockAspect;
	prot["put_LockAspect"] = prot["asc_putLockAspect"] = prot.asc_putLockAspect;
	prot["get_Title"] = prot["asc_getTitle"] = prot.asc_getTitle;
	prot["put_Title"] = prot["asc_putTitle"] = prot.asc_putTitle;
	prot["get_Description"] = prot["asc_getDescription"] = prot.asc_getDescription;
	prot["put_Description"] = prot["asc_putDescription"] = prot.asc_putDescription;
	prot["get_Name"] = prot["asc_getName"] = prot.asc_getName;
	prot["put_Name"] = prot["asc_putName"] = prot.asc_putName;
	prot["get_ColumnNumber"] = prot["asc_getColumnNumber"] = prot.asc_getColumnNumber;
	prot["put_ColumnNumber"] = prot["asc_putColumnNumber"] = prot.asc_putColumnNumber;
	prot["get_ColumnSpace"] = prot["asc_getColumnSpace"] = prot.asc_getColumnSpace;
	prot["get_TextFitType"] = prot["asc_getTextFitType"] = prot.asc_getTextFitType;
	prot["get_VertOverflowType"] = prot["asc_getVertOverflowType"] = prot.asc_getVertOverflowType;
	prot["put_ColumnSpace"] = prot["asc_putColumnSpace"] = prot.asc_putColumnSpace;
	prot["put_TextFitType"] = prot["asc_putTextFitType"] = prot.asc_putTextFitType;
	prot["put_VertOverflowType"] = prot["asc_putVertOverflowType"] = prot.asc_putVertOverflowType;
	prot["get_SignatureId"] = prot["asc_getSignatureId"] = prot.asc_getSignatureId;
	prot["put_SignatureId"] = prot["asc_putSignatureId"] = prot.asc_putSignatureId;
	prot["get_FromImage"] = prot["asc_getFromImage"] = prot.asc_getFromImage;
	prot["put_FromImage"] = prot["asc_putFromImage"] = prot.asc_putFromImage;
	prot["get_Rot"] = prot["asc_getRot"] = prot.asc_getRot;
	prot["put_Rot"] = prot["asc_putRot"] = prot.asc_putRot;
	prot["get_RotAdd"] = prot["asc_getRotAdd"] = prot.asc_getRotAdd;
	prot["put_RotAdd"] = prot["asc_putRotAdd"] = prot.asc_putRotAdd;
	prot["get_FlipH"] = prot["asc_getFlipH"] = prot.asc_getFlipH;
	prot["put_FlipH"] = prot["asc_putFlipH"] = prot.asc_putFlipH;
	prot["get_FlipV"] = prot["asc_getFlipV"] = prot.asc_getFlipV;
	prot["put_FlipV"] = prot["asc_putFlipV"] = prot.asc_putFlipV;
	prot["get_FlipHInvert"] = prot["asc_getFlipHInvert"] = prot.asc_getFlipHInvert;
	prot["put_FlipHInvert"] = prot["asc_putFlipHInvert"] = prot.asc_putFlipHInvert;
	prot["get_FlipVInvert"] = prot["asc_getFlipVInvert"] = prot.asc_getFlipVInvert;
	prot["put_FlipVInvert"] = prot["asc_putFlipVInvert"] = prot.asc_putFlipVInvert;
	prot["put_Shadow"] = prot.put_Shadow = prot["put_shadow"] = prot.put_shadow = prot["asc_putShadow"] = prot.asc_putShadow;
	prot["get_Shadow"] = prot.get_Shadow = prot["get_shadow"] = prot.get_shadow = prot["asc_getShadow"] = prot.asc_getShadow;
	prot["put_Anchor"] = prot.put_Anchor = prot["asc_putAnchor"] = prot.asc_putAnchor;
	prot["get_Anchor"] = prot.get_Anchor = prot["asc_getAnchor"] = prot.asc_getAnchor;
	prot["get_ProtectionLockText"] = prot["asc_getProtectionLockText"] = prot.asc_getProtectionLockText;
	prot["put_ProtectionLockText"] = prot["asc_putProtectionLockText"] = prot.asc_putProtectionLockText;
	prot["get_ProtectionLocked"] = prot["asc_getProtectionLocked"] = prot.asc_getProtectionLocked;
	prot["put_ProtectionLocked"] = prot["asc_putProtectionLocked"] = prot.asc_putProtectionLocked;
	prot["get_ProtectionPrint"] = prot["asc_getProtectionPrint"] = prot.asc_getProtectionPrint;
	prot["put_ProtectionPrint"] = prot["asc_putProtectionPrint"] = prot.asc_putProtectionPrint;
	prot["get_Position"] = prot["asc_getPosition"] = prot.asc_getPosition;
	prot["put_Position"] = prot["asc_putPosition"] = prot.asc_putPosition;
	prot["get_IsMotionPath"] = prot["asc_getIsMotionPath"] = prot.asc_getIsMotionPath;
	prot["asc_getCanEditText"]		= prot.asc_getCanEditText;
	prot["asc_setCanEditText"]		= prot.asc_setCanEditText;

	window["Asc"]["asc_CAnnotProperty"] = window["Asc"].asc_CAnnotProperty = asc_CAnnotProperty;
	prot = asc_CAnnotProperty.prototype;
	prot["asc_getType"]				= prot.asc_getType;
	prot["asc_putType"]				= prot.asc_putType;
	prot["asc_getFill"]				= prot.asc_getFill;
	prot["asc_putFill"]				= prot.asc_putFill;
	prot["asc_getStroke"]			= prot.asc_getStroke;
	prot["asc_putStroke"]			= prot.asc_putStroke;
	prot["asc_getCanFill"]			= prot.asc_getCanFill;
	prot["asc_putCanFill"]			= prot.asc_putCanFill;
	prot["asc_getCanChangeArrows"]	= prot.asc_getCanChangeArrows;
	prot["asc_setCanChangeArrows"]	= prot.asc_setCanChangeArrows;
	prot["asc_getSubject"]			= prot.asc_getSubject;
	prot["asc_setSubject"]			= prot.asc_setSubject;
	prot["asc_getCanEditText"]		= prot.asc_getCanEditText;
	prot["asc_setCanEditText"]		= prot.asc_setCanEditText;

	window["Asc"]["asc_CPdfPageProperty"] = window["Asc"].asc_CPdfPageProperty = asc_CPdfPageProperty;
	prot = asc_CPdfPageProperty.prototype;
	prot["asc_getDeleteLock"]	= prot.asc_getDeleteLock;
	prot["asc_putDeleteLock"]	= prot.asc_putDeleteLock;
	prot["asc_getRotateLock"]	= prot.asc_getRotateLock;
	prot["asc_putRotateLock"]	= prot.asc_putRotateLock;
	prot["asc_getEditLock"]		= prot.asc_getEditLock;
	prot["asc_putEditLock"]		= prot.asc_putEditLock;

	window["Asc"]["asc_TextArtProperties"] = window["Asc"].asc_TextArtProperties = asc_TextArtProperties;
	prot = asc_TextArtProperties.prototype;
	prot["asc_putFill"] = prot.asc_putFill;
	prot["asc_getFill"] = prot.asc_getFill;
	prot["asc_putLine"] = prot.asc_putLine;
	prot["asc_getLine"] = prot.asc_getLine;
	prot["asc_putForm"] = prot.asc_putForm;
	prot["asc_getForm"] = prot.asc_getForm;
	prot["asc_putStyle"] = prot.asc_putStyle;
	prot["asc_getStyle"] = prot.asc_getStyle;

	window['Asc']['CImagePositionH'] = window["Asc"].CImagePositionH = CImagePositionH;
	prot = CImagePositionH.prototype;
	prot['get_RelativeFrom'] = prot.get_RelativeFrom;
	prot['put_RelativeFrom'] = prot.put_RelativeFrom;
	prot['get_UseAlign'] = prot.get_UseAlign;
	prot['put_UseAlign'] = prot.put_UseAlign;
	prot['get_Align'] = prot.get_Align;
	prot['put_Align'] = prot.put_Align;
	prot['get_Value'] = prot.get_Value;
	prot['put_Value'] = prot.put_Value;
	prot['get_Percent'] = prot.get_Percent;
	prot['put_Percent'] = prot.put_Percent;

	window['Asc']['CImagePositionV'] = window["Asc"].CImagePositionV = CImagePositionV;
	prot = CImagePositionV.prototype;
	prot['get_RelativeFrom'] = prot.get_RelativeFrom;
	prot['put_RelativeFrom'] = prot.put_RelativeFrom;
	prot['get_UseAlign'] = prot.get_UseAlign;
	prot['put_UseAlign'] = prot.put_UseAlign;
	prot['get_Align'] = prot.get_Align;
	prot['put_Align'] = prot.put_Align;
	prot['get_Value'] = prot.get_Value;
	prot['put_Value'] = prot.put_Value;
	prot['get_Percent'] = prot.get_Percent;
	prot['put_Percent'] = prot.put_Percent;

	window['Asc']['CPosition'] = window["Asc"].CPosition = CPosition;
	prot = CPosition.prototype;
	prot['get_X'] = prot.get_X;
	prot['put_X'] = prot.put_X;
	prot['get_Y'] = prot.get_Y;
	prot['put_Y'] = prot.put_Y;

	window["Asc"]["asc_CImgProperty"] = window["Asc"].asc_CImgProperty = asc_CImgProperty;
	prot = asc_CImgProperty.prototype;
	prot["get_ChangeLevel"] = prot["asc_getChangeLevel"] = prot.asc_getChangeLevel;
	prot["put_ChangeLevel"] = prot["asc_putChangeLevel"] = prot.asc_putChangeLevel;
	prot["get_CanBeFlow"] = prot["asc_getCanBeFlow"] = prot.asc_getCanBeFlow;
	prot["get_Width"] = prot["asc_getWidth"] = prot.asc_getWidth;
	prot["put_Width"] = prot["asc_putWidth"] = prot.asc_putWidth;
	prot["get_Height"] = prot["asc_getHeight"] = prot.asc_getHeight;
	prot["put_Height"] = prot["asc_putHeight"] = prot.asc_putHeight;
	prot["get_WrappingStyle"] = prot["asc_getWrappingStyle"] = prot.asc_getWrappingStyle;
	prot["put_WrappingStyle"] = prot["asc_putWrappingStyle"] = prot.asc_putWrappingStyle;
	prot["get_Paddings"] = prot["asc_getPaddings"] = prot.asc_getPaddings;
	prot["put_Paddings"] = prot["asc_putPaddings"] = prot.asc_putPaddings;
	prot["get_AllowOverlap"] = prot["asc_getAllowOverlap"] = prot.asc_getAllowOverlap;
	prot["put_AllowOverlap"] = prot["asc_putAllowOverlap"] = prot.asc_putAllowOverlap;
	prot["get_Position"] = prot["asc_getPosition"] = prot.asc_getPosition;
	prot["put_Position"] = prot["asc_putPosition"] = prot.asc_putPosition;
	prot["get_PositionH"] = prot["asc_getPositionH"] = prot.asc_getPositionH;
	prot["put_PositionH"] = prot["asc_putPositionH"] = prot.asc_putPositionH;
	prot["get_PositionV"] = prot["asc_getPositionV"] = prot.asc_getPositionV;
	prot["put_PositionV"] = prot["asc_putPositionV"] = prot.asc_putPositionV;
	prot["get_SizeRelH"] = prot["asc_getSizeRelH"] = prot.asc_getSizeRelH;
	prot["put_SizeRelH"] = prot["asc_putSizeRelH"] = prot.asc_putSizeRelH;
	prot["get_SizeRelV"] = prot["asc_getSizeRelV"] = prot.asc_getSizeRelV;
	prot["put_SizeRelV"] = prot["asc_putSizeRelV"] = prot.asc_putSizeRelV;
	prot["get_Value_X"] = prot["asc_getValue_X"] = prot.asc_getValue_X;
	prot["get_Value_Y"] = prot["asc_getValue_Y"] = prot.asc_getValue_Y;
	prot["get_ImageUrl"] = prot["asc_getImageUrl"] = prot.asc_getImageUrl;
	prot["put_ImageUrl"] = prot["asc_putImageUrl"] = prot.asc_putImageUrl;
	prot["get_Group"] = prot["asc_getGroup"] = prot.asc_getGroup;
	prot["put_Group"] = prot["asc_putGroup"] = prot.asc_putGroup;
	prot["get_FromGroup"] = prot["asc_getFromGroup"] = prot.asc_getFromGroup;
	prot["put_FromGroup"] = prot["asc_putFromGroup"] = prot.asc_putFromGroup;
	prot["get_isChartProps"] = prot["asc_getisChartProps"] = prot.asc_getisChartProps;
	prot["put_isChartPross"] = prot["asc_putisChartPross"] = prot.asc_putisChartPross;
	prot["get_SeveralCharts"] = prot["asc_getSeveralCharts"] = prot.asc_getSeveralCharts;
	prot["put_SeveralCharts"] = prot["asc_putSeveralCharts"] = prot.asc_putSeveralCharts;
	prot["get_SeveralChartTypes"] = prot["asc_getSeveralChartTypes"] = prot.asc_getSeveralChartTypes;
	prot["put_SeveralChartTypes"] = prot["asc_putSeveralChartTypes"] = prot.asc_putSeveralChartTypes;
	prot["get_SeveralChartStyles"] = prot["asc_getSeveralChartStyles"] = prot.asc_getSeveralChartStyles;
	prot["put_SeveralChartStyles"] = prot["asc_putSeveralChartStyles"] = prot.asc_putSeveralChartStyles;
	prot["get_VerticalTextAlign"] = prot["asc_getVerticalTextAlign"] = prot.asc_getVerticalTextAlign;
	prot["put_VerticalTextAlign"] = prot["asc_putVerticalTextAlign"] = prot.asc_putVerticalTextAlign;
	prot["get_Vert"] = prot["asc_getVert"] = prot.asc_getVert;
	prot["put_Vert"] = prot["asc_putVert"] = prot.asc_putVert;
	prot["get_Locked"] = prot["asc_getLocked"] = prot.asc_getLocked;
	prot["getLockAspect"] = prot["asc_getLockAspect"] = prot.asc_getLockAspect;
	prot["putLockAspect"] = prot["asc_putLockAspect"] = prot.asc_putLockAspect;
	prot["get_ChartProperties"] = prot["asc_getChartProperties"] = prot.asc_getChartProperties;
	prot["put_ChartProperties"] = prot["asc_putChartProperties"] = prot.asc_putChartProperties;
	prot["get_ShapeProperties"] = prot["asc_getShapeProperties"] = prot.asc_getShapeProperties;
	prot["put_ShapeProperties"] = prot["asc_putShapeProperties"] = prot.asc_putShapeProperties;
	prot["put_SlicerProperties"] = prot["asc_putSlicerProperties"] = prot.asc_putSlicerProperties;
	prot["get_SlicerProperties"] = prot["asc_getSlicerProperties"] = prot.asc_getSlicerProperties;
	prot["get_OriginSize"] = prot["asc_getOriginSize"] = prot.asc_getOriginSize;
	prot["get_PluginGuid"] = prot["asc_getPluginGuid"] = prot.asc_getPluginGuid;
	prot["put_PluginGuid"] = prot["asc_putPluginGuid"] = prot.asc_putPluginGuid;
	prot["get_PluginData"] = prot["asc_getPluginData"] = prot.asc_getPluginData;
	prot["put_PluginData"] = prot["asc_putPluginData"] = prot.asc_putPluginData;
	prot["get_Rot"] = prot["asc_getRot"] = prot.asc_getRot;
	prot["put_Rot"] = prot["asc_putRot"] = prot.asc_putRot;
	prot["get_RotAdd"] = prot["asc_getRotAdd"] = prot.asc_getRotAdd;
	prot["put_RotAdd"] = prot["asc_putRotAdd"] = prot.asc_putRotAdd;
	prot["get_FlipH"] = prot["asc_getFlipH"] = prot.asc_getFlipH;
	prot["put_FlipH"] = prot["asc_putFlipH"] = prot.asc_putFlipH;
	prot["get_FlipV"] = prot["asc_getFlipV"] = prot.asc_getFlipV;
	prot["put_FlipV"] = prot["asc_putFlipV"] = prot.asc_putFlipV;
	prot["get_FlipHInvert"] = prot["asc_getFlipHInvert"] = prot.asc_getFlipHInvert;
	prot["put_FlipHInvert"] = prot["asc_putFlipHInvert"] = prot.asc_putFlipHInvert;
	prot["get_FlipVInvert"] = prot["asc_getFlipVInvert"] = prot.asc_getFlipVInvert;
	prot["put_FlipVInvert"] = prot["asc_putFlipVInvert"] = prot.asc_putFlipVInvert;
	prot["put_ResetCrop"] = prot["asc_putResetCrop"] = prot.asc_putResetCrop;

	prot["get_Title"] = prot["asc_getTitle"] = prot.asc_getTitle;
	prot["put_Title"] = prot["asc_putTitle"] = prot.asc_putTitle;
	prot["get_Description"] = prot["asc_getDescription"] = prot.asc_getDescription;
	prot["put_Description"] = prot["asc_putDescription"] = prot.asc_putDescription;
	prot["get_Name"] = prot["asc_getName"] = prot.asc_getName;
	prot["put_Name"] = prot["asc_putName"] = prot.asc_putName;
	prot["get_ColumnNumber"] = prot["asc_getColumnNumber"] = prot.asc_getColumnNumber;
	prot["put_ColumnNumber"] = prot["asc_putColumnNumber"] = prot.asc_putColumnNumber;
	prot["get_ColumnSpace"] = prot["asc_getColumnSpace"] = prot.asc_getColumnSpace;
	prot["get_TextFitType"] = prot["asc_getTextFitType"] = prot.asc_getTextFitType;
	prot["get_VertOverflowType"] = prot["asc_getVertOverflowType"] = prot.asc_getVertOverflowType;
	prot["put_ColumnSpace"] = prot["asc_putColumnSpace"] = prot.asc_putColumnSpace;
	prot["put_TextFitType"] = prot["asc_putTextFitType"] = prot.asc_putTextFitType;
	prot["put_VertOverflowType"] = prot["asc_putVertOverflowType"] = prot.asc_putVertOverflowType;
	prot["asc_getSignatureId"] = prot["asc_getSignatureId"] = prot.asc_getSignatureId;

	prot["put_Shadow"] = prot.put_Shadow = prot["put_shadow"] = prot.put_shadow = prot["asc_putShadow"] = prot.asc_putShadow;
	prot["get_Shadow"] = prot.get_Shadow = prot["get_shadow"] = prot.get_shadow = prot["asc_getShadow"] = prot.asc_getShadow;

	prot["put_Anchor"] = prot.put_Anchor = prot["asc_putAnchor"] = prot.asc_putAnchor;
	prot["get_Anchor"] = prot.get_Anchor = prot["asc_getAnchor"] = prot.asc_getAnchor;
	prot["get_ProtectionLockText"] = prot["asc_getProtectionLockText"] = prot.asc_getProtectionLockText;
	prot["put_ProtectionLockText"] = prot["asc_putProtectionLockText"] = prot.asc_putProtectionLockText;
	prot["get_ProtectionLocked"] = prot["asc_getProtectionLocked"] = prot.asc_getProtectionLocked;
	prot["put_ProtectionLocked"] = prot["asc_putProtectionLocked"] = prot.asc_putProtectionLocked;
	prot["get_ProtectionPrint"] = prot["asc_getProtectionPrint"] = prot.asc_getProtectionPrint;
	prot["put_ProtectionPrint"] = prot["asc_putProtectionPrint"] = prot.asc_putProtectionPrint;
	prot["get_Transparent"] = prot["asc_getTransparent"] = prot.asc_getTransparent;
	prot["put_Transparent"] = prot["asc_putTransparent"] = prot.asc_putTransparent;
	prot["get_IsCrop"] = prot["asc_getIsCrop"] = prot.asc_getIsCrop;

	window["AscCommon"].asc_CSelectedObject = asc_CSelectedObject;
	prot = asc_CSelectedObject.prototype;
	prot["get_ObjectType"] = prot["asc_getObjectType"] = prot.asc_getObjectType;
	prot["get_ObjectValue"] = prot["asc_getObjectValue"] = prot.asc_getObjectValue;

	window["Asc"]["asc_CShapeFill"] = window["Asc"].asc_CShapeFill = asc_CShapeFill;
	prot = asc_CShapeFill.prototype;
	prot["get_type"] = prot["asc_getType"] = prot.asc_getType;
	prot["put_type"] = prot["asc_putType"] = prot.asc_putType;
	prot["get_fill"] = prot["asc_getFill"] = prot.asc_getFill;
	prot["put_fill"] = prot["asc_putFill"] = prot.asc_putFill;
	prot["get_transparent"] = prot["asc_getTransparent"] = prot.asc_getTransparent;
	prot["put_transparent"] = prot["asc_putTransparent"] = prot.asc_putTransparent;
	prot["asc_CheckForseSet"] = prot["asc_CheckForseSet"] = prot.asc_CheckForseSet;

	window["Asc"]["asc_CFillBlip"] = window["Asc"].asc_CFillBlip = asc_CFillBlip;
	prot = asc_CFillBlip.prototype;
	prot["get_type"] = prot["asc_getType"] = prot.asc_getType;
	prot["put_type"] = prot["asc_putType"] = prot.asc_putType;
	prot["get_url"] = prot["asc_getUrl"] = prot.asc_getUrl;
	prot["put_url"] = prot["asc_putUrl"] = prot.asc_putUrl;
	prot["get_texture_id"] = prot["asc_getTextureId"] = prot.asc_getTextureId;
	prot["put_texture_id"] = prot["asc_putTextureId"] = prot.asc_putTextureId;

	window["Asc"]["asc_CFillHatch"] = window["Asc"].asc_CFillHatch = asc_CFillHatch;
	prot = asc_CFillHatch.prototype;
	prot["get_pattern_type"] = prot["asc_getPatternType"] = prot.asc_getPatternType;
	prot["put_pattern_type"] = prot["asc_putPatternType"] = prot.asc_putPatternType;
	prot["get_color_fg"] = prot["asc_getColorFg"] = prot.asc_getColorFg;
	prot["put_color_fg"] = prot["asc_putColorFg"] = prot.asc_putColorFg;
	prot["get_color_bg"] = prot["asc_getColorBg"] = prot.asc_getColorBg;
	prot["put_color_bg"] = prot["asc_putColorBg"] = prot.asc_putColorBg;

	window["Asc"]["asc_CFillGrad"] = window["Asc"].asc_CFillGrad = asc_CFillGrad;
	prot = asc_CFillGrad.prototype;
	prot["get_colors"] = prot["asc_getColors"] = prot.asc_getColors;
	prot["put_colors"] = prot["asc_putColors"] = prot.asc_putColors;
	prot["get_positions"] = prot["asc_getPositions"] = prot.asc_getPositions;
	prot["put_positions"] = prot["asc_putPositions"] = prot.asc_putPositions;
	prot["get_grad_type"] = prot["asc_getGradType"] = prot.asc_getGradType;
	prot["put_grad_type"] = prot["asc_putGradType"] = prot.asc_putGradType;
	prot["get_linear_angle"] = prot["asc_getLinearAngle"] = prot.asc_getLinearAngle;
	prot["put_linear_angle"] = prot["asc_putLinearAngle"] = prot.asc_putLinearAngle;
	prot["get_linear_scale"] = prot["asc_getLinearScale"] = prot.asc_getLinearScale;
	prot["put_linear_scale"] = prot["asc_putLinearScale"] = prot.asc_putLinearScale;
	prot["get_path_type"] = prot["asc_getPathType"] = prot.asc_getPathType;
	prot["put_path_type"] = prot["asc_putPathType"] = prot.asc_putPathType;

	window["Asc"]["asc_CFillSolid"] = window["Asc"].asc_CFillSolid = asc_CFillSolid;
	prot = asc_CFillSolid.prototype;
	prot["get_color"] = prot["asc_getColor"] = prot.asc_getColor;
	prot["put_color"] = prot["asc_putColor"] = prot.asc_putColor;

	window["Asc"]["asc_CStroke"] = window["Asc"].asc_CStroke = asc_CStroke;
	prot = asc_CStroke.prototype;
	prot["get_type"] = prot["asc_getType"] = prot.asc_getType;
	prot["put_type"] = prot["asc_putType"] = prot.asc_putType;
	prot["get_width"] = prot["asc_getWidth"] = prot.asc_getWidth;
	prot["put_width"] = prot["asc_putWidth"] = prot.asc_putWidth;
	prot["get_color"] = prot["asc_getColor"] = prot.asc_getColor;
	prot["put_color"] = prot["asc_putColor"] = prot.asc_putColor;
	prot["get_linejoin"] = prot["asc_getLinejoin"] = prot.asc_getLinejoin;
	prot["put_linejoin"] = prot["asc_putLinejoin"] = prot.asc_putLinejoin;
	prot["get_linecap"] = prot["asc_getLinecap"] = prot.asc_getLinecap;
	prot["put_linecap"] = prot["asc_putLinecap"] = prot.asc_putLinecap;
	prot["get_linebeginstyle"] = prot["asc_getLinebeginstyle"] = prot.asc_getLinebeginstyle;
	prot["put_linebeginstyle"] = prot["asc_putLinebeginstyle"] = prot.asc_putLinebeginstyle;
	prot["get_linebeginsize"] = prot["asc_getLinebeginsize"] = prot.asc_getLinebeginsize;
	prot["put_linebeginsize"] = prot["asc_putLinebeginsize"] = prot.asc_putLinebeginsize;
	prot["get_lineendstyle"] = prot["asc_getLineendstyle"] = prot.asc_getLineendstyle;
	prot["put_lineendstyle"] = prot["asc_putLineendstyle"] = prot.asc_putLineendstyle;
	prot["get_lineendsize"] = prot["asc_getLineendsize"] = prot.asc_getLineendsize;
	prot["put_lineendsize"] = prot["asc_putLineendsize"] = prot.asc_putLineendsize;
	prot["get_canChangeArrows"] = prot["asc_getCanChangeArrows"] = prot.asc_getCanChangeArrows;
	prot["put_prstDash"] = prot["asc_putPrstDash"] = prot.asc_putPrstDash;
	prot["get_prstDash"] = prot["asc_getPrstDash"] = prot.asc_getPrstDash;
	prot["get_transparent"] = prot["asc_getTransparent"] = prot.asc_getTransparent;
	prot["put_transparent"] = prot["asc_putTransparent"] = prot.asc_putTransparent;

	window["AscCommon"].CAscColorScheme = CAscColorScheme;
	prot = CAscColorScheme.prototype;
	prot["get_colors"] = prot.get_colors;
	prot["get_name"] = prot.get_name;

	window["AscCommon"].CMouseMoveData = CMouseMoveData;
	prot = CMouseMoveData.prototype;
	prot["get_Type"] = prot.get_Type;
	prot["get_X"] = prot.get_X;
	prot["get_Y"] = prot.get_Y;
	prot["get_Hyperlink"] = prot.get_Hyperlink;
	prot["get_UserId"] = prot.get_UserId;
	prot["get_HaveChanges"] = prot.get_HaveChanges;
	prot["get_LockedObjectType"] = prot.get_LockedObjectType;
	prot["get_FootnoteText"] = prot.get_FootnoteText;
	prot["get_FootnoteNumber"] = prot.get_FootnoteNumber;
	prot["get_FormHelpText"] = prot.get_FormHelpText;
	prot["get_ReviewChange"] = prot.get_ReviewChange;
	prot["get_EyedropperColor"] = prot.get_EyedropperColor;
	prot["get_PlaceholderType"] = prot.get_PlaceholderType;
	prot["get_EffectText"] = prot.get_EffectText;
	prot["get_EffectDescription"] = prot.get_EffectDescription;

	window["Asc"]["asc_CUserInfo"] = window["Asc"].asc_CUserInfo = asc_CUserInfo;
	prot = asc_CUserInfo.prototype;
	prot["asc_putId"] = prot["put_Id"] = prot.asc_putId;
	prot["asc_getId"] = prot["get_Id"] = prot.asc_getId;
	prot["asc_putFullName"] = prot["put_FullName"] = prot.asc_putFullName;
	prot["asc_getFullName"] = prot["get_FullName"] = prot.asc_getFullName;
	prot["asc_putFirstName"] = prot["put_FirstName"] = prot.asc_putFirstName;
	prot["asc_getFirstName"] = prot["get_FirstName"] = prot.asc_getFirstName;
	prot["asc_putLastName"] = prot["put_LastName"] = prot.asc_putLastName;
	prot["asc_getLastName"] = prot["get_LastName"] = prot.asc_getLastName;
	prot["asc_putIsAnonymousUser"] = prot["put_IsAnonymousUser"] = prot.asc_putIsAnonymousUser;
	prot["asc_getIsAnonymousUser"] = prot["get_IsAnonymousUser"] = prot.asc_getIsAnonymousUser;

	window["Asc"]["asc_CDocInfo"] = window["Asc"].asc_CDocInfo = asc_CDocInfo;
	prot = asc_CDocInfo.prototype;
	prot["get_Id"] = prot["asc_getId"] = prot.asc_getId;
	prot["put_Id"] = prot["asc_putId"] = prot.asc_putId;
	prot["get_Url"] = prot["asc_getUrl"] = prot.asc_getUrl;
	prot["put_Url"] = prot["asc_putUrl"] = prot.asc_putUrl;
	prot["get_DirectUrl"] = prot["asc_getDirectUrl"] = prot.asc_getDirectUrl;
	prot["put_DirectUrl"] = prot["asc_putDirectUrl"] = prot.asc_putDirectUrl;
	prot["get_Title"] = prot["asc_getTitle"] = prot.asc_getTitle;
	prot["put_Title"] = prot["asc_putTitle"] = prot.asc_putTitle;
	prot["get_Format"] = prot["asc_getFormat"] = prot.asc_getFormat;
	prot["put_Format"] = prot["asc_putFormat"] = prot.asc_putFormat;
	prot["get_VKey"] = prot["asc_getVKey"] = prot.asc_getVKey;
	prot["put_VKey"] = prot["asc_putVKey"] = prot.asc_putVKey;
	prot["get_UserId"] = prot["asc_getUserId"] = prot.asc_getUserId;
	prot["get_UserName"] = prot["asc_getUserName"] = prot.asc_getUserName;
	prot["get_Options"] = prot["asc_getOptions"] = prot.asc_getOptions;
	prot["put_Options"] = prot["asc_putOptions"] = prot.asc_putOptions;
	prot["get_CallbackUrl"] = prot["asc_getCallbackUrl"] = prot.asc_getCallbackUrl;
	prot["put_CallbackUrl"] = prot["asc_putCallbackUrl"] = prot.asc_putCallbackUrl;
	prot["get_TemplateReplacement"] = prot["asc_getTemplateReplacement"] = prot.asc_getTemplateReplacement;
	prot["put_TemplateReplacement"] = prot["asc_putTemplateReplacement"] = prot.asc_putTemplateReplacement;
	prot["get_UserInfo"] = prot["asc_getUserInfo"] = prot.asc_getUserInfo;
	prot["put_UserInfo"] = prot["asc_putUserInfo"] = prot.asc_putUserInfo;
	prot["get_Token"] = prot["asc_getToken"] = prot.asc_getToken;
	prot["put_Token"] = prot["asc_putToken"] = prot.asc_putToken;
	prot["get_Mode"] = prot["asc_getMode"] = prot.asc_getMode;
	prot["put_Mode"] = prot["asc_putMode"] = prot.asc_putMode;
	prot["get_Permissions"] = prot["asc_getPermissions"] = prot.asc_getPermissions;
	prot["put_Permissions"] = prot["asc_putPermissions"] = prot.asc_putPermissions;
	prot["get_Lang"] = prot["asc_getLang"] = prot.asc_getLang;
	prot["put_Lang"] = prot["asc_putLang"] = prot.asc_putLang;
	prot["get_Encrypted"] = prot["asc_getEncrypted"] = prot.asc_getEncrypted;
	prot["put_Encrypted"] = prot["asc_putEncrypted"] = prot.asc_putEncrypted;
	prot["get_EncryptedInfo"] = prot["asc_getEncryptedInfo"] = prot.asc_getEncryptedInfo;
	prot["put_EncryptedInfo"] = prot["asc_putEncryptedInfo"] = prot.asc_putEncryptedInfo;
	prot["get_IsEnabledPlugins"] = prot["asc_getIsEnabledPlugins"] = prot.asc_getIsEnabledPlugins;
	prot["put_IsEnabledPlugins"] = prot["asc_putIsEnabledPlugins"] = prot.asc_putIsEnabledPlugins;
	prot["get_IsEnabledMacroses"] = prot["asc_getIsEnabledMacroses"] = prot.asc_getIsEnabledMacroses;
	prot["put_IsEnabledMacroses"] = prot["asc_putIsEnabledMacroses"] = prot.asc_putIsEnabledMacroses;
	prot["get_CoEditingMode"] = prot["asc_getCoEditingMode"] = prot.asc_getCoEditingMode;
	prot["put_CoEditingMode"] = prot["asc_putCoEditingMode"] = prot.asc_putCoEditingMode;
	prot["put_ReferenceData"] = prot["asc_putReferenceData"] = prot.asc_putReferenceData;
	prot["put_IsWebOpening"] = prot["asc_putIsWebOpening"] = prot.asc_putIsWebOpening;
	prot["get_IsWebOpening"] = prot["asc_getIsWebOpening"] = prot.asc_getIsWebOpening;
	prot["put_SupportsOnSaveDocument"] = prot["asc_putSupportsOnSaveDocument"] = prot.asc_putSupportsOnSaveDocument;
	prot["get_SupportsOnSaveDocument"] = prot["asc_getSupportsOnSaveDocument"] = prot.asc_getSupportsOnSaveDocument;
	prot["put_Wopi"] = prot["asc_putWopi"] = prot.asc_putWopi;
	prot["get_Wopi"] = prot["asc_getWopi"] = prot.asc_getWopi;
	prot["put_Shardkey"] = prot["asc_putShardkey"] = prot.asc_putShardkey;
	prot["get_Shardkey"] = prot["asc_getShardkey"] = prot.asc_getShardkey;
	prot["put_ShowVerticalScroll"] = prot["asc_putShowVerticalScroll"] = prot.asc_putShowVerticalScroll;
	prot["get_ShowVerticalScroll"] = prot["get_getShowVerticalScroll"] = prot.get_getShowVerticalScroll;
	prot["put_ShowHorizontalScroll"] = prot["asc_putShowHorizontalScroll"] = prot.asc_putShowHorizontalScroll;
	prot["get_ShowHorizontalScroll"] = prot["get_getShowHorizontalScroll"] = prot.get_getShowHorizontalScroll;

	window["AscCommon"].COpenProgress = COpenProgress;
	prot = COpenProgress.prototype;
	prot["asc_getType"] = prot.asc_getType;
	prot["asc_getFontsCount"] = prot.asc_getFontsCount;
	prot["asc_getCurrentFont"] = prot.asc_getCurrentFont;
	prot["asc_getImagesCount"] = prot.asc_getImagesCount;
	prot["asc_getCurrentImage"] = prot.asc_getCurrentImage;

	window["AscCommon"].CErrorData = CErrorData;
	prot = CErrorData.prototype;
	prot["put_Value"] = prot.put_Value;
	prot["get_Value"] = prot.get_Value;

	window["AscCommon"].CAscMathType = CAscMathType;
	prot = CAscMathType.prototype;
	prot["get_Id"] = prot.get_Id;
	prot["get_X"] = prot.get_X;
	prot["get_Y"] = prot.get_Y;

	window["AscCommon"].CAscMathCategory = CAscMathCategory;
	prot = CAscMathCategory.prototype;
	prot["get_Id"] = prot.get_Id;
	prot["get_Data"] = prot.get_Data;
	prot["get_W"] = prot.get_W;
	prot["get_H"] = prot.get_H;

	window["AscCommon"].CStyleImage = CStyleImage;
	prot = CStyleImage.prototype;
	prot["asc_getId"] = prot["asc_getName"] = prot["get_Name"] = prot.asc_getName;
	prot["asc_getDisplayName"] = prot.asc_getDisplayName;
	prot["asc_getType"] = prot["get_Type"] = prot.asc_getType;
	prot["asc_getImage"] = prot.asc_getImage;

	window["AscCommon"].asc_CSpellCheckProperty = asc_CSpellCheckProperty;
	prot = asc_CSpellCheckProperty.prototype;
	prot["get_Word"] = prot.get_Word;
	prot["get_Checked"] = prot.get_Checked;
	prot["get_Variants"] = prot.get_Variants;

	window["AscCommon"].CWatermarkOnDraw = CWatermarkOnDraw;
	window["AscCommon"].isFileBuild = isFileBuild;
	window["AscCommon"].checkCanvasInDiv = checkCanvasInDiv;
	window["AscCommon"].isValidJs = isValidJs;
    window["AscCommon"].parseJSDoc = parseJSDoc;

	window["Asc"]["PluginType"] = window["Asc"].PluginType = PluginType;
	window["Asc"]["CPluginVariation"] = window["Asc"].CPluginVariation = CPluginVariation;
	window["Asc"]["CPlugin"] = window["Asc"].CPlugin = CPlugin;

	window["AscCommon"].CDocInfoProp = CDocInfoProp;
	CDocInfoProp.prototype['get_PageCount'] = CDocInfoProp.prototype.get_PageCount;
	CDocInfoProp.prototype['put_PageCount'] = CDocInfoProp.prototype.put_PageCount;
	CDocInfoProp.prototype['get_WordsCount'] = CDocInfoProp.prototype.get_WordsCount;
	CDocInfoProp.prototype['put_WordsCount'] = CDocInfoProp.prototype.put_WordsCount;
	CDocInfoProp.prototype['get_ParagraphCount'] = CDocInfoProp.prototype.get_ParagraphCount;
	CDocInfoProp.prototype['put_ParagraphCount'] = CDocInfoProp.prototype.put_ParagraphCount;
	CDocInfoProp.prototype['get_SymbolsCount'] = CDocInfoProp.prototype.get_SymbolsCount;
	CDocInfoProp.prototype['put_SymbolsCount'] = CDocInfoProp.prototype.put_SymbolsCount;
	CDocInfoProp.prototype['get_SymbolsWSCount'] = CDocInfoProp.prototype.get_SymbolsWSCount;
	CDocInfoProp.prototype['put_SymbolsWSCount'] = CDocInfoProp.prototype.put_SymbolsWSCount;
	
	window["Asc"]["RangePermProp"] = window["Asc"].RangePermProp = RangePermProp;
	prot = RangePermProp.prototype;
	prot["get_canEditText"] = prot.get_canEditText;
	prot["get_canEditPara"] = prot.get_canEditPara;
	prot["get_canInsObject"] = prot.get_canInsObject;

	window["Asc"]["CButtonData"] = window["Asc"].CButtonData = CButtonData;
	prot = CButtonData.prototype;

	prot["get_Obj"] = prot.get_Obj;
	prot["get_Type"] = prot.get_Type;
	prot["get_Button"] = prot.get_Button;
	prot["get_IsForm"] = prot.get_IsForm;
	prot["get_Properties"] = prot.get_Properties;

	window["AscCommon"]["pix2mm"] = window["AscCommon"].pix2mm = function(pix)
	{
		return pix * AscCommon.g_dKoef_pix_to_mm;
	};
	window["AscCommon"]["mm2pix"] = window["AscCommon"].mm2pix = function(mm)
	{
		return mm * AscCommon.g_dKoef_mm_to_pix;
	};
	
})(window);