/*
 * (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";

(function(window, undefined)
{
	var prot;

	// Import
	var c_oEditorId = AscCommon.c_oEditorId;
	var c_oCloseCode = AscCommon.c_oCloseCode;
	var DownloadType = AscCommon.DownloadType;
	var c_oAscFrameDataType = AscCommon.c_oAscFrameDataType;

	var c_oAscError           = Asc.c_oAscError;
	var c_oAscAsyncAction     = Asc.c_oAscAsyncAction;
	var c_oAscAsyncActionType = Asc.c_oAscAsyncActionType;

	/** @constructor */
	function baseEditorsApi(config, editorId)
	{
		this.editorId      = editorId;
		this.isLoadFullApi = false;
        this.modulesCount  = 0;
		this.modulesLoaded = 0;
		this.openResult    = null;
		this.isOpenOOXInBrowser = false;
		this.openOOXInBrowserZip = null;

		this.HtmlElementName = config['id-view'] || '';
		this.HtmlElement     = null;

		this.isMobileVersion = (config['mobile'] === true);
		this.isEmbedVersion = (config['embedded'] === true);

		this.isViewMode = false;
		this.restrictions = Asc.c_oAscRestrictionType.None;
		this.isCanSendChanges = true; // Флаг, говорит о возможности отсылать свои изменения (задается извне)

		this.FontLoader  = null;
		this.ImageLoader = null;

		this.LoadedObject        = null;
		this.DocumentType        = 0; // 0 - empty, 1 - test, 2 - document (from json)
		this.DocInfo             = null;
		this.documentId          = undefined;
		this.documentUserId      = undefined;
		this.documentUrl         = "null";
		this.documentUrlChanges  = null;
		this.documentTokenChanges  = null;
		this.documentCallbackUrl = undefined;		// Ссылка для отправления информации о документе
		this.documentFormat      = "null";
		this.documentTitle       = "null";
		this.documentFormatSave  = Asc.c_oAscFileType.UNKNOWN;
		this.documentShardKey  = undefined;
		this.documentWopiSrc  = undefined;
		this.documentIsWopi = false;
		this.documentUserSessionId = undefined;

		this.documentOpenOptions = undefined;		// Опции при открытии (пока только опции для CSV)

		// Тип состояния на данный момент (сохранение, открытие или никакое)
		this.advancedOptionsAction = AscCommon.c_oAscAdvancedOptionsAction.None;
		this.OpenDocumentProgress  = new AscCommon.COpenProgress();
		var sProtocol              = window.location.protocol;
		this.documentOrigin        = ((sProtocol && '' !== sProtocol) ? sProtocol + '//' : '') + window.location.host; // for presentation theme url
		this.documentPathname      = window.location.pathname; // for presentation theme url

		// Переменная отвечает, получили ли мы ответ с сервера совместного редактирования
		this.ServerIdWaitComplete = false;

		// Long action
		this.IsLongActionCurrent       = 0;
		this.LongActionCallbacks       = [];
		this.LongActionCallbacksParams = [];
		this.IsActionRestrictionCurrent  = 0;
		this.IsActionRestrictionPrev  = null;

		// AutoSave
		this.autoSaveGap = 0;					// Интервал автосохранения (0 - означает, что автосохранения нет) в милесекундах
		this.lastSaveTime = null;				// Время последнего сохранения
		this.autoSaveGapFast = 2000;			// Интервал быстрого автосохранения (когда человек один) - 2 сек.
		this.autoSaveGapSlow = 10 * 60 * 1000;	// Интервал медленного автосохранения (когда совместно) - 10 минут
		this.intervalWaitAutoSave = 1000;

		// Unlock document
		this.canUnlockDocument = false;
		this.canUnlockDocument2 = false;		// Дублирующий флаг, только для saveChanges или unLockDocument
		this.canStartCoAuthoring = false;

		this.isDocumentCanSave = false;			// Флаг, говорит о возможности сохранять документ (активна кнопка save или нет)

		// translate manager
		this.translateManager = AscCommon.translateManager.init(config['translate']);

		//shape names map by preset. Set from interface
		this.shapeNames = {};

		// Chart
		this.chartPreviewManager   = null;
		this.textArtPreviewManager = null;
		this.shapeElementId        = null;
		// Режим вставки диаграмм в редакторе документов
		this.isChartEditor         = false;
		this.isOpenedChartFrame    = false;

		this.isOleEditor = false;

		this.MathMenuLoad          = false;

		this.mathInputType = Asc.c_oAscMathInputType.Unicode;

		// CoAuthoring and Chat
		this.User                   = undefined;
		this.CoAuthoringApi         = new AscCommon.CDocsCoApi();
		this.isCoAuthoringEnable    = true;
		// Массив lock-ов, которые были на открытии документа
		this.arrPreOpenLocksObjects = [];

		// Spell Checking
		this.SpellCheckUrl = '';    // Ссылка сервиса для проверки орфографии

		// Результат получения лицензии
		this.licenseResult       = null;
		// Получили ли лицензию
		this.isOnLoadLicense     = false;
		// Переменная, которая отвечает, послали ли мы окончание открытия документа
		this.isDocumentLoadComplete = false;
		// Переменная, которая отвечает, послали ли мы окончание открытия документа
		this.isPreOpenLocks = true;
		this.isApplyChangesOnOpenEnabled = true;
		this.isProtectionSupport = true;
		this.isAnonymousSupport = true;

		this.canSave    = true;        // Флаг нужен чтобы не происходило сохранение пока не завершится предыдущее сохранение
		this.IsUserSave = false;    // Флаг, контролирующий сохранение было сделано пользователем или нет (по умолчанию - нет)
		this.isForceSaveOnUserSave = false;
        this.forceSaveButtonTimeout = null;
        this.forceSaveButtonContinue = false;
        this.forceSaveTimeoutTimeout = null;
		this.forceSaveForm = null;
		this.forceSaveUndoRequest = false; // Флаг нужен, чтобы мы знали, что данное сохранение пришло по запросу Undo в совместке
		this.forceSaveSendFormRequest = false;
		this.forceSaveDisconnectRequest = false;
		this.forceSaveOformRequest = false;
		this.saveRelativePrev = {};

		// Version History
		this.VersionHistory = null;				// Объект, который отвечает за точку в списке версий

		//Флаги для применения свойств через слайдеры
		this.noCreatePoint     = false;
		this.exucuteHistory    = false;
		this.exucuteHistoryEnd = false;

		this.selectSearchingResults = false;

		this.isSendStandartTextures = false;

		this.tmpFocus = null;

		this.fCurCallback = null;

		this.pluginsManager = null;

		this.isLockTargetUpdate   = false;
		this.isLockScrollToTarget = false;

		this.lastWorkTime = 0;

		this.signatures = [];

		this.currentPassword = "";

		this.disableAutostartMacros = false;
		this.macros = null;
		this.vbaMacros = null;
		this.vbaProject = null;

        this.openFileCryptBinary = null;

        this.copyOutEnabled = true;

		this.watermarkDraw = null;

		this.SaveAfterMacros = false;

		// Spell Checking
		this.SpellCheckApi = new AscCommon.CSpellCheckApi();
		this.isSpellCheckEnable = true;

		// macros & plugins events
		this.internalEvents = {};

		this.skinObject = config['skin'];
		this.isDarkMode = false;

		this.isRtlInterface = config['isRtlInterface'] === true;

		this.Shortcuts = new AscCommon.CShortcuts();
		this.initDefaultShortcuts();

		this.isUseNativeViewer = true;

		this.openedAt = undefined;
		this.maxChangesSize = 0;
		this.binaryChanges = false;

		this.isBlurEditor = false;
		
		this.builderFonts = {};

		this.formatPainter = new AscCommon.CFormatPainter(this);
		this.eyedropper = new AscCommon.CEyedropper(this);
		this.inkDrawer = new AscCommon.CInkDrawer(this);
		this._correctEmbeddedWork();

		return this;
	}

	baseEditorsApi.prototype._init                           = function()
	{
		if (window["AscDesktopEditor"])
			window["AscDesktopEditor"]["CreateEditorApi"](this);

		var t            = this;
		//Asc.editor = Asc['editor'] = AscCommon['editor'] = AscCommon.editor = this; // ToDo сделать это!
		this.HtmlElement = document.getElementById(this.HtmlElementName);
		if (this.HtmlElement)
		{
			// запрещаем действия браузера по умолчанию
			this.HtmlElement.style.touchAction = "none";
		}

		// init OnMessage
		AscCommon.InitOnMessage(function(error, url)
		{
			if (c_oAscError.ID.No !== error)
			{
				t.sendEvent("asc_onError", error, c_oAscError.Level.NoCritical);
			}
			else
			{
				t._addImageUrl([url]);
			}

			t.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.UploadImage);
		});

		AscCommon.loadSdk(this._editorNameById(), function()
		{
			t.isLoadFullApi = true;

			t._onEndLoadSdk();
			t.onEndLoadDocInfo();
		}, function(err) {
			t.sendEvent("asc_onError", Asc.c_oAscError.ID.LoadingScriptError, c_oAscError.Level.Critical);
		});

		this._loadModules();

		const noop = function () { };
		if (!this.isPdfEditor())
		{
			AscCommon.loadChartStyles(noop, function (err) {
				t.sendEvent("asc_onError", Asc.c_oAscError.ID.LoadingScriptError, c_oAscError.Level.NoCritical);
			});
		}
		const sendUnhandledError  = function(errorMsg, url, lineNumber, column, stack) {
			let editorInfo = t.getEditorErrorInfo();
			let memoryInfo = AscCommon.getMemoryInfo();
			lineNumber = undefined !== lineNumber ? lineNumber : "";
			column = undefined !== column ? column : "";
			var msg = 'Error: ' + errorMsg + '\n Script: ' + (url || "") + '\n Line: ' + lineNumber + ':' + column +
				'\n userAgent: ' + (navigator.userAgent || navigator.vendor || window.opera) + '\n platform: ' +
				navigator.platform + '\n isLoadFullApi: ' + t.isLoadFullApi + '\n isDocumentLoadComplete: ' +
				t.isDocumentLoadComplete + (editorInfo ? '\n ' + editorInfo : "") +
				(memoryInfo ? '\n performance.memory: ' + memoryInfo : "") +
				'\n StackTrace: ' + (stack || "");
			AscCommon.sendClientLog("error", "changesError: " + msg, t);
			if (t.isLoadFullApi ) {
				if(t.isDocumentLoadComplete) {
					//todo disconnect and downloadAs ability
					t.sendEvent("asc_onError", Asc.c_oAscError.ID.EditingError, c_oAscError.Level.NoCritical);
					if (t.isCoAuthoringEnable) {
						t.asc_coAuthoringDisconnect();
					} else {
						t.asc_setViewMode(true);
					}
				}
				else {
					t.sendEvent("asc_onError", Asc.c_oAscError.ID.ConvertationOpenError, c_oAscError.Level.Critical);
				}
			}
		}
		var oldOnunhandledrejection = window.onunhandledrejection;
		window.onunhandledrejection = function(errorEvent) {
			//send only first error to reduce number of requests. also following error may be consequences of first
			window.onunhandledrejection = oldOnunhandledrejection;
			const errorMsg = errorEvent.reason.message || errorEvent.reason;
			const stack = errorEvent.reason.stack || "";
			console.error(errorEvent.reason);
			sendUnhandledError(errorMsg, undefined, undefined, undefined, stack);
			if (oldOnunhandledrejection) {
				return oldOnunhandledrejection.apply(this, arguments);
			} else {
				return false;
			}
		}
		var oldOnError = window.onerror;
		window.onerror = function(errorMsg, url, lineNumber, column, errorObj) {
			//send only first error to reduce number of requests. also following error may be consequences of first
			window.onerror = oldOnError;
			sendUnhandledError(errorMsg, url, lineNumber, column, (errorObj ? errorObj.stack : ""));
			if (oldOnError) {
				return oldOnError.apply(this, arguments);
			} else {
				return false;
			}
		};

		// disable mousewheel on macOS
		if (AscCommon.AscBrowser.isMacOs)
		{
			document.body.onmousewheel = function(e) {
				if (e.stopPropagation)
					e.stopPropagation();
				e.returnValue = false;
				return false;
			};
		}
	};
	baseEditorsApi.prototype._correctEmbeddedWork = function()
	{
		let body = document.getElementById("viewport");
		if (body && body.addEventListener)
		{
			body.addEventListener("mousewheel", function(e) {
				if (e.ctrlKey || e.altKey || e.shiftKey || e.metaKey)
					return;
				e.preventDefault && e.preventDefault();
				e.stopPropagation && e.stopPropagation();
				return false;
			}, false);
			body.addEventListener("DOMMouseScroll", function(e)
			{
				if (e.ctrlKey || e.altKey || e.shiftKey || e.metaKey)
					return;
				e.preventDefault && e.preventDefault();
				e.stopPropagation && e.stopPropagation();
				return false;
			}, false);
		}

		var _t = this;
		window.addEventListener && window.addEventListener("blur", function(){
			_t.isBlurEditor = true;
		}, false);
	};
	baseEditorsApi.prototype._editorNameById                 = function()
	{
		var res = '';
		switch (this.editorId)
		{
			case c_oEditorId.Word:
				res = 'word';
				break;
			case c_oEditorId.Spreadsheet:
				res = 'cell';
				break;
			case c_oEditorId.Presentation:
				res = 'slide';
				break;
			case c_oEditorId.Visio:
				res = 'visio';
				break;
		}
		return res;
	};
	baseEditorsApi.prototype._getOpenFormatByEditorId                 = function(editorId, isOpenOoxml)
	{
		let res = Asc.c_oAscFileType.UNKNOWN;
		switch (this.editorId)
		{
			case c_oEditorId.Word:
				if (this.isPdfEditor())
				{
					//todo выставить формат
					res = undefined;
				}
				else
				{
					res = isOpenOoxml ? Asc.c_oAscFileType.DOCX : Asc.c_oAscFileType.CANVAS_WORD;
				}
				break;
			case c_oEditorId.Spreadsheet:
				res = isOpenOoxml ? Asc.c_oAscFileType.XLSX: Asc.c_oAscFileType.CANVAS_SPREADSHEET;
				break;
			case c_oEditorId.Presentation:
				res = isOpenOoxml ? Asc.c_oAscFileType.PPTX : Asc.c_oAscFileType.CANVAS_PRESENTATION;
				break;
			case c_oEditorId.Visio:
				res = Asc.c_oAscFileType.VSDX;
				break;
		}
		return res;
	};
	baseEditorsApi.prototype.getEditorId                     = function()
	{
		return this.editorId;
	};
	baseEditorsApi.prototype.isPdfEditor = function()
	{
		return false;
	};
	baseEditorsApi.prototype.isDocumentRenderer = function()
	{
		return false;
	};
	baseEditorsApi.prototype.getEditorErrorInfo = function()
	{
		return "";
	};

	// modules
	baseEditorsApi.prototype._loadModules = function()
	{
		this.modulesCount = 1;
		AscFonts.load(this, this._onSuccessLoadModule.bind(this), this._onErrorLoadModule.bind(this));
		//AscCommon.zlib_load(this._onSuccessLoadModule.bind(this), this._onErrorLoadModule.bind(this));
	};
	baseEditorsApi.prototype._onSuccessLoadModule = function()
	{
		this.modulesLoaded++;
		if (this.modulesLoaded === this.modulesCount)
			this.onEndLoadFile(null);
	};
	baseEditorsApi.prototype._onErrorLoadModule = function()
	{
		this.sendEvent("asc_onError", Asc.c_oAscError.ID.LoadingScriptError, c_oAscError.Level.Critical);
	};
	baseEditorsApi.prototype._isLoadedModules = function()
	{
		return (this.modulesLoaded === this.modulesCount) ? true : false;
	};

	baseEditorsApi.prototype.asc_loadFontsFromServer             = function (fonts)
	{
		if (!fonts)
		{
			fonts = ["Arial", "Symbol", "Wingdings", "Courier New", "Times New Roman"];
		}
		this.FontLoader.LoadFontsFromServer(fonts);
	};
	baseEditorsApi.prototype.asc_GetFontThumbnailsPath       = function()
	{
		return '../Common/Images/';
	};
	baseEditorsApi.prototype.asc_getDocumentName             = function()
	{
		return this.documentTitle;
	};
	baseEditorsApi.prototype.asc_getAppProps                 = function()
	{
		return null;
	};
	baseEditorsApi.prototype.asc_getCoreProps                = function()
	{
		var oCore = this.getInternalCoreProps();
		if(oCore) {
			return oCore.copy();
		}
		return null;
	};
	baseEditorsApi.prototype.getInternalCoreProps                = function()
	{
		return null;
	};
	baseEditorsApi.prototype.isFrameEditor = function () {
		return !!(this.isChartEditor ||  this.isEditOleMode); // TODO: solve the confusion
	};
	baseEditorsApi.prototype.asc_setCoreProps                = function(oProps)
	{

	};
	baseEditorsApi.prototype.asc_setDocInfo                  = function(oDocInfo)
	{
		var oldInfo = this.DocInfo;
		if (oDocInfo)
		{
			this.DocInfo = oDocInfo;
		}

		if (this.DocInfo)
		{
			this.documentId          = this.DocInfo.get_Id();
			this.documentUserId      = this.DocInfo.get_UserId();
			this.documentUrl         = this.DocInfo.get_Url();
			this.documentTitle       = this.DocInfo.get_Title();
			this.documentFormat      = this.DocInfo.get_Format();
			this.documentCallbackUrl = this.DocInfo.get_CallbackUrl();

			this.documentOpenOptions = this.DocInfo.asc_getOptions();

			var permissions = this.DocInfo.asc_getPermissions();
			if (permissions && undefined !== permissions['copy'])
			{
				this.copyOutEnabled = permissions['copy'];
			}

			this.User = new AscCommon.asc_CUser();
			this.User.setId(this.DocInfo.get_UserId());
			this.User.setUserName(this.DocInfo.get_UserName());
			this.User.setFirstName(this.DocInfo.get_FirstName());
			this.User.setLastName(this.DocInfo.get_LastName());

			//чтобы в versionHistory был один documentId для auth и open
			this.CoAuthoringApi.setDocId(this.documentId);

			if (this.DocInfo.get_Wopi())
			{
				this.documentWopiSrc = this.DocInfo.get_Wopi()["WOPISrc"];
				this.documentUserSessionId = this.DocInfo.get_Wopi()["UserSessionId"];
				this.documentIsWopi = true;
			}
			if (this.documentOpenOptions)
			{
				if (this.documentOpenOptions["watermark"])
				{
					this.watermarkDraw = new AscCommon.CWatermarkOnDraw(this.documentOpenOptions["watermark"], this);
					this.watermarkDraw.CheckParams(this);
				}

				if (false === this.documentOpenOptions["oform"] && AscCommon.IsSupportOFormFeature())
				{
					window["Asc"]["Addons"]["forms"] = false;
					AscCommon.g_oTableId.InitOFormClasses();
				}
			}
			if (!this.documentWopiSrc) {
				//todo add tenant in origin?
				this.documentShardKey = this.DocInfo.get_Shardkey() || this.documentId;
			}
		}

		if (AscCommon.chartMode === this.documentUrl)
		{
			this.isChartEditor = true;
            AscCommon.EncryptionWorker.isChartEditor = true;
			this.DocInfo.put_OfflineApp(true);
		}
		else if (AscCommon.offlineMode === this.documentUrl)
		{
			this.DocInfo.put_OfflineApp(true);
		}
		else if (AscCommon.dataMode === this.documentUrl)
		{
			this.DocInfo.put_IsWebOpening(true);
		}

		if (this.DocInfo.get_EncryptedInfo())
		{
			if (undefined !== window["AscDesktopEditor"])
			{
				var obj = this.DocInfo.get_EncryptedInfo();
				obj["userId"] = this.documentUserId;
				window["AscDesktopEditor"]["execCommand"]("portal:cryptoinfo", JSON.stringify(obj));
			}
		}

		if (undefined !== window["AscDesktopEditor"] && !(this.DocInfo && this.DocInfo.get_OfflineApp()))
		{
			window["AscDesktopEditor"]["SetDocumentName"](this.documentTitle);
		}

		if (!this.isChartEditor && undefined !== window["AscDesktopEditor"] && undefined !== window["AscDesktopEditor"]["CryptoMode"])
		{
			this.DocInfo.put_Encrypted(0 < window["AscDesktopEditor"]["CryptoMode"]);
		}

		if (!oldInfo)
		{
			this.onEndLoadDocInfo();
		}
	};
	baseEditorsApi.prototype.asc_changeDocInfo = function(oDocInfo)
	{
		var rData = {
			"c": 'changedocinfo',
			"id": this.documentId,
			"username": oDocInfo.asc_getUserName()
		};
		var t            = this;
		t.fCurCallback   = function(input)
		{
			if (null != input && "changedocinfo" == input["type"])
			{
				if ('ok' === input["status"]) {
					t.DocInfo.asc_getUserInfo().asc_putFullName(oDocInfo.asc_getUserName());
					t.User.setUserName(oDocInfo.asc_getUserName());
				} else {
					t.sendEvent("asc_onError", AscCommon.mapAscServerErrorToAscError(parseInt(input["data"])),
						c_oAscError.Level.NoCritical);
				}
			}
			else
			{
				t.sendEvent("asc_onError", c_oAscError.ID.Unknown, c_oAscError.Level.NoCritical);
			}
		};
		AscCommon.sendCommand(this, null, rData);
	};
	baseEditorsApi.prototype.asc_isCrypto = function()
	{
		if (this.DocInfo && this.DocInfo.get_Encrypted() === true)
			return true;
		return false;
	};
	baseEditorsApi.prototype.asc_enableKeyEvents             = function(isEnabled, isFromInput)
	{
	};
	// Copy/Past/Cut
	baseEditorsApi.prototype.asc_IsFocus                     = function(bIsNaturalFocus)
	{
		var _ret = false;
		if (this.WordControl.IsFocus)
			_ret = true;
		if (_ret && bIsNaturalFocus && this.WordControl.TextBoxInputFocus)
			_ret = false;
		return _ret;
	};
	baseEditorsApi.prototype.isCopyOutEnabled                = function()
	{
		return this.copyOutEnabled;
	};
	baseEditorsApi.prototype.sync_CanCopyCutCallback = function (bCanCopyCut, bCanCut)
	{
		this.sendEvent("asc_onCanCopyCut", bCanCopyCut, bCanCut);
	};
	baseEditorsApi.prototype.can_CopyCut = function ()
	{
		return true;
	};
	// target pos
	baseEditorsApi.prototype.asc_LockTargetUpdate		     = function(isLock)
	{
		this.isLockTargetUpdate = isLock;
	};
	baseEditorsApi.prototype.asc_LockScrollToTarget          = function(isLock)
	{
		this.isLockScrollToTarget = isLock;
	};
	baseEditorsApi.prototype.isLiveViewer                     = function()
	{
		return this.isViewMode && AscCommon.CollaborativeEditing.Is_Fast() && !this.VersionHistory;
	};
	// Events
	baseEditorsApi.prototype.sendEvent                       = function()
	{
	};
	baseEditorsApi.prototype.asc_checkNeedCallback = function(name)
	{
		return false;
	};
	baseEditorsApi.prototype.SendOpenProgress                = function()
	{
		this.sendEvent("asc_onOpenDocumentProgress", this.OpenDocumentProgress);
	};
	baseEditorsApi.prototype.sync_InitEditorFonts            = function(gui_fonts)
	{
		if (!this.isViewMode) {
			// корректируем имена для текущего языка интерфейса
			var currentLang = this.asc_getLocale();
			if (typeof currentLang !== "string")
				currentLang = (AscCommon.g_oDefaultCultureInfo && (typeof AscCommon.g_oDefaultCultureInfo.Name === "string")) ? AscCommon.g_oDefaultCultureInfo.Name : "en";

			AscFonts.g_fontApplication && AscFonts.g_fontApplication.CheckNamesForInterface(currentLang);
			this.sendEvent("asc_onInitEditorFonts", gui_fonts);
		}
	};
	/**
	 * @param {Asc.c_oAscAsyncAction} type
	 * @param {Asc.c_oAscAsyncActionType} id
	 * @param {Asc.c_oAscRestrictionType} [actionRestriction]
	 */
	baseEditorsApi.prototype.sync_StartAction                = function(type, id, actionRestriction)
	{
		if (type !== c_oAscAsyncActionType.Empty)
			this.sendEvent('asc_onStartAction', type, id);
		//console.log("asc_onStartAction: type = " + type + " id = " + id);

		if (c_oAscAsyncActionType.BlockInteraction === type)
		{
			this.incrementCounterLongAction();
		}
		if (undefined !== actionRestriction)
		{
			//для некоторых действий не хочется показывать модальный loader, который закрывает всю страницу
			//если для них делать incrementCounterLongAction, то будут проблемы, что не заблокированы линейки, resize окна не работает
			//И скорее всего другие проблемы, поэтому делается через asc_setRestriction
			this.incrementCounterActionRestriction(actionRestriction);
		}
	};
	/**
	 * @param type {Asc.c_oAscAsyncAction}
	 * @param id {Asc.c_oAscAsyncActionType}
	 * @param {Asc.c_oAscRestrictionType} [actionRestriction]
	 */
	baseEditorsApi.prototype.sync_EndAction                  = function(type, id, actionRestriction)
	{
		if (type !== c_oAscAsyncActionType.Empty)
			this.sendEvent('asc_onEndAction', type, id);
		//console.log("asc_onEndAction: type = " + type + " id = " + id);

		if (c_oAscAsyncActionType.BlockInteraction === type)
		{
			this.decrementCounterLongAction();
		}
		if (undefined !== actionRestriction)
		{
			this.decrementCounterActionRestriction();
		}
	};
	baseEditorsApi.prototype.asc_setViewMode                 = function()
	{
	};
	/**
	 * @param val
	 * @param additionalSettings {AscCommon.CRestrictionSettings}
	 */
	baseEditorsApi.prototype.asc_setRestriction              = function(val, additionalSettings)
	{
		// Если выставлен флаг OnlySignatures, то его нельзя перебить никак, кроме как явно снять через
		// editor.removeRestriction(Asc.c_oAscRestrictionType.OnlySignatures)
		if (this.restrictions & Asc.c_oAscRestrictionType.OnlySignatures)
			return;

		this.restrictions = val;
		this.onUpdateRestrictions(additionalSettings);
		this.checkInputMode();
		this.sendEvent("asc_onChangeRestrictions", this.restrictions);
	};
	baseEditorsApi.prototype.getViewMode                     = function()
	{
		return this.isViewMode;
	};
	baseEditorsApi.prototype.asc_addRestriction              = function(val)
	{
		this.restrictions |= val;
		this.onUpdateRestrictions();
		this.checkInputMode();
		this.sendEvent("asc_onChangeRestrictions", this.restrictions);
	};
	baseEditorsApi.prototype.asc_removeRestriction           = function(val)
	{
		this.restrictions &= ~val;
		this.onUpdateRestrictions();
		this.checkInputMode();
		this.sendEvent("asc_onChangeRestrictions", this.restrictions);
	};
	baseEditorsApi.prototype.asc_setCanSendChanges           = function(canSend)
	{
		this.isCanSendChanges = canSend;
	};
	baseEditorsApi.prototype.canSendChanges                  = function()
	{
		return this.isCanSendChanges;
	};

	baseEditorsApi.prototype.checkInputMode                  = function()
	{
		if (AscCommon.g_inputContext)
			AscCommon.g_inputContext.checkViewMode();
	};

	baseEditorsApi.prototype.addTableOleObject = function(oleBinary)
	{
		var _this = this;
		if (oleBinary) {
			if (!oleBinary['imageUrl'])
			{
				var base64Image = oleBinary['base64Image'];
				var fAfterUploadOleObjectImage = function (url) {
					oleBinary['imageUrl'] = url;
					_this.addTableOleObject(oleBinary);
				}
				var obj = {
					fAfterUploadOleObjectImage: fAfterUploadOleObjectImage
				};
				AscCommon.sendImgUrls(_this, [base64Image], function(data) {
					if (data[0] && data[0].path != null && data[0].url !== "error")
					{
						oleBinary['imageUrl'] = data[0].url;
						_this._addImageUrl([data[0].url], obj);
					}
				});
				return;
			}
			var blipUrl = oleBinary['imageUrl'];
			var arrImagesForAddToHistory = oleBinary['imagesForAddToHistory'];
			var binaryDataOfSheet = AscCommon.Base64.decode(oleBinary['binary']);
			var sizes = AscCommon.getSourceImageSize(blipUrl);
			var mmExtX = sizes.width * AscCommon.g_dKoef_pix_to_mm;
			var mmExtY = sizes.height * AscCommon.g_dKoef_pix_to_mm;
			this.asc_addOleObjectAction(blipUrl, binaryDataOfSheet, 'Excel.Sheet.12', mmExtX, mmExtY, sizes.width, sizes.height, true, arrImagesForAddToHistory);
		}
	};
	baseEditorsApi.prototype.asc_addTableOleObject = function(oleBinary)
	{
		this.addTableOleObject(oleBinary);
	};

	baseEditorsApi.prototype.asc_editTableOleObject = function(oleBinary)
	{
		this.editTableOleObject(oleBinary);
	};

	baseEditorsApi.prototype.sendFromFrameToGeneralEditor = function (oData)
	{
		this.sendEvent("asc_sendFromFrameToGeneralEditor", oData);
	};

	baseEditorsApi.prototype.sendFromGeneralToFrameEditor = function (oData)
	{
		this.sendEvent("asc_sendFromGeneralToFrameEditor", oData);
	};


	baseEditorsApi.prototype.asc_getInformationBetweenFrameAndGeneralEditor = function (oData)
	{
		const nType = oData["type"];
		const oInformation = oData["information"]
		switch (nType)
		{
			case c_oAscFrameDataType.GetLoadedImages:
			{
				this.CoAuthoringApi.onDocumentOpen(oInformation["inputWrap"], true);
				break;
			}
			case c_oAscFrameDataType.SendImageUrls:
			{
				AscCommon.sendImgUrls(this, oInformation["images"], function () {}, true, oInformation["token"]);
				break;
			}
			case c_oAscFrameDataType.OpenFrame: // TODO: это нужно перенести в web-apps,
				// при открытии и закрытии фрейма метод должен вызываться там, в 7.2 это сделать не успели
			{
				this.asc_onOpenChartFrame();
				break;
			}
			case c_oAscFrameDataType.ShowImageDialogInFrame:
			{
				const oOptions = {
				sendUrlsToFrameEditor: true
				};
				this.asc_addImage(oOptions);
				break;
			}
			case c_oAscFrameDataType.GetUrlsFromImageDialog:
			{
				let oOptions;
				if (this.oSaveObjectForAddImage)
				{
					oOptions = this.oSaveObjectForAddImage;
					delete this.oSaveObjectForAddImage;
				}
				const arrUrlsForAddToDocumentUrls = oInformation;
				AscCommon.g_oDocumentUrls.addUrls(arrUrlsForAddToDocumentUrls);
				this._addImageUrl(Object.keys(arrUrlsForAddToDocumentUrls).map(function (localUrl) {
					return arrUrlsForAddToDocumentUrls[localUrl]
				}), oOptions);
				this.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.UploadImage);
				break;
			}
			case c_oAscFrameDataType.StartUploadImageAction:
			{
				this.sync_StartAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.UploadImage);
			}
			default:
			{
				break;
			}
		}
	};

	baseEditorsApi.prototype.sendStartUploadImageActionToFrameEditor = function () {
		this.sendFromGeneralToFrameEditor({
			"type": c_oAscFrameDataType.StartUploadImageAction,
		});
	}

	baseEditorsApi.prototype.addImageUrlsFromGeneralToFrameEditor = function (urls)
	{
		const urlsForAddToDocumentUrls = {};
		for (let i = 0; i < urls.length; i += 1)
		{
			const url = urls[i];
			urlsForAddToDocumentUrls[AscCommon.g_oDocumentUrls.getLocal(url)] = url;
		}
		this.sendFromGeneralToFrameEditor({
			"type": AscCommon.c_oAscFrameDataType.GetUrlsFromImageDialog,
			"information": urlsForAddToDocumentUrls
		});
	};

	baseEditorsApi.prototype.editTableOleObject = function(oOleBinaryInfo)
	{
		const oThis = this;
		if (oOleBinaryInfo)
		{
			if (!oOleBinaryInfo['imageUrl'])
			{
				const sBase64Image = oOleBinaryInfo['base64Image'];
				const fAfterUploadOleObjectImage = function (sUrl) {
					oOleBinaryInfo['imageUrl'] = sUrl;
					oThis.editTableOleObject(oOleBinaryInfo);
				}
				const oOptions = {
					fAfterUploadOleObjectImage: fAfterUploadOleObjectImage
				};
				AscCommon.sendImgUrls(oThis, [sBase64Image], function(data) {
					if (data[0] && data[0].path != null && data[0].url !== "error")
					{
						oOleBinaryInfo['imageUrl'] = data[0].url;
						oThis._addImageUrl([data[0].url], oOptions);
					}
				});
				return;
			}

			const oController = this.getGraphicController();
			if (oController)
			{
				const arrSelectedObjects = AscFormat.getObjectsByTypesFromArr(oController.selectedObjects);
				if (arrSelectedObjects.oleObjects.length === 1)
				{
					const arrImagesForAddToHistory = oOleBinaryInfo['imagesForAddToHistory'];
					const oSelectedOleObject = arrSelectedObjects.oleObjects[0];
					const sBlipUrl = oOleBinaryInfo['imageUrl'];
					const arrBinaryDataOfSheet = AscCommon.Base64.decode(oOleBinaryInfo['binary']);
					const oSizes = AscCommon.getSourceImageSize(sBlipUrl);
					const nImageWidthCoefficient = oOleBinaryInfo['widthCoefficient'] || 1;
					const nImageHeightCoefficient = oOleBinaryInfo['heightCoefficient'] || 1;

					let nMMExtX, nMMExtY, nAdaptSizeHeight, nAdaptSizeWidth;
					nAdaptSizeWidth = (oSizes.width || 0) * nImageWidthCoefficient;
					nAdaptSizeHeight = (oSizes.height || 0) * nImageHeightCoefficient;
					nMMExtY = nAdaptSizeHeight * AscCommon.g_dKoef_pix_to_mm;
					nMMExtX = nAdaptSizeWidth * AscCommon.g_dKoef_pix_to_mm;
					this.asc_editOleObjectAction(oSelectedOleObject, sBlipUrl, arrBinaryDataOfSheet, nMMExtX, nMMExtY, nAdaptSizeWidth, nAdaptSizeHeight, arrImagesForAddToHistory);
				}
			}
		}
	};

	baseEditorsApi.prototype.asc_SaveDrawingAsPicture = function(sFormat)
	{
		let oController = this.getGraphicController();
		if(oController)
		{
			let sImageFormat = "image/png";
			if(sFormat === "jpg" || sFormat === "jpeg") {
				sImageFormat = "image/jpeg";
			}
			let oImageData = oController.getImageDataForSaving(true, sImageFormat);
			if(oImageData)
			{
				let a = document.createElement("a");
				let sSrc = oImageData.src;
				a.href = sSrc;
				let sExt = sSrc.substring("data:image/".length, sSrc.indexOf(";base64"));
				a.download = AscCommon.translateManager.getValue("Picture") + "." + sExt;
				a.click();
			}
		}
	};
	baseEditorsApi.prototype.canEdit                         = function()
	{
		return !this.isViewMode && this.restrictions === Asc.c_oAscRestrictionType.None;
	};
	baseEditorsApi.prototype.isTargetHandMode = function()
	{
		return this.isRestrictionForms();
	};
	baseEditorsApi.prototype.isRestrictionForms              = function()
	{
		return !!(this.restrictions & Asc.c_oAscRestrictionType.OnlyForms);
	};
	baseEditorsApi.prototype.isRestrictionComments           = function()
	{
		return !!(this.restrictions & Asc.c_oAscRestrictionType.OnlyComments);
	};
	baseEditorsApi.prototype.isRestrictionSignatures         = function()
	{
		return !!(this.restrictions & Asc.c_oAscRestrictionType.OnlySignatures);
	};
	baseEditorsApi.prototype.isRestrictionView               = function()
	{
		return !!(this.restrictions & Asc.c_oAscRestrictionType.View);
	};
	baseEditorsApi.prototype.onUpdateRestrictions = function()
	{
	};
	baseEditorsApi.prototype.isLongActionBase                    = function()
	{
		//word api overrides isLongAction with additional checks
		return (0 !== this.IsLongActionCurrent);
	};
	baseEditorsApi.prototype.isLongAction                    = function()
	{
		return this.isLongActionBase();
	};
	baseEditorsApi.prototype.incrementCounterLongAction      = function()
	{
		++this.IsLongActionCurrent;
	};
	baseEditorsApi.prototype.decrementCounterLongAction      = function()
	{
		this.IsLongActionCurrent--;
		if (this.IsLongActionCurrent < 0)
		{
			this.IsLongActionCurrent = 0;
		}

		if (!this.isLongActionBase())
		{
			var _length = this.LongActionCallbacks.length;
			for (var i = 0; i < _length; i++)
			{
				this.LongActionCallbacks[i](this.LongActionCallbacksParams[i]);
			}
			this.LongActionCallbacks.splice(0, _length);
			this.LongActionCallbacksParams.splice(0, _length);
		}
	};

	baseEditorsApi.prototype.isActionWithRestriction                   = function()
	{
		return 0 !== this.IsActionRestrictionCurrent;
	};
	baseEditorsApi.prototype.incrementCounterActionRestriction      = function(restrictions)
	{
		if (0 === this.IsActionRestrictionCurrent)
		{
			this.IsActionRestrictionPrev = this.restrictions;
			this.asc_setRestriction(restrictions);
		}
		++this.IsActionRestrictionCurrent;
	};
	baseEditorsApi.prototype.decrementCounterActionRestriction      = function()
	{
		this.IsActionRestrictionCurrent--;
		if (this.IsActionRestrictionCurrent < 0)
		{
			this.IsActionRestrictionCurrent = 0;
		}

		if (0 === this.IsActionRestrictionCurrent && null !== this.IsActionRestrictionPrev)
		{
			this.asc_setRestriction(this.IsActionRestrictionPrev);
			this.IsActionRestrictionPrev = null;
		}
	};
	baseEditorsApi.prototype.checkLongActionCallback         = function(_callback, _param)
	{
		if (this.isLongActionBase())
		{
			this.LongActionCallbacks[this.LongActionCallbacks.length]             = _callback;
			this.LongActionCallbacksParams[this.LongActionCallbacksParams.length] = _param;
			return false;
		}
		else
		{
			return true;
		}
	};
	baseEditorsApi.prototype.canUndoRedoByRestrictions = function()
	{
		return (this.canEdit() || this.isRestrictionComments() || this.isRestrictionForms());
	};
	/**
	 * Функция для загрузчика шрифтов (нужно ли грузить default шрифты). Для Excel всегда возвращаем false
	 * @returns {boolean}
	 */
	baseEditorsApi.prototype.IsNeedDefaultFonts = function()
	{
		var res = false;
		switch (this.editorId)
		{
			case c_oEditorId.Word:
				res = true;
				break;
			case c_oEditorId.Presentation:
				res = true;
				break;
			case c_oEditorId.Visio:
				//todo сделать как в презентациях когда будет редактор
				res = false;
				break;
		}
		return res;
	};
	baseEditorsApi.prototype.isShowShapeAdjustments = function()
	{
		return true;
	};
	baseEditorsApi.prototype.isShowTableAdjustments = function()
	{
		return true;
	};
	baseEditorsApi.prototype.isShowEquationTrack = function()
	{
		return true;
	};
	baseEditorsApi.prototype.onPrint                             = function()
	{
		this.sendEvent("asc_onPrint");
	};
	baseEditorsApi.prototype._getOpenCmd = function()
	{
		var rData                  = null;
		if (!(this.DocInfo && this.DocInfo.get_OfflineApp()))
		{
			var locale = !window['NATIVE_EDITOR_ENJINE'] && this.asc_getLocale() || undefined;
			if (typeof locale === "string") {
				if (Asc.g_oLcidNameToIdMap) {
					locale = Asc.g_oLcidNameToIdMap[locale];
				} else {
					locale = undefined;
				}
			}
			let isOpenOoxml = !!(this.DocInfo && this.DocInfo.get_DirectUrl()) && this["asc_isSupportFeature"]("ooxml");
			let outputformat = this._getOpenFormatByEditorId(this.editorId, isOpenOoxml);
			rData = {
				"c"             : 'open',
				"id"            : this.documentId,
				"userid"        : this.documentUserId,
				"format"        : this.documentFormat,
				"url"           : this.documentUrl,
				"title"         : this.documentTitle,
				"lcid"          : locale,
				"nobase64"      : true,
				"outputformat"  : outputformat,
				"convertToOrigin" : ""
			};

			if (this.isUseNativeViewer)
			{
				rData["convertToOrigin"] += Asc.c_sNativeViewerFormats;
			}

			if (this.VersionHistory)
			{
				rData["serverVersion"] = this.VersionHistory.serverVersion;
			}
		}
		return rData;
	}
	// Open
	baseEditorsApi.prototype.asc_LoadDocument                    = function(isRepeat)
	{
		// Меняем тип состояния (на открытие)
		this.advancedOptionsAction = AscCommon.c_oAscAdvancedOptionsAction.Open;

		//todo auth on connection
		this.CoAuthoringApi.auth(this.getViewMode(), this._getOpenCmd());

		if (!isRepeat) {
			this.sync_StartAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.Open);
		}

        if (this.DocInfo.get_Encrypted() && window["AscDesktopEditor"] && !window["AscDesktopEditor"]["IsLocalFile"](true))
        {
        	var t = this;
            window["AscDesktopEditor"]["OpenFileCrypt"](this.DocInfo.get_Title(), this.DocInfo.get_Url(), function () {t.openFileCryptCallback.apply(t, arguments);});
        }
	};
	baseEditorsApi.prototype._openChartOrLocalDocument           = function()
	{
		this._openEmptyDocument();
	};
	baseEditorsApi.prototype._openEmptyDocument           = function()
	{
		var file = new AscCommon.OpenFileResult();
		file.data = AscCommon.getEmpty();
		file.bSerFormat = AscCommon.checkStreamSignature(file.data, AscCommon.c_oSerFormat.Signature);
		this.onEndLoadFile(file);
	};
	baseEditorsApi.prototype._openDocumentEndCallback            = function()
	{
	};
	baseEditorsApi.prototype._openVersionHistoryEndCallback            = function()
	{
		this.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.Open);
	};
	baseEditorsApi.prototype._openOnClient                       = function()
	{
	};
	baseEditorsApi.prototype._onOpenCommand                      = function(data)
	{
		var t = this;
		let perfStart = performance.now();
		AscCommon.openFileCommand(this.documentId, data, this.documentUrlChanges, this.documentTokenChanges, AscCommon.c_oSerFormat.Signature, function(error, result)
		{
			let perfEnd = performance.now();
			AscCommon.sendClientLog("debug", AscCommon.getClientInfoString("onDownloadFile", perfEnd - perfStart), t);
			if (c_oAscError.ID.No !== error)
			{
				t.sendEvent("asc_onError", error, c_oAscError.Level.Critical);
				return;
			}
			t.onEndLoadFile(result);
		});
		this._openOnClient();
	};
	baseEditorsApi.prototype.openFileCryptCallback               = function (stream)
	{
		if (!this.isLoadFullApi)
		{
			this.openFileCryptBinary = stream;
			return;
		}
		this.openFileCryptBinary = null;

		if (stream == null)
		{
			this.sendEvent("asc_onError", c_oAscError.ID.ConvertationOpenError, c_oAscError.Level.Critical);
			return;
		}

		var file = new AscCommon.OpenFileResult();
		file.bSerFormat = AscCommon.checkStreamSignature(stream, AscCommon.c_oSerFormat.Signature);
		file.data = stream;
		this.openDocument(file);
		this.sendEvent("asc_onDocumentPassword", ("" !== this.currentPassword));
	};
	baseEditorsApi.prototype._onNeedParams                       = function(data, opt_isPassword)
	{
	};
	baseEditorsApi.prototype.asyncServerIdEndLoaded              = function(openedAt)
	{
		this.setOpenedAt(openedAt);
		// С сервером соединились, возможно стоит подождать загрузку шрифтов
		this.ServerIdWaitComplete = true;
		this._openDocumentEndCallback();
	};
	baseEditorsApi.prototype.asyncFontStartLoaded                = function()
	{
		// здесь прокинуть евент о заморозке меню
		this.sync_StartAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.LoadFont);
	};
	baseEditorsApi.prototype.asyncImageStartLoaded               = function()
	{
		// здесь прокинуть евент о заморозке меню
	};
	baseEditorsApi.prototype.asyncImagesDocumentStartLoaded      = function(aImages)
	{
		// евент о заморозке не нужен... оно и так заморожено
		// просто нужно вывести информацию в статус бар (что началась загрузка картинок)
	};
	baseEditorsApi.prototype.onDocumentContentReady              = function()
	{
		var t = this;
		this.isDocumentLoadComplete = true;
		if (!window['IS_NATIVE_EDITOR']) {
			setInterval(function() {t._autoSave();}, 40);
		}
		this.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.Open);
		this.sendEvent('asc_onDocumentContentReady');

		let time = this.VersionHistory ? undefined : performance.now();//todo perfStart?
		AscCommon.sendClientLog("debug", AscCommon.getClientInfoString("onDocumentContentReady", time, AscCommon.getMemoryInfo()), t);

		if (window.g_asc_plugins)
            window.g_asc_plugins.onPluginEvent("onDocumentContentReady");

		if (this.DocInfo)
			this["pluginMethod_SetProperties"](this.DocInfo.asc_getOptions());

		if (this.macros && !this.disableAutostartMacros && this.macros.isExistAuto())
			this.sendEvent("asc_onRunAutostartMacroses");

		if (window["AscDesktopEditor"] && window["AscDesktopEditor"]["onDocumentContentReady"])
            window["AscDesktopEditor"]["onDocumentContentReady"]();

		// теперь на старте нельзя удалить бинарник для подбора - он может пригодиться в nativeViewer
		if (!this.disableRemoveFonts)
			delete window["g_fonts_selection_bin"];
	};
	// Save
	baseEditorsApi.prototype.processSavedFile                    = function(url, downloadType, filetype)
	{
		if (AscCommon.DownloadType.None !== downloadType)
		{
			this.sendEvent(downloadType, url, filetype);
		}
		else
		{
			AscCommon.getFile(url);
		}
	};
	baseEditorsApi.prototype.getDrawingObjects = function ()
	{
		return null;
	};
	baseEditorsApi.prototype.getDrawingDocument = function ()
	{
		return null;
	};
	baseEditorsApi.prototype.getLogicDocument = function ()
	{
		return null;
	};
	baseEditorsApi.prototype._createSmartArt = function ()
	{
		return null;
	};
	baseEditorsApi.prototype.asc_createSmartArt = function (nSmartArtType, oPlaceholderObject) {
		const oThis = this;
		AscCommon.g_oBinarySmartArts.checkLoadDrawing().then(function()
		{
			return AscCommon.g_oBinarySmartArts.checkLoadData(nSmartArtType);
		}).then(function()
		{
			AscCommon.History.Create_NewPoint(AscDFH.historydescription_Document_AddSmartArt);
			const oSmartArt = new AscFormat.SmartArt();
			oSmartArt.fillByPreset(nSmartArtType);
			const oController = oThis.getGraphicController();
			oThis._createSmartArt(oSmartArt, oPlaceholderObject);
			oController.clearTrackObjects();
			oController.clearPreTrackObjects();
			oController.updateOverlay();
			oController.changeCurrentState(new AscFormat.NullState(oController));
			oController.updateSelectionState();
			return oSmartArt;
		});
	};
	baseEditorsApi.prototype.forceSave = function()
	{
		if (!this.getViewMode()) {
			return this.CoAuthoringApi.forceSave();
		}
		return false;
	};
	baseEditorsApi.prototype.saveFromChanges = function(data, timeout, callback) {
		var t = this;
		var fAfterSaveChanges = function() {
			t.forceSaveForm = null;
			if (!t.CoAuthoringApi.callPRC(data, timeout, callback)) {
				callback(false, undefined);
			}
		};
		if (this.asc_Save(true)) {
			this.forceSaveForm = fAfterSaveChanges;
		} else {
			fAfterSaveChanges();
		}
	};
	/**
	 * This callback is displayed as a global member.
	 * @callback saveRelativeFromChangesCallback
	 * @param {boolean} timeout
	 * @param {Object} data description
	 * @param {number} data.errorCode from AscCommon.c_oAscServerCommandErrors {NoError, NotModified, Token, UnknownError}
	 * @param {boolean} data.inProgress
	 * @param {string} data.url
	 */
	/**
	 * Сохранение документа с указанием относительного пути
	 * @param docId external document id
	 * @param token from intergation
	 * @param timeout in ms
	 * @param callback {saveRelativeFromChangesCallback}
	 */
	baseEditorsApi.prototype.saveRelativeFromChanges = function(docId, token, timeout, callback) {
		let t = this;
		let time = this.saveRelativePrev[docId];
		let callbackWrapper = function (timeout, data) {
			if (data && data.time) {
				t.saveRelativePrev[docId] = data.time;
			}
			callback(timeout, data);
		}
		if (!this.CoAuthoringApi.callPRC({'type': 'saveRelativeFromChanges', 'docId': docId, 'token': token, 'time': time}, timeout, callbackWrapper)) {
			callback(true, undefined);
		}
	};

	baseEditorsApi.prototype.asc_setIsForceSaveOnUserSave = function(val)
	{
		this.isForceSaveOnUserSave = val;
	};
	baseEditorsApi.prototype._onUpdateDocumentCanSave = function () {
	};
	baseEditorsApi.prototype._onUpdateDocumentCanUndoRedo = function () {
	};
	baseEditorsApi.prototype._saveCheck = function () {
		return false;
	};
	// Переопределяется во всех редакторах
	baseEditorsApi.prototype._haveOtherChanges = function () {
		return false;
	};
	baseEditorsApi.prototype._haveChanges = function() {
		return AscCommon.History.Have_Changes();
	};
	baseEditorsApi.prototype._onSaveCallback = function (e) {
		var t = this;
		var nState;
		if (false == e["saveLock"]) {
			if (this.isLongAction()) {
				// Мы не можем в этот момент сохранять, т.к. попали в ситуацию, когда мы залочили сохранение и успели нажать вставку до ответа
				// Нужно снять lock с сохранения
				this.CoAuthoringApi.onUnSaveLock = function () {
					if (t.isForceSaveOnUserSave && t.IsUserSave) {
						t.forceSaveButtonContinue = t.forceSave();
					}
					if (t.forceSaveForm) {
						t.forceSaveForm();
					}

					t.canSave = true;
					t.IsUserSave = false;
					t.lastSaveTime = null;

					if (t.canUnlockDocument) {
						t._unlockDocument();
					}
				};
				this.CoAuthoringApi.unSaveLock();
				return;
			}

			this.sync_StartAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.Save);

			this.canUnlockDocument2 = this.canUnlockDocument;
			if (this.canUnlockDocument && this.canStartCoAuthoring) {
				this.CoAuthoringApi.onStartCoAuthoring(true);
			}
			this.canStartCoAuthoring = false;
			this.canUnlockDocument = false;

			this._onSaveCallbackInner();
		} else {
			nState = this.CoAuthoringApi.get_state();
			if (AscCommon.ConnectionState.ClosedCoAuth === nState || AscCommon.ConnectionState.ClosedAll === nState) {
				// Отключаемся от сохранения, соединение потеряно
				this.IsUserSave = false;
				this.canSave = true;
			} else {
				// Если автосохранение, то не будем ждать ответа, а просто перезапустим таймер на немного
				if (!this.IsUserSave) {
					this.canSave = true;
					if (this.canUnlockDocument) {
						this._unlockDocument();
					}
					return;
				}

				setTimeout(function() {
					t.CoAuthoringApi.askSaveChanges(function(event) {
						t._onSaveCallback(event);
					});
				}, 1000);
			}
		}
	};
	// Функция сохранения. Переопределяется во всех редакторах
	baseEditorsApi.prototype._onSaveCallbackInner = function () {
	};
	baseEditorsApi.prototype._autoSave = function () {
		if (this.canSave && (!this.isViewMode || this.isLiveViewer()) && (this.canUnlockDocument || 0 !== this.autoSaveGap)) {
			if (this.canUnlockDocument) {
				this.lastSaveTime = new Date();
				// Check edit mode after unlock document http://bugzilla.onlyoffice.com/show_bug.cgi?id=35971
				// Close cell edit without errors (isIdle = true)
				this.asc_Save(true, true);
			} else {
				this._autoSaveInner();
			}
		}
	};
	// Функция автосохранения. Переопределяется во всех редакторах
	baseEditorsApi.prototype._autoSaveInner = function () {
	};
	baseEditorsApi.prototype._prepareSave = function (isIdle) {
		return true;
	};
	// Unlock document when start co-authoring
	baseEditorsApi.prototype._unlockDocument = function (isWaitAuth) {
		if (isWaitAuth && this.isDocumentLoadComplete && !this.canSave) {
			var errorMsg = 'Error: connection state changed waitAuth' +
				';this.canSave:' + this.canSave;
			AscCommon.sendClientLog("error", "changesError: " + errorMsg, this);
		}
		if (this.isDocumentLoadComplete) {
			// Document is load
			this.canUnlockDocument = true;
			this.canStartCoAuthoring = true;
			if (this.canSave) {
				// We can only unlock with delete index
				this.CoAuthoringApi.unLockDocument(false, true, AscCommon.History.GetDeleteIndex());
				this.startCollaborationEditing();
				AscCommon.History.RemovePointsByDeleteIndex();
				this._onUpdateDocumentCanSave();
				this._onUpdateDocumentCanUndoRedo();
				this.canStartCoAuthoring = false;
				this.canUnlockDocument = false;
			} else {
				// ToDo !!!!
			}
		} else {
			// Когда документ еще не загружен, нужно отпустить lock (при быстром открытии 2-мя пользователями)
			this.startCollaborationEditing();
			this.CoAuthoringApi.unLockDocument(false, true);
		}
	};
	// Выставление интервала автосохранения (0 - означает, что автосохранения нет)
	baseEditorsApi.prototype.asc_setAutoSaveGap                  = function(autoSaveGap)
	{
		if (typeof autoSaveGap === "number")
		{
			this.autoSaveGap = autoSaveGap * 1000; // Нам выставляют в секундах
		}
	};
	baseEditorsApi.prototype.checkChangesSize = function() {
		if (0 === this.maxChangesSize) {
			return;
		}
		let api = this;
		let localSize = AscCommon.History.GetLocalChangesSize ? AscCommon.History.GetLocalChangesSize() : 0;
		let serverSize = api.CoAuthoringApi.get_serverChangesSize();
		if (localSize + serverSize > api.maxChangesSize) {
			api.asc_stopSaving();
			api.sendEvent("asc_onConfirmAction", Asc.c_oAscConfirm.ConfirmMaxChangesSize,
				function(can) {
					if (can) {
						api.asc_Undo ? api.asc_Undo() : api.Undo();
					} else {
						api.setViewModeDisconnect(true);
					}
					api.asc_continueSaving();
				});
		}
	};
	// send chart message
	baseEditorsApi.prototype.asc_coAuthoringChatSendMessage      = function(message)
	{
		this.CoAuthoringApi.sendMessage(message);
	};
	// get chart messages
	baseEditorsApi.prototype.asc_coAuthoringChatGetMessages      = function()
	{
		this.CoAuthoringApi.getMessages();
	};
	// get users, возвращается массив users
	baseEditorsApi.prototype.asc_coAuthoringGetUsers             = function()
	{
		this.CoAuthoringApi.getUsers();
	};
	// get permissions
	baseEditorsApi.prototype.asc_getEditorPermissions            = function()
	{
		AscCommon.sendClientLog("debug", AscCommon.getClientInfoString("getEditorPermissions", performance.now()), this);
		this._coAuthoringInit();
	};
	baseEditorsApi.prototype.getConvertedXLSXFileFromUrl  = function (sUrl, sFileType, sToken, nOutputFormat, fCallback) {
		if (this.canEdit()) {
			const oDocument = {url: sUrl, format: sFileType, token: sToken};
			this.insertDocumentUrlsData = {
				imageMap: null, documents: [oDocument], convertCallback: function (_api, url) {
					_api.insertDocumentUrlsData.imageMap = url;
					if (url['output.xlsx']) {
						fCallback(url['output.xlsx']);
					} else if (url['output.xlst']) {
						fCallback(url['output.xlst']);
					} else {
						fCallback(null);
					}
					_api.endInsertDocumentUrls();
				}, endCallback: function (_api) {
					fCallback(null);
				}
			};

			const oOptions = new Asc.asc_CDownloadOptions(nOutputFormat);
			oOptions.isNaturalDownload = true;
			oOptions.isGetTextFromUrl = true;
			this.downloadAs(Asc.c_oAscAsyncAction.DownloadAs, oOptions);
		}
	};
	baseEditorsApi.prototype.getConvertedBinFileFromRtf  = function (document, nOutputFormat, fCallback) {
		if (this.canEdit()) {
			this.insertDocumentUrlsData = {
				imageMap: null, documents: [document], convertCallback: function (_api, url) {
					_api.insertDocumentUrlsData.imageMap = url;
					if (url['output.bin']) {
						fCallback(url['output.bin']);
					} else {
						fCallback(null);
					}
					//_api.endInsertDocumentUrls();
				}, endCallback: function (_api) {
					fCallback(null);
				}
			};

			const oOptions = new Asc.asc_CDownloadOptions(nOutputFormat);
			oOptions.isNaturalDownload = true;
			oOptions.isGetTextFromUrl = true;
			this.downloadAs(Asc.c_oAscAsyncAction.DownloadAs, oOptions);
		}
	};
	baseEditorsApi.prototype._onEndPermissions                   = function()
	{
		if (this.isOnLoadLicense) {
			var oResult = new AscCommon.asc_CAscEditorPermissions();
			if (null !== this.licenseResult) {
				var type = this.licenseResult['type'];
				oResult.setLicenseType(type);
				oResult.setCanBranding(this.licenseResult['branding']);
				oResult.setCustomization(this.licenseResult['customization']);
				oResult.setIsLight(this.licenseResult['light']);
				oResult.setLicenseMode(this.licenseResult['mode']);
				oResult.setRights(this.licenseResult['rights']);
				oResult.setBuildVersion(this.licenseResult['buildVersion']);
				oResult.setBuildNumber(this.licenseResult['buildNumber']);
				oResult.setLiveViewerSupport(this.licenseResult['liveViewerSupport']);

				if (undefined !== this.licenseResult['protectionSupport']) {
					this.isProtectionSupport = this.licenseResult['protectionSupport'];
				}
				if (undefined !== this.licenseResult['isAnonymousSupport']) {
					this.isAnonymousSupport = this.licenseResult['isAnonymousSupport'];
				}
			}
			this.sendEvent('asc_onGetEditorPermissions', oResult);
		}
	};
	// GoTo
	baseEditorsApi.prototype.goTo                                = function(options)
	{
		options = options || (this.DocInfo && this.DocInfo.asc_getOptions());
		options = options && options['action'];
		if (!options) {
			return;
		}
		switch (options['type']) {
			case 'bookmark':
			case 'internallink':
				this._goToBookmark(options['data']);
				break;
			case 'comment':
				this._goToComment(options['data']);
				break;
		}
	};
	baseEditorsApi.prototype._goToComment                        = function(data)
	{
	};
	baseEditorsApi.prototype._goToBookmark                       = function(data)
	{
	};
	// CoAuthoring
	baseEditorsApi.prototype._coAuthoringInit                    = function()
	{
		this.initCollaborativeEditing();
		
		var t = this;
		//Если User не задан, отключаем коавторинг.
		if (null == this.User || null == this.User.asc_getId())
		{
			this.User = new AscCommon.asc_CUser();
			this.User.setId("Unknown");
			this.User.setUserName("Unknown");
		}
		//в обычном серверном режиме портим ссылку, потому что CoAuthoring теперь имеет встроенный адрес
		//todo надо использовать проверку get_OfflineApp
		if (!(window['NATIVE_EDITOR_ENJINE'] || (this.DocInfo && this.DocInfo.get_OfflineApp())) || window['IS_NATIVE_EDITOR'])
		{
			this.CoAuthoringApi.set_url(null);
		}

		this.CoAuthoringApi.onMessage                 = function(e, clear)
		{
			t.sendEvent('asc_onCoAuthoringChatReceiveMessage', e, clear);
		};
		this.CoAuthoringApi.onServerVersion = function (buildVersion, buildNumber) {
			t.sync_EndAction(Asc.c_oAscAsyncActionType.Information, Asc.c_oAscAsyncAction.Disconnect, Asc.c_oAscRestrictionType.View);

			t.sendEvent('asc_onServerVersion', buildVersion, buildNumber);
		};
		this.CoAuthoringApi.onAuthParticipantsChanged = function(users, userId)
		{
			t.sendEvent("asc_onAuthParticipantsChanged", users, userId);
		};
		this.CoAuthoringApi.onParticipantsChanged     = function(users)
		{
			t.sendEvent("asc_onParticipantsChanged", users);
		};
		this.CoAuthoringApi.onSpellCheckInit          = function(e)
		{
			t.SpellCheckUrl = e;
			t._coSpellCheckInit();
		};
		this.CoAuthoringApi.onSetIndexUser            = function(e)
		{
			AscCommon.g_oIdCounter.Set_UserId('' + e);
		};
		this.CoAuthoringApi.onFirstLoadChangesEnd     = function(openedAt)
		{
			t.asyncServerIdEndLoaded(openedAt);
		};
		this.CoAuthoringApi.onFirstConnect            = function()
		{
			if (!t.isOnLoadLicense) {
				t._onEndPermissions();
			} else {
				//todo auth on connection
				if (t.CoAuthoringApi.get_isAuth()) {
					t.CoAuthoringApi.auth(t.getViewMode(), undefined, t.isIdle());
				} else {
					//первый запрос или ответ не дошел надо повторить открытие
					t.asc_LoadDocument(true);
				}
			}
		};
		this.CoAuthoringApi.onLicense                 = function(res)
		{
			t.licenseResult   = res;
			t.isOnLoadLicense = true;
			t._onEndPermissions();
		};
		this.CoAuthoringApi.onLicenseChanged          = function(res)
		{
			if (res['settings']) {
				if (res['settings']['maxChangesSize']) {
					t.maxChangesSize = res['settings']['maxChangesSize'];
				}
				if (res['settings']['binaryChanges']) {
					t.binaryChanges = res['settings']['binaryChanges'];
					t.CoAuthoringApi.setBinaryChanges(t.binaryChanges);
				}
				if (res['settings']['limits_image_size']) {
					AscCommon.c_oAscImageUploadProp.MaxFileSize = res['settings']['limits_image_size']
				}
				if (res['settings']['limits_image_types_upload']) {
					AscCommon.c_oAscImageUploadProp.SupportedFormats = res['settings']['limits_image_types_upload'].split(";")
				}
			}
			let licenseType = res['licenseType'];
			if (t.licenseResult) {
				t.licenseResult['type'] = licenseType;
			}
			t.isOnLoadLicense = true;
			var oResult = new AscCommon.asc_CAscEditorPermissions();
			oResult.setLicenseType(licenseType);
			t.sendEvent('asc_onLicenseChanged', oResult);
		};
		this.CoAuthoringApi.onWarning                 = function(code)
		{
			t.sendEvent('asc_onError', code || c_oAscError.ID.Warning, c_oAscError.Level.NoCritical);
		};
		this.CoAuthoringApi.onMeta                    = function(data)
		{
			var newDocumentTitle = data["title"];
			if (newDocumentTitle) {
				t.documentTitle = newDocumentTitle;
				if (t.DocInfo) {
					t.DocInfo.asc_putTitle(newDocumentTitle);
				}
			}
			t.sendEvent('asc_onMeta', data);
		};
		this.CoAuthoringApi.onSession = function(data) {
			var code = data["code"];
			var reason = data["reason"];
			var interval = data["interval"];
			var extendSession = true;
			if (c_oCloseCode.sessionIdle === code) {
				var idleTime = t.isIdle();
				if (idleTime > interval) {
					extendSession = false;
				} else {
					t.CoAuthoringApi.extendSession(idleTime);
				}
			} else if (c_oCloseCode.sessionAbsolute === code) {
				extendSession = false;
			}
			if (!extendSession) {
				t.CoAuthoringApi.sendClientLog('debug', 'disconnect code:' + code + ';reason:' + reason);
				t.CoAuthoringApi.disconnect(code, reason);
			}
		};
        this.CoAuthoringApi.onForceSave = function(data) {
            if (AscCommon.c_oAscForceSaveTypes.Button === data.type) {
                if (data.start) {
                    if (null === t.forceSaveButtonTimeout && !t.forceSaveButtonContinue) {
                        t.sync_StartAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.ForceSaveButton);
                    } else {
                        clearInterval(t.forceSaveButtonTimeout);
                    }
                    t.forceSaveButtonTimeout = setTimeout(function() {
                        t.forceSaveButtonTimeout = null;
                        if (t.forceSaveButtonContinue) {
                            t.sync_EndAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.Save);
                        } else {
                            t.sync_EndAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.ForceSaveButton);
                        }
                        t.forceSaveButtonContinue = false;
                        t.sendEvent('asc_onError', Asc.c_oAscError.ID.ForceSaveButton, c_oAscError.Level.NoCritical);
                    }, Asc.c_nMaxConversionTime);
                } else if (data.refuse) {
                    if (t.forceSaveButtonContinue) {
                        t.sync_EndAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.Save);
                    }
                    t.forceSaveButtonContinue = false;
                } else {
                    if (null !== t.forceSaveButtonTimeout) {
                        clearInterval(t.forceSaveButtonTimeout);
                        t.forceSaveButtonTimeout = null;
                        if (t.forceSaveButtonContinue) {
                            t.sync_EndAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.Save);
                        } else {
                            t.sync_EndAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.ForceSaveButton);
                        }
                        t.forceSaveButtonContinue = false;
                        if (!data.success) {
                            t.sendEvent('asc_onError', Asc.c_oAscError.ID.ForceSaveButton, c_oAscError.Level.NoCritical);
                        }
                    }
                }
            } else {
                if (AscCommon.CollaborativeEditing.Is_Fast() || null !== t.forceSaveTimeoutTimeout) {
                    if (data.start) {
                        if (null === t.forceSaveTimeoutTimeout) {
                            t.sync_StartAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.ForceSaveTimeout);
                        } else {
                            clearInterval(t.forceSaveTimeoutTimeout);
                        }
                        t.forceSaveTimeoutTimeout = setTimeout(function() {
                            t.forceSaveTimeoutTimeout = null;
                            t.sync_EndAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.ForceSaveTimeout);
                            t.sendEvent('asc_onError', Asc.c_oAscError.ID.ForceSaveTimeout, c_oAscError.Level.NoCritical);
                        }, Asc.c_nMaxConversionTime);
                    } else {
                        if (null !== t.forceSaveTimeoutTimeout) {
                            clearInterval(t.forceSaveTimeoutTimeout);
                            t.forceSaveTimeoutTimeout = null;
                            t.sync_EndAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.ForceSaveTimeout);
                            if (!data.success) {
                                t.sendEvent('asc_onError', Asc.c_oAscError.ID.ForceSaveTimeout, c_oAscError.Level.NoCritical);
                            }
                        }
                    }
                }
            }
        };
		this.CoAuthoringApi.onExpiredToken = function(data) {
			t.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.Open);
			if (t.VersionHistory && t.VersionHistory.isRequested) {
				var error = AscCommon.getDisconnectErrorCode(t.isDocumentLoadComplete, data["code"]);
				var level = t.isDocumentLoadComplete ? Asc.c_oAscError.Level.NoCritical : Asc.c_oAscError.Level.Critical;
				if (Asc.c_oAscError.ID.UpdateVersion === error && !t.isDocumentModified()) {
					t.sendEvent("asc_onDocumentUpdateVersion", function() {});
				} else {
					t.sendEvent('asc_onError', error, level);
				}
			} else {
				t.VersionHistory = null;
				t.sendEvent('asc_onExpiredToken');
			}
		};
		this.CoAuthoringApi.onHasForgotten = function() {
			//todo very bad way, need rewrite
			var isDocumentCanSaveOld = t.isDocumentCanSave;
			var canSaveOld = t.canSave;
			t.isDocumentCanSave = true;
			t.canSave = false;
			t.sendEvent("asc_onDocumentModifiedChanged");
			t.isDocumentCanSave = isDocumentCanSaveOld;
			t.canSave = canSaveOld;
			t.sendEvent("asc_onDocumentModifiedChanged");
		};
		/**
		 * Event об отсоединении от сервера
		 * @param {jQuery} e  event об отсоединении с причиной
		 * @param {opt_closeCode: AscCommon.c_oCloseCode.drop} opt_closeCode
		 */
		this.CoAuthoringApi.onDisconnect = function(e, opt_closeCode)
		{
			if (AscCommon.c_oCloseCode.quiet === opt_closeCode) {
				return;
			}
			if (AscCommon.ConnectionState.None === t.CoAuthoringApi.get_state())
			{
				t.asyncServerIdEndLoaded();
			}
			let isSessionIdleDisconnect = AscCommon.c_oCloseCode.sessionIdle === opt_closeCode;
			if (null != opt_closeCode && !isSessionIdleDisconnect) {
				t.sync_EndAction(Asc.c_oAscAsyncActionType.Information, Asc.c_oAscAsyncAction.Disconnect, Asc.c_oAscRestrictionType.View);
				let allowRefresh = [c_oCloseCode.updateVersion, c_oCloseCode.noCache, c_oCloseCode.restore, c_oCloseCode.quiet];
				if (-1 !== allowRefresh.indexOf(opt_closeCode) && !t.isDocumentModified() && t.canRefreshFile())  {
					t.onRefreshFile();
				} else {
					var error = AscCommon.getDisconnectErrorCode(t.isDocumentLoadComplete, opt_closeCode);
					var level = t.isDocumentLoadComplete ? Asc.c_oAscError.Level.NoCritical : Asc.c_oAscError.Level.Critical;
					t.setViewModeDisconnect(AscCommon.getEnableDownloadByCloseCode(opt_closeCode));
					if (Asc.c_oAscError.ID.UpdateVersion === error && !t.isDocumentModified()) {
						t.sendEvent("asc_onDocumentUpdateVersion", function() {});
					} else {
						t.sendEvent('asc_onError', error, level);
					}
				}
			} else if (!t.isActionWithRestriction()){
				t.sync_StartAction(Asc.c_oAscAsyncActionType.Information, Asc.c_oAscAsyncAction.Disconnect, Asc.c_oAscRestrictionType.View);
				if (isSessionIdleDisconnect) {
					t.waitNotIdle(undefined, function () {
						t.CoAuthoringApi.connect();
					});
				}
			}
		};
		this.CoAuthoringApi.onDocumentOpen = function (inputWrap) {
			if (t.isOpenedChartFrame) {
				const oSentInformation = {
					"type": c_oAscFrameDataType.GetLoadedImages,
					"information": {
						"inputWrap": inputWrap
					}
				};
				t.sendFromGeneralToFrameEditor(oSentInformation);
			}
			if (AscCommon.EncryptionWorker.isNeedCrypt())
			{
                if (t.fCurCallback) {
                	t.fCurCallback(inputWrap ? inputWrap["data"] : undefined);
                	t.fCurCallback = null;
                }
				return;
			}
			if (inputWrap["data"]) {
				var input = inputWrap["data"];
				switch (input["type"]) {
					case 'reopen':
					case 'open':
						switch (input["status"]) {
							case "updateversion":
							case "ok":
								//call setOpenedAt twice in case of waitAuth
								t.setOpenedAt(input["openedAt"]);
								var urls = input["data"];
								AscCommon.g_oDocumentUrls.init(urls);
								var documentUrl = urls['Editor.bin'] || urls['origin.' + t.documentFormat];
								if (t["asc_isSupportFeature"]("ooxml") && !documentUrl) {
									documentUrl = urls['origin.docx'] || urls['origin.xlsx'] || urls['origin.pptx'];
								}
								if (t.isUseNativeViewer && !documentUrl)
									documentUrl = urls['origin.pdf'] || urls['origin.xps'] || urls['origin.oxps'] || urls['origin.djvu'];
								if (null != documentUrl) {
									if ('ok' === input["status"] || t.getViewMode()) {
										t._onOpenCommand(documentUrl);
									} else if (t.canRefreshFile()) {
										t.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.Open);
										t.onRefreshFile();
									} else {
										t.sendEvent("asc_onDocumentUpdateVersion", function () {
											if (t.isCoAuthoringEnable) {
												t.asc_coAuthoringDisconnect();
											}
											t._onOpenCommand(documentUrl);
										});
									}
								} else {
									t.sendEvent("asc_onError", c_oAscError.ID.ConvertationOpenError,
										c_oAscError.Level.Critical);
								}
								break;
							case "needparams":
								t._onNeedParams(input["data"]);
								break;
							case "needpassword":
								t._onNeedParams(null, true);
								break;
							case "err":
								t.sendEvent("asc_onError",
									AscCommon.mapAscServerErrorToAscError(parseInt(input["data"]),
										Asc.c_oAscError.ID.ConvertationOpenError), c_oAscError.Level.Critical);
								break;
						}
						break;
					default:
						if (t.fCurCallback) {
							t.fCurCallback(input);
							t.fCurCallback = null;
						} else {
							t.sendEvent("asc_onError", c_oAscError.ID.Unknown, c_oAscError.Level.NoCritical);
						}
						break;
				}
			}
		};
		this.CoAuthoringApi.onStartCoAuthoring = function (isStartEvent, isWaitAuth) {
			if (t.isViewMode) {
				return;
			}
			// На старте не нужно ничего делать
			if (isStartEvent) {
				t.startCollaborationEditing();
			} else {
				t._unlockDocument(isWaitAuth);
			}
		};
		this.CoAuthoringApi.onEndCoAuthoring = function (isStartEvent) {
			if (t.canUnlockDocument) {
				t.canStartCoAuthoring = false;
			} else {
				t.endCollaborationEditing();
			}
		};

		this._coAuthoringInitEnd();

		let openCmd = this._getOpenCmd();
		this.CoAuthoringApi.init(this.User, this.documentId, this.documentCallbackUrl, 'fghhfgsjdgfjs', this.editorId, this.documentFormatSave, this.DocInfo, this.documentShardKey, this.documentWopiSrc, this.documentUserSessionId, this.headingsColor, openCmd);
	};
	baseEditorsApi.prototype._coAuthoringInitEnd                 = function()
	{
	};
	baseEditorsApi.prototype.startCollaborationEditing           = function()
	{
	};
	baseEditorsApi.prototype.endCollaborationEditing             = function()
	{
	};
	baseEditorsApi.prototype._coAuthoringCheckEndOpenDocument    = function(f)
	{
		if (this.isPreOpenLocks)
		{
			var context = this.CoAuthoringApi;
			var args = Array.prototype.slice.call(arguments, 1);

			// Пока документ еще не загружен, будем сохранять функцию и аргументы
			this.arrPreOpenLocksObjects.push(function()
			{
				f.apply(context, args);
			});
			return true;
		}
		return false;
	};
	baseEditorsApi.prototype._applyPreOpenLocks                  = function()
	{
		this.isPreOpenLocks = false;
		// Применяем все lock-и (ToDo возможно стоит пересмотреть вообще Lock-и)
		for (var i = 0; i < this.arrPreOpenLocksObjects.length; ++i)
		{
			this.arrPreOpenLocksObjects[i]();
		}
		this.arrPreOpenLocksObjects = [];
	};
	// server disconnect
	baseEditorsApi.prototype.asc_coAuthoringDisconnect           = function()
	{
		this.CoAuthoringApi.disconnect();
		this.isCoAuthoringEnable = false;

		// Выставляем view-режим
		this.asc_setViewMode(true);
	};
	baseEditorsApi.prototype.asc_stopSaving                      = function()
	{
		this.incrementCounterLongAction();
	};
	baseEditorsApi.prototype.asc_continueSaving                  = function()
	{
		this.decrementCounterLongAction();
	};
	// SpellCheck
	baseEditorsApi.prototype.asc_SpellCheckDisconnect            = function()
	{
		if (!this.SpellCheckApi)
			return; // Error
		this.SpellCheckApi.disconnect();
		this.isSpellCheckEnable = false;
		this._spellCheckDisconnect();
	};
	baseEditorsApi.prototype._spellCheckRestart                  = function(word)
	{
	};
	baseEditorsApi.prototype._spellCheckDisconnect               = function()
	{
	};
	baseEditorsApi.prototype._coSpellCheckInit                   = function()
	{
		var t = this;

		if (!this.SpellCheckApi)
		{
			return; // Error
		}

		if (window["AscDesktopEditor"]) {

            window["asc_nativeOnSpellCheck"] = function(response) {
                var _editor = window["Asc"]["editor"] ? window["Asc"]["editor"] : window.editor;
                if (_editor.SpellCheckApi) {
                	// поверяем на сообщение о полной очистке очереди задач для текущего
                	if ("clear" === response) {
						_editor.SpellCheckApi.isRestart = false;
						return;
					}
					if (_editor.SpellCheckApi.isRestart === true)
						return;
					_editor.SpellCheckApi.onSpellCheck(response);
				}
            };

			this.SpellCheckApi.spellCheck = function (spellData) {
				window["AscDesktopEditor"]["SpellCheck"](JSON.stringify(spellData));
			};
			this.SpellCheckApi.disconnect = function () {
			};
			this.SpellCheckApi.restart = function() {
				this.isRestart = true;
				window["AscDesktopEditor"]["SpellCheck"]("clear");
			};

			if (window["AscDesktopEditor"]["IsLocalFile"] && !window["AscDesktopEditor"]["IsLocalFile"]())
			{
				let langs = AscCommon.spellcheckGetLanguages();
				let langs_array = [];
				for (let item in langs)
				{
					if (!langs.hasOwnProperty(item))
						continue;
					langs_array.push(item);
				}

				this.sendEvent('asc_onSpellCheckInit', langs_array);
			}
		} else {
			if (!this.SpellCheckUrl && !window['NATIVE_EDITOR_ENJINE']) {
				this.SpellCheckApi = {};
				this.SpellCheckApi.log = false;
				this.SpellCheckApi.worker = new CSpellchecker({
					enginePath: "../../../../sdkjs/common/spell/spell",
					dictionariesPath: "./../../../../dictionaries"
				});
				this.SpellCheckApi.worker.restartCallback = function() {
					t.asc_restartCheckSpelling();
				};
				this.SpellCheckApi.checkDictionary = function (lang) {
					if (this.log) console.log("checkDictionary: " + lang + ": " + this.worker.checkDictionary(lang));
					return this.worker.checkDictionary(lang);
				};
				this.SpellCheckApi.spellCheck = function (spellData) {
					if (this.log) {
						console.log("spellCheck:");
						console.log(spellData);
					}
					this.worker.command(spellData);
				};
				this.SpellCheckApi.worker.oncommand = function (spellData) {
					if (t.SpellCheckApi.log) {
						console.log("onSpellCheck:");
						console.log(spellData);
					}
					t.SpellCheck_CallBack(spellData);
				};
				this.SpellCheckApi.disconnect = function ()
				{
				};
				this.SpellCheckApi.restart = function() {
					this.worker.restart();
				};

				this.sendEvent('asc_onSpellCheckInit', this.SpellCheckApi.worker.getLanguages());
				return;
			}
			
			// Deprecated old scheme with server
			if (this.SpellCheckUrl && this.isSpellCheckEnable) {
				this.SpellCheckApi.set_url(this.SpellCheckUrl);
			}
		}

		this.SpellCheckApi.onInit = function (e) {
			t.sendEvent('asc_onSpellCheckInit', e);
		};
		this.SpellCheckApi.onSpellCheck = function (e) {
			t.SpellCheck_CallBack(e);
		};
		this.SpellCheckApi.init(this.documentId);
	};
    baseEditorsApi.prototype.asc_spellCheckAddToDictionary       = function(SpellCheckProperty)
    {
		var word = (typeof SpellCheckProperty === "string") ? SpellCheckProperty : SpellCheckProperty.Word;
		if (window["AscDesktopEditor"])
		{
			window["AscDesktopEditor"]["SpellCheck"]("{\"type\":\"add\",\"usrWords\":[\"" + word + "\"]}");

			this._spellCheckRestart(word);
		}
    };
    baseEditorsApi.prototype.asc_spellCheckClearDictionary       = function()
    {
    };
	baseEditorsApi.prototype.asc_restartCheckSpelling            = function()
	{
	};
	// Print Desktop
	baseEditorsApi.prototype._waitPrint                          = function (actionType, options)
	{
		return false;
	};
	baseEditorsApi.prototype._printDesktop                       = function ()
	{
	};
	// Download
	baseEditorsApi.prototype.endInsertDocumentUrls               = function()
	{
		if (this.insertDocumentUrlsData) {
			this.insertDocumentUrlsData.endCallback(this);
			this.insertDocumentUrlsData = null;
		}
	};
	baseEditorsApi.prototype._downloadAs                        = function ()
	{
	};
	baseEditorsApi.prototype.downloadAs                         = function (actionType, options)
	{
		var isCloudCrypto = !!(window["AscDesktopEditor"] && (0 < window["AscDesktopEditor"]["CryptoMode"]));
		if (isCloudCrypto)
		{
			window.isCloudCryptoDownloadAs = true;
		}
		if (this._waitPrint(actionType, options))
		{
			return;
		}

		if (actionType)
		{
			this.sync_StartAction(c_oAscAsyncActionType.BlockInteraction, actionType);
		}

		var downloadType;
		if (options.isDownloadEvent) {
			downloadType = options.oDocumentMailMerge ? DownloadType.MailMerge : (actionType === c_oAscAsyncAction.Print ? DownloadType.Print : DownloadType.Download);
		} else {
			downloadType = DownloadType.None;
		}

		var isNoBase64 = (typeof ArrayBuffer !== 'undefined') && !isCloudCrypto;
		var dataContainer = {data : null, part : null, index : 0, count : 0};
		var oAdditionalData = {};
		oAdditionalData["c"] = 'save';
		oAdditionalData["id"] = this.documentId;
		oAdditionalData["userid"] = this.documentUserId;
		oAdditionalData["tokenSession"] = this.CoAuthoringApi.get_jwt();
		oAdditionalData["outputformat"] = options.fileType;
		oAdditionalData["title"] = AscCommon.changeFileExtention(this.documentTitle, AscCommon.getExtentionByFormat(options.fileType), Asc.c_nMaxDownloadTitleLen);
		oAdditionalData["nobase64"] = isNoBase64;
		oAdditionalData["isSaveAs"] = options.isSaveAs;
		oAdditionalData["saveAsPath"] = options.wopiSaveAsPath;
		let locale = this.asc_getLocale() || undefined;
		if (typeof locale === "string") {
			locale = Asc.g_oLcidNameToIdMap[locale];
		}
		oAdditionalData["lcid"] = locale;
		if (DownloadType.Print === downloadType)
		{
			oAdditionalData["withoutPassword"] = true;
			oAdditionalData["inline"] = 1;
		}
		if (Asc.c_oAscFileType.JPG === options.fileType || Asc.c_oAscFileType.TIFF === options.fileType
			|| Asc.c_oAscFileType.TGA === options.fileType || Asc.c_oAscFileType.GIF === options.fileType
			|| Asc.c_oAscFileType.PNG === options.fileType || Asc.c_oAscFileType.EMF === options.fileType
			|| Asc.c_oAscFileType.WMF === options.fileType || Asc.c_oAscFileType.BMP === options.fileType
			|| Asc.c_oAscFileType.CR2 === options.fileType || Asc.c_oAscFileType.PCX === options.fileType
			|| Asc.c_oAscFileType.RAS === options.fileType || Asc.c_oAscFileType.PSD === options.fileType
			|| Asc.c_oAscFileType.ICO === options.fileType) {
			oAdditionalData["thumbnail"] = {
				"aspect": 2,
				"first": false
			}
			switch (options.fileType) {
				case Asc.c_oAscFileType.PNG:
					oAdditionalData["thumbnail"]["format"] = 4;
					break;
				case Asc.c_oAscFileType.GIF:
					oAdditionalData["thumbnail"]["format"] = 2;
					break;
				case Asc.c_oAscFileType.BMP:
					oAdditionalData["thumbnail"]["format"] = 1;
					break;
				default:
					oAdditionalData["thumbnail"]["format"] = 3;
					break;
			}
			oAdditionalData["outputformat"] = Asc.c_oAscFileType.IMG;
			oAdditionalData["title"] = AscCommon.changeFileExtention(this.documentTitle, "zip", Asc.c_nMaxDownloadTitleLen);

			let jsonparams = {};
			//todo convert from asc_CAdjustPrint
			jsonparams["spreadsheetLayout"] = {"ignorePrintArea": true, "scale": 100};
			jsonparams["locale"] = this.asc_getLocale();
			//todo move cmd from header to body and uncomment
			// jsonparams["translate"] = AscCommon.translateManager.mapTranslate;
			jsonparams["documentLayout"] = { "openedAt" : this.openedAt, "headingsColor" : this.headingsColor};
			if (this.watermarkDraw && this.watermarkDraw.inputContentSrc) {
				jsonparams["watermark"] = JSON.parse(this.watermarkDraw.inputContentSrc);
			}
			oAdditionalData["jsonparams"] = jsonparams;
		} else if ((Asc.c_oAscFileType.PDF === options.fileType || Asc.c_oAscFileType.PDFA === options.fileType) &&
			this.watermarkDraw && this.watermarkDraw.inputContentSrc) {
			let jsonparams = {};
			jsonparams["watermark"] = JSON.parse(this.watermarkDraw.getCorrectedInputContentSrc());
			oAdditionalData["jsonparams"] = jsonparams;
		}
		if (options.textParams && undefined !== options.textParams.asc_getAssociation()) {
			oAdditionalData["textParams"] = {"association": options.textParams.asc_getAssociation()};
		}

		if (this._downloadAs(actionType, options, oAdditionalData, dataContainer, downloadType))
		{
			return;
		}
		this._downloadAsUsingServer(actionType, options, oAdditionalData, dataContainer, downloadType);
	};
	baseEditorsApi.prototype._downloadAsUsingServer                        = function (actionType, options, oAdditionalData, dataContainer, downloadType)
	{
		var t = this;
		this.fCurCallback = null;
		if (!options.callback)
		{
			this.fCurCallback = function(input, status)
			{
				var error = 403 === status ? c_oAscError.ID.AccessDeny : c_oAscError.ID.Unknown;
				//input = {'type': command, 'status': 'err', 'data': -80};
				if (null != input && oAdditionalData["c"] === input['type'])
				{
					if ('ok' === input['status'])
					{
						var url = input['data'];
						if (url)
						{
							error = c_oAscError.ID.No;
							t.processSavedFile(url, downloadType, input["filetype"]);
						}
					}
					else
					{
						error = AscCommon.mapAscServerErrorToAscError(parseInt(input["data"]),
							(options && options.isGetTextFromUrl) ? AscCommon.c_oAscAdvancedOptionsAction.Open : AscCommon.c_oAscAdvancedOptionsAction.Save);
					}
				}
				if (c_oAscError.ID.No !== error)
				{
					t.endInsertDocumentUrls();
					t.sendEvent('asc_onError', options.errorDirect || error, c_oAscError.Level.NoCritical);
				}
				if (actionType)
				{
					t.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, actionType);
				}
			};
		}
		AscCommon.saveWithParts(function(fCallback1, oAdditionalData1, dataContainer1) {
			AscCommon.sendCommand(t, fCallback1, oAdditionalData1, dataContainer1);
		}, this.fCurCallback, options.callback, oAdditionalData, dataContainer);
	};
	baseEditorsApi.prototype._downloadOriginalFile = function (directUrl, url, fileType, token, callback)
	{
		if (directUrl) {
			AscCommon.loadFileContent(directUrl, function(resp) {
				if (resp) {
					callback(AscCommon.initStreamFromResponse(resp));
				} else {
					callback(null);
				}
			}, "arraybuffer");
		} else {
			AscCommon.DownloadOriginalFile(this.documentId, url, "", token, function(){
				callback(null);
			}, callback);
		}
	};
	baseEditorsApi.prototype.asc_generateSmartArtPreviews = function(nTypeOfSection)
	{
		return this.smartArtPreviewManager.Begin(nTypeOfSection);
	};
	// Images & Charts & TextArts
	baseEditorsApi.prototype.asc_getChartPreviews                = function(chartType, arrId, bEmpty)
	{
		return this.chartPreviewManager.getChartPreviews(chartType, arrId, bEmpty);
	};
	baseEditorsApi.prototype.asc_generateChartPreviews                = function(chartType, arrId)
	{
		return this.chartPreviewManager.Begin(chartType, arrId);
	};
	baseEditorsApi.prototype.asc_getTextArtPreviews              = function()
	{
		return this.textArtPreviewManager.getWordArtStyles();
	};
	baseEditorsApi.prototype.asc_onOpenChartFrame                = function()
	{
		if(this.isMobileVersion){
			return;
		}
		this.isOpenedChartFrame = true;
	};
	baseEditorsApi.prototype.asc_onCloseChartFrame               = function()
	{
		this.isOpenedChartFrame = false;
	};
	baseEditorsApi.prototype.asc_setInterfaceDrawImagePlaceShape = function(elementId)
	{
		this.shapeElementId = elementId;
	};
	baseEditorsApi.prototype.asc_getPropertyEditorShapes         = function()
	{
		return [AscCommon.g_oAutoShapesGroups, AscCommon.g_oAutoShapesTypes];
	};
	baseEditorsApi.prototype.asc_getPropertyEditorTextArts       = function()
	{
		return this.textArtPreviewManager.getWordArtPreviews();
	};
	baseEditorsApi.prototype.isUseOldMobileVersion       = function()
	{
		if (!this.isMobileVersion)
			return false;
		// return true for old scheme
		return false;
	};
	// Add image
	baseEditorsApi.prototype.AddImageUrl       = function(urls, imgProp, token, obj)
	{
		if (this.isLongAction()) {
			return;
		}
		var t = this;
		var toSendUrls = [];
		var toSendIndex = [];
		for (var i = 0; i < urls.length; ++i) {
			if (!AscCommon.g_oDocumentUrls.getLocal(urls[i])) {
				toSendIndex.push(i);
				toSendUrls.push(urls[i]);
			}
		}
		var callback = function(urls) {
			t._addImageUrl(urls, obj);
		};
		if (toSendUrls.length > 0) {
			AscCommon.sendImgUrls(this, toSendUrls, function(data) {
				if (data) {
					data.forEach(function(currentValue, index) {
						urls[toSendIndex[index]] = currentValue.url;
					});
					callback.call(t, urls);
				}
			}, undefined, token);
		} else {
			callback.call(this, urls);
		}
	};
	baseEditorsApi.prototype._addImageUrl                        = function()
	{
	};
	baseEditorsApi.prototype.asc_addImage                        = function(obj)
	{
		if (this.isEditOleMode)
		{
			this.oSaveObjectForAddImage = obj;
			this.sendFromFrameToGeneralEditor({
				"type": AscCommon.c_oAscFrameDataType.ShowImageDialogInFrame,
			});
			return;
		}
		var t = this;
        if (this.WordControl) // после показа диалога может не прийти mouseUp
        	this.WordControl.m_bIsMouseLock = false;
		AscCommon.ShowImageFileDialog(this.documentId, this.documentUserId, this.CoAuthoringApi.get_jwt(), this.documentShardKey, this.documentWopiSrc, this.documentUserSessionId, function(error, files)
		{
			t._uploadCallback(error, files, obj);
		}, function(error)
		{
			if (c_oAscError.ID.No !== error)
			{
				t.sendEvent("asc_onError", error, c_oAscError.Level.NoCritical);
			}
			if (obj && obj.sendUrlsToFrameEditor && t.isOpenedChartFrame)
			{
				t.sendStartUploadImageActionToFrameEditor();
			}
			obj && obj.fStartUploadImageCallback && obj.fStartUploadImageCallback();
			t.sync_StartAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.UploadImage);
		});
	};
	baseEditorsApi.prototype._uploadCallback                     = function(error, files, obj)
	{
		var t = this;
		if (c_oAscError.ID.No !== error)
		{
			this.sendEvent("asc_onError", error, c_oAscError.Level.NoCritical);
			obj && obj.fErrorCallback && obj.fErrorCallback(error);
		}
		else
		{
			if (obj && obj.sendUrlsToFrameEditor && t.isOpenedChartFrame)
			{
				this.sendStartUploadImageActionToFrameEditor();
			}
			obj && obj.fStartUploadImageCallback && obj.fStartUploadImageCallback();
			this.sync_StartAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.UploadImage);
			AscCommon.UploadImageFiles(files, this.documentId, this.documentUserId, this.CoAuthoringApi.get_jwt(), this.documentShardKey, this.documentWopiSrc, this.documentUserSessionId, function(error, urls)
			{
				if (c_oAscError.ID.No !== error)
				{
					t.sendEvent("asc_onError", error, c_oAscError.Level.NoCritical);
					obj && obj.fErrorCallback && obj.fErrorCallback(error);
				}
				else
				{
					t._addImageUrl(urls, obj);
				}
				t.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.UploadImage);
			});
		}
	};

	//метод, который подменяет callback загрузки в каждом редакторе, TODO: переделать, сделать одинаково в о всех редакторах
	baseEditorsApi.prototype.asc_replaceLoadImageCallback = function(fCallback)
	{
	};

	baseEditorsApi.prototype.asc_loadLocalImageAndAction = function(sLocalImage, fCallback)
	{
		var _loadedUrl = this.ImageLoader.LoadImage(AscCommon.getFullImageSrc2(sLocalImage), 1);
		if (_loadedUrl != null)
		    fCallback(_loadedUrl);
        else
        	this.asc_replaceLoadImageCallback(fCallback);
	};

	baseEditorsApi.prototype.asc_checkImageUrlAndAction = function(sImageUrl, fCallback)
	{
		var oThis = this;
		this.sync_StartAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.UploadImage);
		var fCallback2 = function()
		{
			oThis.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.UploadImage);
			fCallback.apply(oThis, arguments);
		};
		var sLocalImage = AscCommon.g_oDocumentUrls.getImageLocal(sImageUrl);
		if (sLocalImage)
		{
			this.asc_loadLocalImageAndAction(sLocalImage, fCallback2);
			return;
		}

		AscCommon.sendImgUrls(oThis, [sImageUrl], function(data)
		{
			if (data[0] && data[0].path != null && data[0].url !== "error")
			{
				oThis.asc_loadLocalImageAndAction(AscCommon.g_oDocumentUrls.imagePath2Local(data[0].path), fCallback2);
			}
		});
	};

	baseEditorsApi.prototype.asc_addOleObject = function(oPluginData)
	{
		if(this.isViewMode || this.isPdfEditor())
		{
			return;
		}
		let oThis      = this;
		let sImgSrc    = oPluginData["imgSrc"];
		let nWidthPix  = oPluginData["widthPix"];
		let nHeightPix = oPluginData["heightPix"];
		let fWidthMM   = oPluginData["width"];
		let fHeightMM  = oPluginData["height"];
		let sData      = oPluginData["data"];
		let sGuid      = oPluginData["guid"];
		let bSelect    = (oPluginData["select"] === true || oPluginData["select"] === false) ? oPluginData["select"] : true;
		let bPlugin    = oPluginData["plugin"] === true && !!window.g_asc_plugins;
		if (typeof sImgSrc === "string" && sImgSrc.length > 0 && typeof sData === "string"
			&& typeof sGuid === "string" && sGuid.length > 0
			/*&& AscFormat.isRealNumber(nWidthPix) && AscFormat.isRealNumber(nHeightPix)*/
			&& AscFormat.isRealNumber(fWidthMM) && AscFormat.isRealNumber(fHeightMM)
		)
		{
			if(bPlugin)
			{
				window.g_asc_plugins.setPluginMethodReturnAsync();
			}
			this.asc_checkImageUrlAndAction(sImgSrc, function(oImage)
			{
				oThis.asc_addOleObjectAction(AscCommon.g_oDocumentUrls.getImageLocal(oImage.src), sData, sGuid, fWidthMM, fHeightMM, nWidthPix, nHeightPix, bSelect);
				if(bPlugin)
				{
					window.g_asc_plugins.onPluginMethodReturn();
				}
			});
		}

	};

	baseEditorsApi.prototype.asc_editOleObject = function(oPluginData)
	{
		if(this.isViewMode || this.isPdfEditor())
		{
			return;
		}
		var oThis      = this;
		var bResize    = oPluginData["resize"];
		var sImgSrc    = oPluginData["imgSrc"];
		var oOleObject = AscCommon.g_oTableId.Get_ById(oPluginData["objectId"]);
		var nWidthPix  = oPluginData["widthPix"];
		var nHeightPix = oPluginData["heightPix"];
		var sData      = oPluginData["data"];
		var fWidthMM   = oPluginData["width"];
		var fHeightMM  = oPluginData["height"];
		if (typeof sImgSrc === "string" && sImgSrc.length > 0 && typeof sData === "string"
			&& oOleObject /*&& AscFormat.isRealNumber(nWidthPix) && AscFormat.isRealNumber(nHeightPix)*/
			&& AscFormat.isRealNumber(fWidthMM) && AscFormat.isRealNumber(fHeightMM))
		{
            this.asc_checkImageUrlAndAction(sImgSrc, function(oImage)
			{
				oThis.asc_editOleObjectAction(oOleObject, AscCommon.g_oDocumentUrls.getImageLocal(oImage.src), sData, fWidthMM, fHeightMM, nWidthPix, nHeightPix);
			});
		}
	};

	baseEditorsApi.prototype.asc_addOleObjectAction = function(sLocalUrl, sData, sApplicationId, fWidth, fHeight, nWidthPix, nHeightPix, bSelect, arrImagesForAddToHistory)
	{
	};

	baseEditorsApi.prototype.asc_editOleObjectAction = function(oOleObject, sImageUrl, sData, fWidthMM, fHeightMM, nPixWidth, nPixHeight, arrImagesForAddToHistory)
	{
	};


	baseEditorsApi.prototype.asc_startEditCurrentOleObject = function(){

	};
	baseEditorsApi.prototype.asc_canEditCrop = function()
	{
	};

	baseEditorsApi.prototype.asc_startEditCrop = function()
	{
	};

	baseEditorsApi.prototype.asc_endEditCrop = function()
	{
	};

	baseEditorsApi.prototype.asc_cropFit = function()
	{
	};

	baseEditorsApi.prototype.asc_cropFill = function()
	{
	};

	
	baseEditorsApi.prototype.asc_setShapeNames = function(oShapeNames)
	{
		if(oShapeNames !== null && typeof oShapeNames === "object")
		{
			this.shapeNames = oShapeNames;
		}
	};

	baseEditorsApi.prototype.getShapeName = function(sPreset)
	{
		var sShapeName = this.shapeNames[sPreset];
		if(typeof sShapeName !== "string" || sShapeName.length === 0)
		{
			sShapeName = "Shape";
		}
		return sShapeName;
	};

	baseEditorsApi.prototype.getGraphicController = function() {};

	baseEditorsApi.prototype.asc_canEditTableOleObject = function(bReturnOle) {
		var oController = this.getGraphicController();
		if(oController) {
			return oController.canEditTableOleObject(bReturnOle);
		}
		return bReturnOle ? null : false;
	};

	baseEditorsApi.prototype.turnOffSpecialModes = function()
	{};

	//Remove All comments
	baseEditorsApi.prototype.asc_RemoveAllComments = function(isMine, isCurrent)
	{};

	// Version History
	baseEditorsApi.prototype.asc_showRevision   = function(newObj)
	{
		if (!newObj.docId) {
			return;
		}
		if (this.isCoAuthoringEnable) {
			this.asc_coAuthoringDisconnect();
		}

		if (this.SpellCheckApi && this.SpellCheckApi.restart /* старый спеллчек (серверный - не поддеживает этот метод */)
			this.SpellCheckApi.restart();

		var bUpdate = true;
		if (null === this.VersionHistory) {
			this.VersionHistory = new window["Asc"].asc_CVersionHistory(newObj);
		} else {
			bUpdate = this.VersionHistory.update(newObj);
		}
		// ToDo должно быть все общее
		if (bUpdate) {
			this.asc_CloseFile();

			this.documentUrlChanges = this.VersionHistory.urlChanges;
			this.documentTokenChanges = this.VersionHistory.token;

			let newDocInfo = this.DocInfo.clone();
			newDocInfo.put_Id(this.VersionHistory.docId);
			newDocInfo.put_Url(this.VersionHistory.url);
			newDocInfo.put_Mode('view');
			newDocInfo.put_CoEditingMode('strict');
			newDocInfo.put_Token(this.VersionHistory.token);

			this.reopenFileWithReconnection(newDocInfo);
		} else if (this.VersionHistory.currentChangeId < newObj.currentChangeId) {
			var oApi = Asc.editor || editor;
			this.isApplyChangesOnVersionHistory = true;
			this.sync_StartAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.Open);
			// Нужно только добавить некоторые изменения
			AscCommon.CollaborativeEditing.Clear_CollaborativeMarks();
			oApi.VersionHistory.applyChanges(oApi);
			AscCommon.CollaborativeEditing.Apply_Changes();
		}
	};
	baseEditorsApi.prototype.getVersionHistory = function()
	{
		return this.VersionHistory;
	};
	baseEditorsApi.prototype.asc_refreshFile = function(docInfo) {
		this.sync_EndAction(Asc.c_oAscAsyncActionType.Information, Asc.c_oAscAsyncAction.RefreshFile, Asc.c_oAscRestrictionType.View);
		//todo always call asc_CloseFile ?
		let isInfinityLoop = this.documentIsWopi
			? docInfo.get_Wopi()["Version"] === this.DocInfo.get_Wopi()["Version"]
			&& docInfo.get_Wopi()["LastModifiedTime"] === this.DocInfo.get_Wopi()["LastModifiedTime"]
			: docInfo.get_Id() === this.DocInfo.get_Id();
		if (this.isDocumentLoadComplete) {
			this.asc_CloseFile();
		} else if (isInfinityLoop) {
			//loop protection (need backoff and retry?)
			//todo unique error
			this.sendEvent("asc_onDocumentUpdateVersion", function() {});
			// this.sendEvent('asc_onError', Asc.c_oAscError.ID.UpdateVersion, Asc.c_oAscError.Level.Critical);
			return;
		}
		this.reopenFileWithReconnection(docInfo);
	};
	baseEditorsApi.prototype.canRefreshFile = function () {
		return this.documentIsWopi || this.asc_checkNeedCallback('asc_onRequestRefreshFile');
	}
	baseEditorsApi.prototype.onRefreshFile = function () {
		let t = this;
		this.sync_StartAction(Asc.c_oAscAsyncActionType.Information, Asc.c_oAscAsyncAction.RefreshFile, Asc.c_oAscRestrictionType.View);
		if (this.documentIsWopi) {
			let callback = function (isTimeout, response) {
				if (response) {
					//todo event to simulate 'refreshFile' integrator method
					let newDocInfo = t.DocInfo.extendWithWopiParams(response);
					//send rename event
					t.CoAuthoringApi.onMeta({'title': newDocInfo.get_Title()});
					t.asc_refreshFile(newDocInfo);
				} else {
					t.sendEvent("asc_onError", c_oAscError.ID.Unknown, c_oAscError.Level.NoCritical);
				}
			};
			if (!this.CoAuthoringApi.callPRC({'type': 'wopi_RefreshFile'}, Asc.c_nCommonRequestTime, callback)) {
				callback(false, undefined);
			}
		} else {
			this.sendEvent("asc_onRequestRefreshFile");
		}
	}
	baseEditorsApi.prototype.reopenFileWithReconnection = function(docInfo) {
		this.asc_setDocInfo(docInfo);

		this.isOnLoadLicense = false;
		this.ServerIdWaitComplete = false;
		this.CoAuthoringApi.disconnect(AscCommon.c_oCloseCode.quiet);
		//create new connection because new docId can be on different shard
		this.CoAuthoringApi = new AscCommon.CDocsCoApi();
		this._coAuthoringInit();
	};
	baseEditorsApi.prototype.asc_undoAllChanges = function()
	{
	};
	baseEditorsApi.prototype.asc_getAdvancedOptions = function () {
		var cp            = {
			'codepage'  : AscCommon.c_oAscCodePageNone,
			'encodings' : AscCommon.getEncodingParams()
		};
		return new AscCommon.asc_CAdvancedOptions(cp);
	};
	baseEditorsApi.prototype.asc_Print = function (options) {
		if (window["AscDesktopEditor"] && this._printDesktop(options)) {
			return;
		}
		if (this.isLongAction()) {
			return;
		}

		if (!options) {
			options = new Asc.asc_CDownloadOptions();
		}
		options.fileType = Asc.c_oAscFileType.PDF;
		options.isPdfPrint = true;
		this.downloadAs(c_oAscAsyncAction.Print, options);
	};
	baseEditorsApi.prototype.asc_Save = function (isAutoSave, isIdle) {
		var t = this;
		var res = false;
		if (this.canSave && this._saveCheck() && this.canSendChanges()) {
			this.IsUserSave = !isAutoSave;

			if (this.asc_isDocumentCanSave()
				|| this._haveChanges()
				|| this._haveOtherChanges()
				|| this.canUnlockDocument
				|| this.forceSaveUndoRequest
				|| this.forceSaveSendFormRequest
				|| this.forceSaveDisconnectRequest
				|| this.forceSaveOformRequest) {
				if (this._prepareSave(isIdle)) {
					// Не даем пользователю сохранять, пока не закончится сохранение (если оно началось)
					this.canSave = false;
					this.CoAuthoringApi.askSaveChanges(function (e) {
						t._onSaveCallback(e);
					});
					res = true;
				}
			} else if (this.isForceSaveOnUserSave && this.IsUserSave) {
				this.forceSave();
			}
			this.checkSaveDocumentEvent(this.IsUserSave);
		}
		return res;
	};
	baseEditorsApi.prototype.checkSaveDocumentEvent = function (IsUserSave) {
		let t = this;
		if (IsUserSave && this.DocInfo && this.DocInfo.get_SupportsOnSaveDocument()) {
			if (this.isOpenOOXInBrowser && this["asc_isSupportFeature"]("ooxml")) {
				this.saveLogicDocumentToZip(undefined, undefined, function (data) {
					//slice to fix error after zip: Failed to execute 'postMessage' on 'Window': ArrayBuffer at index 0 is not detachable and could not be transferred.
					t.sendEvent('asc_onSaveDocument', data.slice());
					//AscCommon.DownloadFileFromBytes(data, t.documentTitle, AscCommon.openXml.GetMimeType(t.documentFormat));
				});
			} else {
				let opts = new Asc.asc_CDownloadOptions(t.documentFormatSave, true);
				opts.callback = function() {
					t.fCurCallback = function(res) {
						t.sync_EndAction(Asc.c_oAscAsyncActionType.BlockInteraction, Asc.c_oAscAsyncAction.DownloadAs);
						if (res.status === "ok") {
							AscCommon.loadFileContent(res.data, function (httpRequest) {
								if (httpRequest && httpRequest.response) {
									let data = new Uint8Array(httpRequest.response);
									t.sendEvent('asc_onSaveDocument', data);
									// AscCommon.DownloadFileFromBytes(data, t.documentTitle, AscCommon.openXml.GetMimeType(t.documentFormat));
								} else {
									t.sendEvent("asc_onError", c_oAscError.ID.Unknown, c_oAscError.Level.Critical);
								}
							}, "arraybuffer");
						} else {
							t.sendEvent("asc_onError", c_oAscError.ID.ConvertationSaveError, c_oAscError.Level.NoCritical);
						}
					};
				}
				t.downloadAs(Asc.c_oAscAsyncAction.DownloadAs, opts);
			}
		}
	}
	/**
	 * Эта функция возвращает true, если есть изменения или есть lock-и в документе
	 */
	baseEditorsApi.prototype.asc_isDocumentCanSave = function()
	{
		return this.isDocumentCanSave;
	};
	baseEditorsApi.prototype.asc_getCanUndo = function()
	{
		if (!this.canUndoRedoByRestrictions())
			return false;

		return AscCommon.History.Can_Undo();
	};
	baseEditorsApi.prototype.asc_getCanRedo = function()
	{
		if (!this.canUndoRedoByRestrictions())
			return false;

		return AscCommon.History.Can_Redo();
	};
	// Offline mode
	baseEditorsApi.prototype.asc_isOffline  = function()
	{
		return (window.location.protocol.indexOf("file") == 0) ? true : false;
	};
	baseEditorsApi.prototype.asc_getUrlType = function(url)
	{
		let res = AscCommon.getUrlType(url);
		//check bugs after modification: 59753, 59780
		if (window["AscDesktopEditor"] && window["AscDesktopEditor"]["IsLocalFile"]() &&
			(res === AscCommon.c_oAscUrlType.Invalid || res === AscCommon.c_oAscUrlType.Http) &&
			!(AscCommon.rx_allowedProtocols.test(url) || /^(www.)|@/i.test(url)) )
		{
			res = AscCommon.c_oAscUrlType.Unsafe;
		}
		return res;
	};
	baseEditorsApi.prototype.asc_prepareUrl = function(url)
	{
		return AscCommon.prepareUrl(url);
	};

	baseEditorsApi.prototype.openDocument  = function(file)
	{
	};
	baseEditorsApi.prototype.openDocumentFromZip  = function()
	{
	};
	baseEditorsApi.prototype.saveLogicDocumentToZip  = function(fileType, options, callback)
	{
		//todo common getLogicDocument
		let model = this.WordControl && this.WordControl.m_oLogicDocument ? this.WordControl.m_oLogicDocument : this.wb.model;
		this.saveDocumentToZip(model, this.editorId, callback, fileType, options);
	};
	baseEditorsApi.prototype.onEndLoadDocInfo = function()
	{
		if (this.isLoadFullApi && this.DocInfo)
		{
			if (this.DocInfo.get_OfflineApp())
			{
				this._openChartOrLocalDocument();
			}
			this.onEndLoadFile(null);
		}
	};
	baseEditorsApi.prototype.onEndLoadFile = function(result)
	{
		if (result)
		{
			this.openResult = result;
		}
		if (this.isLoadFullApi && this.DocInfo && this.openResult && this._isLoadedModules())
		{
			let editorId = AscCommon.getEditorBySignature(this.openResult.data);
			let isNativeFormat = AscCommon.checkNativeViewerSignature(this.openResult.data);
			if (this.isPdfEditor() ? !isNativeFormat : this.editorId !== editorId) {
				let errorData;
				switch (editorId) {
					case AscCommon.c_oEditorId.Word: errorData = 'docx';break;
					case AscCommon.c_oEditorId.Spreadsheet: errorData = 'xlsx';break;
					case AscCommon.c_oEditorId.Presentation: errorData = 'pptx';break;
					case AscCommon.c_oEditorId.Visio: errorData = 'vsdx';break;
					default:
						if (isNativeFormat) {
							errorData = 'pdf'
						}
						break;
				}
				this.sendEvent("asc_onError", c_oAscError.ID.ConvertationOpenFormat, c_oAscError.Level.Critical, errorData);
				return;
			}
			if (this.VersionHistory && this.VersionHistory.documentSha256) {
				let sha256 = AscCommon.Digest.sha256(this.openResult.data, 0, this.openResult.data.length);
				if (this.VersionHistory.documentSha256 !== AscCommon.Hex.encode(sha256) ) {
					this.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.Open);
					this.sendEvent("asc_onError", c_oAscError.ID.DocumentAndChangeMismatch, c_oAscError.Level.Critical);
					return;
				}
			}

			this.openDocument(this.openResult);
			this.sendEvent("asc_onDocumentPassword", ("" !== this.currentPassword));
			this.openResult = null;
		}

	};
	baseEditorsApi.prototype._onEndLoadSdk = function()
	{
		AscCommon.g_oTableId.init(this);
		this.initCollaborativeEditing();

		// init drag&drop
		var t = this;
		AscCommon.InitDragAndDrop(this.HtmlElement, function(error, files)
		{
			t._uploadCallback(error, files);
		});

		AscFonts.g_fontApplication.Init();

		this.FontLoader  = AscCommon.g_font_loader;
		this.ImageLoader = AscCommon.g_image_loader;
		this.FontLoader.put_Api(this);
		this.ImageLoader.put_Api(this);

		this.chartPreviewManager   = new AscCommon.ChartPreviewManager();
		this.smartArtPreviewManager   = new AscCommon.SmartArtPreviewDrawer();
		this.textArtPreviewManager = new AscCommon.TextArtPreviewManager();

		AscFormat.initStyleManager();

		if (null !== this.tmpFocus)
		{
			this.asc_enableKeyEvents(this.tmpFocus);
		}

		this.pluginsManager     = Asc.createPluginsManager(this);

		this.macros = new AscCommon.CDocumentMacros();

		this._loadSdkImages();

		this.checkDocumentTitleFonts();
	};
	baseEditorsApi.prototype.initCollaborativeEditing = function()
	{
	};
	baseEditorsApi.prototype.checkDocumentTitleFonts = function() {
		if (!AscFonts.FontPickerByCharacter || !this.documentTitle)
			return;
		
		AscFonts.FontPickerByCharacter.getFontsByString(this.documentTitle);
	};
	baseEditorsApi.prototype._loadSdkImages = function ()
	{
	};

	baseEditorsApi.prototype.sendStandartTextures = function()
	{
	    if (this.isSendStandartTextures)
	        return;

	    this.isSendStandartTextures = true;

		var _count = AscCommon.g_oUserTexturePresets.length;
		var arr    = new Array(_count);
		var arrToDownload = [];
		for (var i = 0; i < _count; ++i)
		{
			arr[i]       = new AscCommon.asc_CTexture();
			arr[i].Id    = i;
			arr[i].Image = AscCommon.g_oUserTexturePresets[i];
			arrToDownload.push(AscCommon.g_oUserTexturePresets[i]);
		}
		if(this.editorId === c_oEditorId.Word)
		{
			arrToDownload.push(AscCommon.g_sWordPlaceholderImage);
			arrToDownload.push(AscCommon.g_sWordPlaceholderFormImage);
		}
		this.ImageLoader.LoadImagesWithCallback(arrToDownload, function () {

		}, 0, true);

		this.sendEvent('asc_onInitStandartTextures', arr);
	};

	baseEditorsApi.prototype.sendMathToMenu = function ()
	{
		if (this.MathMenuLoad)
			return;
		// GENERATE_IMAGES
		//var _MathPainter = new CMathPainter(this.m_oWordControl.m_oApi);
		//_MathPainter.StartLoad();
		//return;
		var _MathPainter = new AscFormat.CMathPainter(this);
		_MathPainter.Generate();
		this.MathMenuLoad = true;
	};

	baseEditorsApi.prototype.sendMathTypesToMenu         = function(_math)
	{
		this.sendEvent("asc_onMathTypes", _math);
	};

	baseEditorsApi.prototype.asyncFontEndLoaded_MathDraw = function(Obj)
	{
		this.sync_EndAction(c_oAscAsyncActionType.Information, c_oAscAsyncAction.LoadFont);
		Obj.Generate2();
	};

	baseEditorsApi.prototype.getCurrentColorScheme = function()
	{
		var oTheme = this.getCurrentTheme();
		return oTheme && oTheme.themeElements && oTheme.themeElements.clrScheme;
	};


	baseEditorsApi.prototype.asc_GetCurrentColorSchemeName = function()
	{
		var oClrScheme = this.getCurrentColorScheme();
		if(oClrScheme && typeof oClrScheme.name === "string")
		{
			return oClrScheme.name;
		}
		return "";
	};

	baseEditorsApi.prototype.asc_GetCurrentColorSchemeIndex = function()
	{
		var oTheme = this.getCurrentTheme();
		if(!oTheme)
		{
			return -1;
		}
		return this.getColorSchemes(oTheme).index;
	};

	baseEditorsApi.prototype.getCurrentTheme = function()
	{
		return null;
	};

	baseEditorsApi.prototype.getColorSchemes = function(theme)
	{
		var result = AscCommon.g_oUserColorScheme.slice();
		// theme colors
		var asc_color_scheme, _scheme, i;
		var aCustomSchemes = theme.getExtraAscColorSchemes();
		_scheme = theme.themeElements && theme.themeElements.clrScheme;
		var nIndex = -1;
		if(_scheme) {
			asc_color_scheme = AscCommon.getAscColorScheme(_scheme, theme);
			nIndex = AscCommon.getIndexColorSchemeInArray(result, asc_color_scheme);
			if(nIndex === -1) {
				var nIdxInCustom = AscCommon.getIndexColorSchemeInArray(aCustomSchemes, asc_color_scheme);
				if(nIdxInCustom === -1) {
					aCustomSchemes.push(asc_color_scheme);
				}
			}
			aCustomSchemes.sort(function (a, b) {
				if(a.name === "" || a.name === null) return -1;
				if(b.name === "" || b.name === null) return 1;
				if(a.name > b.name)
				{
					return 1;
				}
				if(a.name < b.name)
				{
					return -1;
				}
				return 0;
			});

			result = result.concat(aCustomSchemes);

			if(nIndex === -1) {
				nIndex = AscCommon.getIndexColorSchemeInArray(result, asc_color_scheme);
			}
		}
		return {schemes: result, index: nIndex};
	};

	baseEditorsApi.prototype.getColorSchemeByIdx = function(nIdx)
	{
		var scheme = AscCommon.getColorSchemeByIdx(nIdx);
		if(!scheme) {
			var oSchemes = this.getColorSchemes(this.getCurrentTheme());
			var oAscScheme = oSchemes.schemes[nIdx];
			scheme = oAscScheme && oAscScheme.scheme;
		}
		return scheme;
	};


	baseEditorsApi.prototype.sendColorThemes = function (theme)
	{
		this.sendEvent("asc_onSendThemeColorSchemes", this.getColorSchemes(theme).schemes);
	};


	baseEditorsApi.prototype.showVideoControl = function(sMediaName, extX, extY, transform)
	{
		if (!window["AscDesktopEditor"] || !window["AscDesktopEditor"]["MediaStart"])
			return;

		switch (this.editorId)
		{
			case c_oEditorId.Word:
			{
				break;
			}
			case c_oEditorId.Presentation:
			{
                var manager = this.WordControl.DemonstrationManager;
                if (!manager.Mode)
                {
                    var pos = this.WordControl.m_oDrawingDocument.ConvertCoordsToCursorWR(0, 0, this.WordControl.m_oLogicDocument.CurPage, null, true);
                    pos.X += this.WordControl.X;
                    pos.Y += this.WordControl.Y;

					var zoom = AscCommon.g_dKoef_mm_to_pix * this.WordControl.m_nZoomValue / 100;

                    if (!transform)
                        window["AscDesktopEditor"]["MediaStart"](sMediaName, pos.X >> 0, pos.Y >> 0, extX, extY, zoom);
                    else
                        window["AscDesktopEditor"]["MediaStart"](sMediaName, pos.X >> 0, pos.Y >> 0, extX, extY, zoom, transform.sx, transform.shy, transform.shx, transform.sy, transform.tx, transform.ty);
                }
                else
				{
					var transition = this.WordControl.DemonstrationManager.Transition;
                    if ((manager.SlideNum >= 0 && manager.SlideNum < this.WordControl.GetSlidesCount()) && (!transition || !transition.IsPlaying()))
                    {
						var _x = (transition.Rect.x / AscCommon.AscBrowser.retinaPixelRatio) >> 0;
						var _y = (transition.Rect.y / AscCommon.AscBrowser.retinaPixelRatio) >> 0;
                        var _w = transition.Rect.w / AscCommon.AscBrowser.retinaPixelRatio;
                        var _h = transition.Rect.h / AscCommon.AscBrowser.retinaPixelRatio;

                        var _w_mm = manager.HtmlPage.m_oLogicDocument.GetWidthMM();
                        var _h_mm = manager.HtmlPage.m_oLogicDocument.GetHeightMM();

                        if (this.isReporterMode)
						{
                            _x += ((this.WordControl.m_oMainParent.AbsolutePosition.L * AscCommon.g_dKoef_mm_to_pix) >> 0);
						}

                        var zoom = _w / _w_mm;

                        if (!transform)
                            window["AscDesktopEditor"]["MediaStart"](sMediaName, _x >> 0, _y >> 0, extX, extY, zoom);
                        else
                            window["AscDesktopEditor"]["MediaStart"](sMediaName, _x >> 0, _y >> 0, extX, extY, zoom, transform.sx, transform.shy, transform.shx, transform.sy, transform.tx, transform.ty);
                    }

				}
				break;
			}
            case c_oEditorId.Spreadsheet:
            {
                break;
            }
		}
	};
	baseEditorsApi.prototype.hideMediaControl = function()
	{

		if(this.mediaData)
		{
			this.callMediaPlayerCommand("hideMediaControl", null);
		}
	};
	baseEditorsApi.prototype.asc_hideMediaControl = function()
	{
		this.hideMediaControl();
	};


	baseEditorsApi.prototype.asc_onMediaPlayerEvent = function(evt, mediaData)
	{

	};
	baseEditorsApi.prototype.getMediaData = function()
	{
		if(this.mediaData && !this.mediaData.isValid())
			this.mediaData = null;
		return this.mediaData;
	};

	baseEditorsApi.prototype.getPlayerData = function (sCmd)
	{
		if(!sCmd) return null;
		if(!this.mediaData) return {"Cmd": sCmd};

		let oPlayerData = null;
		switch (this.editorId)
		{
			case c_oEditorId.Word:
			{
				break;
			}
			case c_oEditorId.Presentation:
			{
				oPlayerData = this.WordControl.GetMediaPlayerData(this.mediaData);

				break;
			}
			case c_oEditorId.Spreadsheet:
			{
				break;
			}
		}

		if(oPlayerData)
		{
			let sCmd_ = sCmd;
			if(sCmd.startsWith("playFrom") === 0)
			{
				sCmd_ = "play";
				oPlayerData["Cmd"] = "play";
			}
			oPlayerData["Cmd"] = sCmd_;
		}
		return oPlayerData;
	};

	baseEditorsApi.prototype.onUpdateMediaPlayer = function()
	{
		if(this.mediaData)
		{
			this.callMediaPlayerCommand("update", this.mediaData);
		}
	};
	baseEditorsApi.prototype.callMediaPlayerCommand = function(sCmd, oMediaData)
	{
		this.mediaData = oMediaData;
		if(!sCmd) return;
		if (window["AscDesktopEditor"] && window["AscDesktopEditor"]["CallMediaPlayerCommand"])
		{
			let oData = this.getPlayerData(sCmd);
			if(!AscFormat.IsEqualObjects(this.lastPlCompareOayerData, oData))
			{
				window["AscDesktopEditor"]["CallMediaPlayerCommand"](oData);
				this.lastPlCompareOayerData = oData;
			}
		}
	};

	baseEditorsApi.prototype.isDrawSlideshowAnnotations = function()
	{
		return false;
	};

	// plugins
	baseEditorsApi.prototype._checkLicenseApiFunctions   = function()
	{
		return this.licenseResult && true === this.licenseResult['plugins'];
	};

	baseEditorsApi.prototype.asc_pluginsRegister   = function(basePath, plugins)
	{
		if (null != this.pluginsManager)
		{
			let runnedArray = [];
			this.pluginsManager.register(basePath, plugins, undefined, runnedArray);
			this.checkInstalledPlugins();

			for (let i = 0, len = runnedArray.length; i < len; i++)
			{
				if (!this.pluginsManager.isRunned(runnedArray[i]))
					this.pluginsManager.run(runnedArray[i], 0, "");
			}
		}
		else
		{
			this.preSetupPlugins = {
				path : basePath,
				plugins : plugins
			};
		}
	};
	baseEditorsApi.prototype.asc_pluginRun         = function(guid, variation, pluginData)
	{
		if (null != this.pluginsManager)
			this.pluginsManager.run(guid, variation, pluginData);
	};
	baseEditorsApi.prototype.asc_pluginStop        = function(guid)
	{
		if (null != this.pluginsManager)
			this.pluginsManager.close(guid);
	};
	baseEditorsApi.prototype.asc_pluginResize      = function(pluginData)
	{
		if (null != this.pluginsManager)
			this.pluginsManager.runResize(pluginData);
	};
	baseEditorsApi.prototype.asc_pluginButtonClick = function(id, guid, windowId)
	{
		if (null != this.pluginsManager)
			this.pluginsManager.buttonClick(id, guid, windowId);
	};
	baseEditorsApi.prototype.asc_pluginButtonDockChanged = function(type, guid, windowId, callback)
	{
		if (null != this.pluginsManager)
			this.pluginsManager.onPluginWindowDockChanged(type, guid, windowId, callback);
	};

	baseEditorsApi.prototype.asc_pluginEnableMouseEvents = function(isEnable)
	{
		if (!this.pluginsManager)
			return;

		this.pluginsManager.onEnableMouseEvents(isEnable);
	};

    baseEditorsApi.prototype.isEnabledDropTarget = function()
    {
    	return true;
    };
    baseEditorsApi.prototype.beginInlineDropTarget = function(e)
    {
    };
    baseEditorsApi.prototype.endInlineDropTarget = function(e)
    {
    };
    baseEditorsApi.prototype.isSliderDragged = function()
    {
		return this.noCreatePoint || this.exucuteHistory || this.exucuteHistoryEnd;
    };

    baseEditorsApi.prototype["asc_insertSymbol"] = function(familyName, code, pr)
    {
		var arrCharCodes = [code];
        AscFonts.FontPickerByCharacter.checkTextLight(arrCharCodes, true);

        var fonts = [new AscFonts.CFont(AscFonts.g_fontApplication.GetFontInfoName(familyName))];
        AscFonts.FontPickerByCharacter.extendFonts(fonts);

        this.asyncMethodCallback = function() {

            switch (this.editorId)
            {
                case c_oEditorId.Word:
                case c_oEditorId.Presentation:
                {
                	if (pr && c_oEditorId.Word === this.editorId)
					{
						this.WordControl.m_oLogicDocument.AddSpecialSymbol(pr);
					}
                	else
					{
						var textPr = new AscCommonWord.CTextPr();
						textPr.SetFontFamily(familyName);

						let settings = new AscCommon.CAddTextSettings();
						settings.SetTextPr(textPr);
						settings.MoveCursorOutside(true);

						this.WordControl.m_oLogicDocument.AddTextWithPr(new AscCommon.CUnicodeStringEmulator(arrCharCodes), settings);
					}
                    break;
                }
                case c_oEditorId.Spreadsheet:
                {
                	this.AddTextWithPr(familyName, arrCharCodes);
                    break;
                }
            }
        };

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

        AscCommon.g_font_loader.LoadDocumentFonts2(fonts);
    };

    baseEditorsApi.prototype["asc_registerPlaceholderCallback"] = function(nType, fCallback)
    {
		const oDrawingDocument = this.getDrawingDocument();
    	if (oDrawingDocument && oDrawingDocument.placeholders)
		{
			oDrawingDocument.placeholders.registerCallback(nType, fCallback);
		}
    };
    baseEditorsApi.prototype["asc_uncheckPlaceholders"] = function()
    {
        if (this.WordControl && this.WordControl.m_oDrawingDocument && this.WordControl.m_oDrawingDocument.placeholders)
        {
            this.WordControl.m_oDrawingDocument.placeholders.closeAllActive();
        }
    };

    // Builder
	baseEditorsApi.prototype.asc_nativeInitBuilder = function()
	{
		AscCommon.History.TurnOffChanges();
		this.asc_setDocInfo(new Asc.asc_CDocInfo());
	};
	baseEditorsApi.prototype.asc_SetSilentMode     = function()
	{
	};
	baseEditorsApi.prototype.asc_canPaste          = function()
	{
		return false;
	};
	baseEditorsApi.prototype.asc_Recalculate       = function()
	{
	};
	baseEditorsApi.prototype.canRunBuilderScript = function()
	{
		return this.asc_canPaste();
	};
	baseEditorsApi.prototype.onEndBuilderScript = function(callback)
	{
		let _t = this;
		this.loadBuilderFonts(function()
		{
			return _t._onEndBuilderScript(callback);
		});
		
		return true;
	};
	baseEditorsApi.prototype.addBuilderFont = function(fontName)
	{
		this.builderFonts[fontName] = true;
	};
	baseEditorsApi.prototype.loadBuilderFonts = function(callback)
	{
		let _t = this;
		this.incrementCounterLongAction();
		AscCommon.g_font_loader.LoadFonts(this.builderFonts, function(){
			_t.decrementCounterLongAction();
			callback();
		});
		this.builderFonts = {};
	};
	baseEditorsApi.prototype._onEndBuilderScript = function(callback)
	{
		// This method is intended to be overridden
		if (callback)
			callback(true);
		
		return true;
	};

	// Native
	baseEditorsApi.prototype['asc_nativeCheckPdfRenderer'] = function (_memory1, _memory2) {
		if (true) {
			// pos не должен минимизироваться!!!

			_memory1.Copy = _memory1["Copy"];
			_memory1.ClearNoAttack = _memory1["ClearNoAttack"];
			_memory1.WriteByte = _memory1["WriteByte"];
			_memory1.WriteBool = _memory1["WriteBool"];
			_memory1.WriteLong = _memory1["WriteLong"];
			_memory1.WriteDouble = _memory1["WriteDouble"];
			_memory1.WriteString = _memory1["WriteString"];
			_memory1.WriteString2 = _memory1["WriteString2"];

			_memory2.Copy = _memory1["Copy"];
			_memory2.ClearNoAttack = _memory1["ClearNoAttack"];
			_memory2.WriteByte = _memory1["WriteByte"];
			_memory2.WriteBool = _memory1["WriteBool"];
			_memory2.WriteLong = _memory1["WriteLong"];
			_memory2.WriteDouble = _memory1["WriteDouble"];
			_memory2.WriteString = _memory1["WriteString"];
			_memory2.WriteString2 = _memory1["WriteString2"];
		}

		var _printer = new AscCommon.CDocumentRenderer();
		_printer.Memory = _memory1;
		_printer.VectorMemoryForPrint = _memory2;
		return _printer;
	};

	// input
	baseEditorsApi.prototype.Begin_CompositeInput = function()
	{
	};
	baseEditorsApi.prototype.Add_CompositeText = function(nCharCode)
	{
	};
	baseEditorsApi.prototype.Remove_CompositeText = function(nCount)
	{
	};
	baseEditorsApi.prototype.Replace_CompositeText = function(arrCharCodes)
	{
	};
	baseEditorsApi.prototype.Set_CursorPosInCompositeText = function(nPos)
	{
	};
	baseEditorsApi.prototype.Get_CursorPosInCompositeText = function()
	{
	};
	baseEditorsApi.prototype.End_CompositeInput = function()
	{
	};
	baseEditorsApi.prototype.Get_MaxCursorPosInCompositeText = function()
	{
	};
	baseEditorsApi.prototype.Input_UpdatePos = function()
	{
	};
	baseEditorsApi.prototype["setInputParams"] = function(_obj)
	{
		window["AscInputMethod"] = window["AscInputMethod"] || {};

		for (var _prop in _obj)
		{
			window["AscInputMethod"][_prop] = _obj[_prop];
		}
	};
	baseEditorsApi.prototype.asc_getInputLanguage = function()
	{
		return lcid_enUS;
	};

	baseEditorsApi.prototype.asc_addSignatureLine = function (oPr, Width, Height, sImgUrl) {

    };
	baseEditorsApi.prototype.asc_getAllSignatures = function () {
		return [];
	};

	baseEditorsApi.prototype.asc_CallSignatureDblClickEvent = function(sGuid){

	};

	// signatures
	baseEditorsApi.prototype.asc_AddSignatureLine2 = function(_obj)
	{
		var _w = 50;
		var _h = 50;
		var _w_pix = (_w * AscCommon.g_dKoef_mm_to_pix) >> 0;
		var _h_pix = (_h * AscCommon.g_dKoef_mm_to_pix) >> 0;
		var _canvas = document.createElement("canvas");
		_canvas.width = _w_pix;
		_canvas.height = _h_pix;
		var _ctx = _canvas.getContext("2d");
		_ctx.fillStyle = "#000000";
		_ctx.strokeStyle = "#000000";
		_ctx.font = "10pt 'Courier New'";
		_ctx.lineWidth = 3;

		_ctx.beginPath();
		var _y_line = (_h_pix >> 1) + 0.5;
		_ctx.moveTo(0, _y_line);
		_ctx.lineTo(_w_pix, _y_line);
		_ctx.stroke();
		_ctx.beginPath();

		_ctx.lineWidth = 2;
		_y_line -= 10;
		_ctx.moveTo(10, _y_line);
		_ctx.lineTo(25, _y_line - 10);
		_ctx.lineTo(10, _y_line - 20);
		_ctx.stroke();
		_ctx.beginPath();

		_ctx.fillText(_obj.asc_getSigner1(), 10, _y_line + 25);
		_ctx.fillText(_obj.asc_getSigner2(), 10, _y_line + 40);
		_ctx.fillText(_obj.asc_getEmail(), 10, _y_line + 55);

		var _url = _canvas.toDataURL("image/png");
		_canvas = null;

		var _args = [];

		this.ImageLoader.LoadImagesWithCallback([_url], function() {
			this.asc_addSignatureLine(_obj, _w, _h, _url);
		}, _args);
	};

	baseEditorsApi.prototype.asc_getRequestSignatures = function()
	{
		var _sigs = this.asc_getAllSignatures();
		var _sigs_ret = [];

		var _found;
		for (var i = _sigs.length - 1; i >= 0; i--)
		{
			var _sig = _sigs[i];
			_found = false;

			for (var j = this.signatures.length - 1; j >= 0; j--)
			{
				if (this.signatures[j].guid == _sig.id)
				{
					_found = true;
					break;
				}
			}

			if (!_found)
			{
				var _add_sig = new AscCommon.asc_CSignatureLine();
				_add_sig.guid = _sig.id;
				_add_sig.signer1 = _sig.signer;
				_add_sig.signer2 = _sig.signer2;
				_add_sig.email = _sig.email;
				_add_sig.showDate = _sig.showDate;
				_add_sig.instructions = _sig.instructions;

				_sigs_ret.push(_add_sig);
			}
		}

		return _sigs_ret;
	};

	baseEditorsApi.prototype.asc_Sign = function(id, guid, url1, url2)
	{
		if (window["AscDesktopEditor"] && !this.isRestrictionView())
			window["AscDesktopEditor"]["Sign"](id, guid, url1, url2);
	};
	baseEditorsApi.prototype.asc_RequestSign = function(guid)
	{
		var signGuid = (guid == "unvisibleAdd") ? AscCommon.CreateGUID() : guid;

		if (window["asc_LocalRequestSign"])
			window["asc_LocalRequestSign"](signGuid);
	};

	baseEditorsApi.prototype.asc_ViewCertificate = function(id)
	{
		if (window["AscDesktopEditor"])
			window["AscDesktopEditor"]["ViewCertificate"](parseInt("" + id)); // integer or string!
	};

	baseEditorsApi.prototype.asc_SelectCertificate = function()
	{
		if (window["AscDesktopEditor"])
			window["AscDesktopEditor"]["SelectCertificate"]();
	};

	baseEditorsApi.prototype.asc_GetDefaultCertificate = function()
	{
		if (window["AscDesktopEditor"])
			window["AscDesktopEditor"]["GetDefaultCertificate"]();
	};

	baseEditorsApi.prototype.asc_getSignatures = function()
	{
		return this.signatures;
	};

	baseEditorsApi.prototype.asc_RemoveSignature = function(guid)
	{
		if (window["AscDesktopEditor"])
			window["AscDesktopEditor"]["RemoveSignature"](guid);
	};

	baseEditorsApi.prototype.asc_RemoveAllSignatures = function()
	{
		if (window["AscDesktopEditor"])
			window["AscDesktopEditor"]["RemoveAllSignatures"]();
	};

	baseEditorsApi.prototype.asc_isSignaturesSupport = function()
	{
		if (window["AscDesktopEditor"] && window["AscDesktopEditor"]["IsSignaturesSupport"])
			return window["AscDesktopEditor"]["IsSignaturesSupport"]();
		return false;
	};
    baseEditorsApi.prototype.asc_isProtectionSupport = function()
    {
        if (window["AscDesktopEditor"] && window["AscDesktopEditor"]["IsProtectionSupport"])
            return window["AscDesktopEditor"]["IsProtectionSupport"]();
        return !(this.DocInfo && this.DocInfo.get_OfflineApp()) && this.isProtectionSupport;
    };
	baseEditorsApi.prototype.asc_isAnonymousSupport = function()
	{
		return this.isAnonymousSupport;
	};

	baseEditorsApi.prototype.asc_gotoSignature = function(guid)
	{
		if (window["AscDesktopEditor"] && window["asc_IsVisibleSign"] && window["asc_IsVisibleSign"](guid))
		{
			this.gotoSignatureInternal(guid);
		}
	};
	baseEditorsApi.prototype.gotoSignatureInternal = function(guid)
	{
	};

	baseEditorsApi.prototype.asc_getSignatureSetup = function(guid)
	{
		var _sigs = this.asc_getAllSignatures();

		for (var i = _sigs.length - 1; i >= 0; i--)
		{
			var _sig = _sigs[i];
			if (_sig.id == guid)
			{
				var _add_sig = new AscCommon.asc_CSignatureLine();
				_add_sig.guid = _sig.id;
				_add_sig.signer1 = _sig.signer;
				_add_sig.signer2 = _sig.signer2;
				_add_sig.email = _sig.email;
				_add_sig.showDate = _sig.showDate;
				_add_sig.instructions = _sig.instructions;

				_add_sig.isrequested = true;
				for (var j = 0; j < this.signatures.length; j++)
				{
					var signDoc = this.signatures[j];
					if (signDoc.guid == _add_sig.guid)
					{
						_add_sig.valid = signDoc.valid;
						_add_sig.isrequested = false;
						break;
					}
				}

				return _add_sig;
			}
		}

		return null;
	};

	baseEditorsApi.prototype.asc_getSignatureImage = function (sGuid) {

		var count = this.signatures.length;
		for (var i = 0; i < count; i++)
		{
			if (this.signatures[i].guid == sGuid)
				return this.signatures[i].image;
		}
		return "";
    };

	baseEditorsApi.prototype.asc_getSessionToken = function () {
		return this.CoAuthoringApi.get_jwt()
	};

	baseEditorsApi.prototype.asc_InputClearKeyboardElement = function()
	{
		if (AscCommon.g_inputContext)
			AscCommon.g_inputContext.nativeFocusElement = null;
	};

    // input helper
    baseEditorsApi.prototype.getTargetOnBodyCoords = function()
    {
        var ret = { X : 0, Y : 0, W : 0, H : 0, TargetH : 0 };
        ret.W = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
        ret.H = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);

        switch (this.editorId)
        {
            case c_oEditorId.Word:
            {
                ret.X += this.WordControl.X;
                ret.Y += this.WordControl.Y;
                ret.X += (this.WordControl.m_oMainView.AbsolutePosition.L * AscCommon.g_dKoef_mm_to_pix);
                ret.Y += (this.WordControl.m_oMainView.AbsolutePosition.T * AscCommon.g_dKoef_mm_to_pix);
                ret.X += (this.WordControl.m_oDrawingDocument.TargetHtmlElementLeft);
                ret.Y += (this.WordControl.m_oDrawingDocument.TargetHtmlElementTop);

                ret.X >>= 0;
                ret.Y >>= 0;

                ret.TargetH = (this.WordControl.m_oDrawingDocument.m_dTargetSize * this.WordControl.m_nZoomValue * AscCommon.g_dKoef_mm_to_pix / 100) >> 0;
                break;
            }
            case c_oEditorId.Presentation:
            {
                ret.X += this.WordControl.X;
                ret.Y += this.WordControl.Y;

                ret.X += (this.WordControl.m_oMainParent.AbsolutePosition.L * AscCommon.g_dKoef_mm_to_pix);

                if (!this.WordControl.m_oLogicDocument.IsFocusOnNotes())
                {
                    ret.Y += (this.WordControl.m_oMainView.AbsolutePosition.T * AscCommon.g_dKoef_mm_to_pix);
                }
                else
                {
                    ret.Y += (this.WordControl.m_oNotesContainer.AbsolutePosition.T * AscCommon.g_dKoef_mm_to_pix);
                }

                ret.X += (this.WordControl.m_oDrawingDocument.TargetHtmlElementLeft);
                ret.Y += (this.WordControl.m_oDrawingDocument.TargetHtmlElementTop);

                ret.X >>= 0;
                ret.Y >>= 0;

                ret.TargetH = (this.WordControl.m_oDrawingDocument.m_dTargetSize * this.WordControl.m_nZoomValue * AscCommon.g_dKoef_mm_to_pix / 100) >> 0;
                break;
            }
            case c_oEditorId.Spreadsheet:
            {
                var off, selectionType = this.asc_getCellInfo().asc_getSelectionType();
                if (this.asc_getCellEditMode())
                {
                    // cell edit
                    var cellEditor = this.wb.cellEditor;
                    ret.X = cellEditor.curLeft;
                    ret.Y = cellEditor.curTop;
                    ret.TargetH = cellEditor.curHeight;
                    off = cellEditor.cursor;
                }
                else if (Asc.c_oAscSelectionType.RangeShapeText === selectionType ||
                    Asc.c_oAscSelectionType.RangeChartText === selectionType)
                {
                    // shape target
                    var drDoc = this.wb.getWorksheet().objectRender.controller.drawingDocument;
                    ret.X = drDoc.TargetHtmlElementLeft;
                    ret.Y = drDoc.TargetHtmlElementTop;
                    ret.TargetH = drDoc.m_dTargetSize * this.asc_getZoom() * AscCommon.g_dKoef_mm_to_pix;
                    off = this.HtmlElement;
                }

                if (off) {
                    off = jQuery(off).offset();
                    if (off)
                    {
                        ret.X += off.left;
                        ret.Y += off.top;
                    }
                }

                ret.X >>= 0;
                ret.Y >>= 0;
                ret.TargetH >>= 0;
                break;
            }
        }
        return ret;
    };

	baseEditorsApi.prototype.onKeyDown = function(e)
	{
	};
	baseEditorsApi.prototype.onKeyPress = function(e)
	{
	};
	baseEditorsApi.prototype.onKeyUp = function(e)
	{
	};
	/**
	 * Получаем текст (в виде массива юникодных значений), который будет добавлен на ивенте KeyDown
	 * @param e
	 * @returns {Number[]}
	 */
	baseEditorsApi.prototype.getAddedTextOnKeyDown = function(e)
	{
		return [];
	};
	baseEditorsApi.prototype.pre_Paste = function(_fonts, _images, callback)
	{
	};

	baseEditorsApi.prototype.asc_Remove = function()
	{
		if (AscCommon.g_inputContext)
			AscCommon.g_inputContext.emulateKeyDownApi(46);
	};

	// System input
	baseEditorsApi.prototype.SetTextBoxInputMode = function(bIsEnable)
	{
		AscCommon.TextBoxInputMode = bIsEnable;
		if (AscCommon.g_inputContext)
			AscCommon.g_inputContext.systemInputEnable(AscCommon.TextBoxInputMode);
	};
	baseEditorsApi.prototype.GetTextBoxInputMode = function()
	{
		return AscCommon.TextBoxInputMode;
	};

	baseEditorsApi.prototype.asc_OnHideContextMenu = function()
	{
	};
	baseEditorsApi.prototype.asc_OnShowContextMenu = function()
	{
	};

	baseEditorsApi.prototype.isIdle = function()
	{
		// пока не стартовали - считаем работаем
		if (0 == this.lastWorkTime)
			return 0;

		// если плагин работает - то и мы тоже
		if (this.pluginsManager && this.pluginsManager.isWorked())
			return 0;

		if (this.isEmbedVersion)
			return 0;

		if (!this.canSave || !this._saveCheck())
			return 0;

		//viewer
		if (this.isViewMode || this.isPdfViewer)
			return 0;

		return new Date().getTime() - this.lastWorkTime;
	};
	baseEditorsApi.prototype.waitNotIdle = function (lastWorkTime, callback)
	{
		let t = this;
		//todo remove first timeout
		//start with timeout to aviod lastWorkTime update on:
		//onDisconnect -> asc_setRestriction -> checkLastWork and CheckTargetUpdate -> checkLastWork
		setTimeout(function () {
			if (undefined === lastWorkTime) {
				lastWorkTime = t.getLastWork();
			}
			if (lastWorkTime < t.getLastWork()) {
				callback();
			} else {
				t.waitNotIdle(lastWorkTime, callback);
			}
		}, 100);
	}

	baseEditorsApi.prototype.checkInterfaceElementBlur = function()
	{
		if (!document.activeElement || !document.createEvent || (document.activeElement.id === "area_id"))
			return;

		if (!document.activeElement.dispatchEvent)
			return;

		var e = document.createEvent("HTMLEvents");
		e.initEvent("blur", true, true);
		e.eventName = "blur";
		document.activeElement.dispatchEvent(e);
	};


	baseEditorsApi.prototype.getLastWork = function()
	{
		return this.lastWorkTime;
	};
	baseEditorsApi.prototype.checkLastWork = function()
	{
		this.lastWorkTime = new Date().getTime();
	};

	baseEditorsApi.prototype.setViewModeDisconnect = function(enableDownload)
	{
		// Посылаем наверх эвент об отключении от сервера
		this.sendEvent('asc_onCoAuthoringDisconnect', enableDownload);
		// И переходим в режим просмотра т.к. мы не можем сохранить файл
		this.asc_setViewMode(true);
	};

	baseEditorsApi.prototype.asc_setCurrentPassword = function(password)
	{
		this.currentPasswordOld = this.currentPassword;
		this.currentPassword = password;
		this.asc_Save(false, undefined, true);
		if (!(this.DocInfo && this.DocInfo.get_OfflineApp()) && !this.isViewMode && !this.isPdfViewer) {
			var rData = {
				"c": 'setpassword',
				"id": this.documentId,
				"password": password
			};
			var t            = this;
			t.fCurCallback   = function(input)
			{
				if (null != input && "setpassword" == input["type"])
				{
					if ('ok' === input["status"])
					{
						t.sendEvent("asc_onDocumentPassword", "" !== t.currentPassword);
					}
					else
					{
						t.sendEvent("asc_onError", AscCommon.mapAscServerErrorToAscError(parseInt(input["data"])),
							c_oAscError.Level.NoCritical);
					}
				}
				else
				{
					t.sendEvent("asc_onError", c_oAscError.ID.Unknown, c_oAscError.Level.NoCritical);
				}
			};
			AscCommon.sendCommand(this, null, rData);
		}
	};
	baseEditorsApi.prototype.asc_resetPassword = function()
	{
		this.asc_setCurrentPassword("");
	};

	baseEditorsApi.prototype.asc_GetPossibleNumberingLanguage = function () {};
	baseEditorsApi.prototype.CheckDeprecatedBulletPreviewInfo = function (arrDrawingInfo, nTypeOfPreview)
	{
		const arrAdaptedDrawingInfo = [];

		for (let i = 0; i < arrDrawingInfo.length; i += 1)
		{
			let sDivId;
			let oNumberingInfo;

			// Это верный тип передачи информации
			if (arrDrawingInfo[i]["numberingInfo"])
			{
				arrAdaptedDrawingInfo.push(arrDrawingInfo[i]);
			}
			else if (arrDrawingInfo[i]["divId"])
			{
				sDivId = arrDrawingInfo[i]["divId"];
				let sResult = null;
				switch (arrDrawingInfo[i]["type"])
				{
					case 0:
					{
						break;
					}
					case 1:
					{
						const oBullet = new AscFormat.CBullet();
						oBullet.fillBulletFromCharAndFont(arrDrawingInfo[i]["char"], arrDrawingInfo[i]["specialFont"] || "Arial");
						oNumberingInfo = oBullet.getJsonBullet();
						break;
					}
					case 2:
					{
						const oBullet = new AscFormat.CBullet();
						oBullet.fillBulletImage(arrDrawingInfo[i]["imageId"]);
						oNumberingInfo = oBullet.getJsonBullet();
						break;
					}
					case 3:
					{
						switch (arrDrawingInfo[i]["numberingType"])
						{
							case Asc.c_oAscNumberingLevel.UpperLetterDot_Left: sResult = '{"bulletTypeface":{"type":"bufont","typeface":"Arial"},"bulletType":{"type":"autonum","char":null,"autoNumType":"alphaUcPeriod","startAt":null}}'; break;
							case Asc.c_oAscNumberingLevel.LowerLetterBracket_Left: sResult = '{"bulletTypeface":{"type":"bufont","typeface":"Arial"},"bulletType":{"type":"autonum","char":null,"autoNumType":"alphaLcParenR","startAt":null}}'; break;
							case Asc.c_oAscNumberingLevel.LowerLetterDot_Left: sResult = '{"bulletTypeface":{"type":"bufont","typeface":"Arial"},"bulletType":{"type":"autonum","char":null,"autoNumType":"alphaLcPeriod","startAt":null}}'; break;
							case Asc.c_oAscNumberingLevel.DecimalDot_Right: sResult = '{"bulletTypeface":{"type":"bufont","typeface":"Arial"},"bulletType":{"type":"autonum","char":null,"autoNumType":"arabicPeriod","startAt":null}}'; break;
							case Asc.c_oAscNumberingLevel.DecimalBracket_Right: sResult = '{"bulletTypeface":{"type":"bufont","typeface":"Arial"},"bulletType":{"type":"autonum","char":null,"autoNumType":"arabicParenR","startAt":null}}'; break;
							case Asc.c_oAscNumberingLevel.UpperRomanDot_Right: sResult = '{"bulletTypeface":{"type":"bufont","typeface":"Arial"},"bulletType":{"type":"autonum","char":null,"autoNumType":"romanUcPeriod","startAt":null}}'; break;
							case Asc.c_oAscNumberingLevel.LowerRomanDot_Right: sResult = '{"bulletTypeface":{"type":"bufont","typeface":"Arial"},"bulletType":{"type":"autonum","char":null,"autoNumType":"romanLcPeriod","startAt":null}}'; break;
							default: break;
						}
						break;
					}
					default: break;
				}
				if (sResult !== null)
					oNumberingInfo = JSON.parse(sResult);
				arrAdaptedDrawingInfo.push({"divId": sDivId, "numberingInfo": {"bullet": oNumberingInfo}});
			}
		}

		return arrAdaptedDrawingInfo;
	};
	baseEditorsApi.prototype.ParseBulletPreviewInformation = function (arrDrawingInfo)
	{
		const arrNumberingLvls = [];
		AscFormat.ExecuteNoHistory(function ()
		{
			for (let i = 0; i < arrDrawingInfo.length; i += 1)
			{
				const oDrawInfo = arrDrawingInfo[i];
				const oNumberingInfo = oDrawInfo["numberingInfo"];
				if (!oNumberingInfo) continue;
				const sDivId = oDrawInfo["divId"];
				if (!oNumberingInfo["bullet"])
				{
					const oPresentationBullet = new AscCommonWord.CPresentationBullet();
					const oTextPr = new AscCommonWord.CTextPr();
					oPresentationBullet.m_sChar = AscCommon.translateManager.getValue("None");
					oPresentationBullet.m_nType = AscFormat.numbering_presentationnumfrmt_Char;
					oPresentationBullet.m_bFontTx = false;
					oPresentationBullet.m_sFont   = "Arial";
					oTextPr.Unifill = AscFormat.CreateSolidFillRGB(0, 0, 0);
					oTextPr.FontSize = oTextPr.FontSizeCS = 65;
					oPresentationBullet.MergeTextPr(oTextPr);
					arrNumberingLvls.push({divId: sDivId, arrLvls: [oPresentationBullet], isRemoving: true});
				}
				else
				{
					const oBullet = window['AscJsonConverter'].ReaderFromJSON.prototype.BulletFromJSON(oNumberingInfo["bullet"]);
					const oPresentationBullet = oBullet.getPresentationBullet(AscFormat.GetDefaultTheme(), AscFormat.GetDefaultColorMap());
					oPresentationBullet.m_bFontTx = false;
					const oTextPr = new AscCommonWord.CTextPr();
					oTextPr.Unifill = AscFormat.CreateSolidFillRGB(0, 0, 0);
					oTextPr.FontSize = oTextPr.FontSizeCS = 65;
					oPresentationBullet.MergeTextPr(oTextPr);
					arrNumberingLvls.push({divId: sDivId, arrLvls: [oPresentationBullet]});
				}
			}
		}, this);
		return arrNumberingLvls;
	};
	baseEditorsApi.prototype.SetDrawImagePreviewBulletForMenu = function(arrDrawingInfo, nType)
	{
		const arrAdaptedDrawingInfo = this.CheckDeprecatedBulletPreviewInfo(arrDrawingInfo, nType);
		const arrParsedInfo = this.ParseBulletPreviewInformation(arrAdaptedDrawingInfo);
		const oDrawer = new AscCommon.CBulletPreviewDrawer(arrParsedInfo, nType);
		oDrawer.checkFontsAndDraw();
	};
	baseEditorsApi.prototype.asc_setMacros = function(sData)
	{
		if (!this.macros)
			return true;

		// we shouldn't create a history point and update it if macros haven't been changed
		if (this.macros.Data && this.macros.Data === sData)
			return true;

		if (true === AscCommon.CollaborativeEditing.Get_GlobalLock())
			return true;

		AscCommon.CollaborativeEditing.OnStart_CheckLock();
		this.macros.CheckLock();

		if (this.editorId == AscCommon.c_oEditorId.Spreadsheet)
		{
			var _this = this;
			Asc.editor.checkObjectsLock([this.macros.Get_Id()], function(bNoLock) {
				if (bNoLock)
				{
					AscCommon.History.Create_NewPoint(AscDFH.historydescription_DocumentMacros_Data);
					_this.macros.SetData(sData);
				}
			});
		}
		else
		{
			if (false === AscCommon.CollaborativeEditing.OnEnd_CheckLock(false))
			{
				AscCommon.History.Create_NewPoint(AscDFH.historydescription_DocumentMacros_Data);
				this.macros.SetData(sData);
			}
		}
	};
	baseEditorsApi.prototype.asc_getMacros = function()
	{
		return this.macros.GetData();
	};

	baseEditorsApi.prototype._beforeEvalCommand = function()
	{
		var oApi = this;
		switch (this.editorId)
		{
			case AscCommon.c_oEditorId.Word:
			{
				if (this.WordControl && this.WordControl.m_oLogicDocument)
					this.WordControl.m_oLogicDocument.LockPanelStyles();
				break;
			}
			case AscCommon.c_oEditorId.Spreadsheet:
			{
				if (AscCommonExcel)
				{
					oApi.tmpR1C1mode = AscCommonExcel.g_R1C1Mode;
					AscCommonExcel.g_R1C1Mode = false;
				}
				break;
			}
			default:
				break;
		}
	};

	baseEditorsApi.prototype._afterEvalCommand = function(endAction)
	{
		var oApi = this;
		switch (this.editorId)
		{
			case AscCommon.c_oEditorId.Word:
			case AscCommon.c_oEditorId.Presentation:
			{
				var oLogicDocument = this.WordControl.m_oLogicDocument;
				if (!oLogicDocument)
				{
					endAction && endAction();
					return;
				}

				var _imagesArray = oLogicDocument.Get_AllImageUrls();
				var _images = {};
				for (var i = 0; i < _imagesArray.length; i++)
					_images[_imagesArray[i]] = _imagesArray[i];

				AscCommon.Check_LoadingDataBeforePrepaste(this, oLogicDocument.Document_Get_AllFontNames(), _images, function() {
					if (oLogicDocument.Reassign_ImageUrls)
						oLogicDocument.Reassign_ImageUrls(_images);

					if (AscCommon.c_oEditorId.Word === oApi.editorId)
					{
						oLogicDocument.UnlockPanelStyles(true);
						oLogicDocument.OnEndLoadScript();
					}
					
					if (oApi.SaveAfterMacros)
					{
						oApi.asc_Save();
						oApi.SaveAfterMacros = false;
					}

					endAction && endAction();
				});
				break;
			}
			case AscCommon.c_oEditorId.Spreadsheet:
			{
				var oModel = this.wbModel;
				var _imagesArray = oModel.getAllImageUrls();
				var _images = {};
				for (var i = 0; i < _imagesArray.length; i++)
					_images[_imagesArray[i]] = _imagesArray[i];

				AscCommon.Check_LoadingDataBeforePrepaste(this, oModel._generateFontMap(), _images, function() {
					oModel.reassignImageUrls(_images);
					oApi.asc_Recalculate(true);
					var wsView = oApi.wb && oApi.wb.getWorksheet();
					if (wsView && wsView.objectRender && wsView.objectRender.controller)
					{
						wsView.objectRender.controller.recalculate2(undefined);
					}

					if (oApi.SaveAfterMacros)
					{
						oApi.asc_Save();
						oApi.SaveAfterMacros = false;
					}

					endAction && endAction();
				});
				
				if (AscCommonExcel)
				{
					AscCommonExcel.g_R1C1Mode = oApi.tmpR1C1mode;
					oApi.tmpR1C1mode = null;
				}
				break;
			}
			default:
				break;
		}
	};


	baseEditorsApi.prototype.asc_runAutostartMacroses = function()
    {
    	if (!this.macros || this.disableAutostartMacros)
    		return;

		if (this.DocInfo && !this.DocInfo.asc_getIsEnabledMacroses())
			return;
		
		if (window["AscDesktopEditor"] && window["AscDesktopEditor"]["isSupportMacroses"] && !window["AscDesktopEditor"]["isSupportMacroses"]())
			return;
		
		if (!this.canRunBuilderScript())
			return;
	
		this._beforeEvalCommand();
		this.macros.runAuto();
		this._afterEvalCommand(undefined);
		this.onEndBuilderScript();
    };
	baseEditorsApi.prototype.asc_runMacros = function(sGuid)
    {
    	if (!this.macros)
    		return;

		if (this.DocInfo && !this.DocInfo.asc_getIsEnabledMacroses())
			return;
		
		if (window["AscDesktopEditor"] && window["AscDesktopEditor"]["isSupportMacroses"] && !window["AscDesktopEditor"]["isSupportMacroses"]())
			return;
		
		if (!this.canRunBuilderScript())
			return;
		
		this._beforeEvalCommand();
		this.macros.run(sGuid);
		this._afterEvalCommand(undefined);
		this.onEndBuilderScript();
    };
	baseEditorsApi.prototype.asc_getAllMacrosNames = function()
    {
    	if (!this.macros)
    		return [];

		return this.macros.getAllNames();
    };
	baseEditorsApi.prototype.asc_getMacrosGuidByName = function(sName)
    {
    	if (!this.macros)
    		return "";

		return this.macros.getGuidByName(sName);
    };
	baseEditorsApi.prototype.asc_getMacrosByGuid = function(sGuid)
    {
    	if (!this.macros)
    		return "";

		return this.macros.getNameByGuid(sGuid);
    };
	baseEditorsApi.prototype.asc_getUserPermissionToMakeRequestFromMacros = function(url, callback)
	{
		var bNeedCallback = this.editorId === AscCommon.c_oEditorId.Spreadsheet ? this.handlers.hasTrigger('asc_onMacrosPermissionRequest') : this.asc_checkNeedCallback('asc_onMacrosPermissionRequest');
		if (bNeedCallback) {
			this.sendEvent('asc_onMacrosPermissionRequest', url, callback);
		} else {
			var permission = confirm("A macro makes a request to URL. Do you want to allow the request to the '" + url +"' ?");
			callback(permission);
		}
	};

	baseEditorsApi.prototype.asc_getSelectedDrawingObjectsCount = function()
	{
		return 0;
	};

	baseEditorsApi.prototype.asc_decodeBuffer = function(buffer, codePage, callback) {
		//todo TextDecoder (ie11)
		var reader = new FileReader();
		//todo onerror
		reader.onload = reader.onerror = function(e) {
			callback(e.target.result ? e.target.result : "");
		};
		var encoding = "UTF-8";
		var encodingsLen = AscCommon.c_oAscEncodings.length;
		for (var i = 0; i < encodingsLen; ++i)
		{
			if (AscCommon.c_oAscEncodings[i][0] === codePage)
			{
				encoding = AscCommon.c_oAscEncodings[i][2];
				break;
			}
		}

		reader.readAsText(new Blob([buffer]), encoding);
	};
	baseEditorsApi.prototype.asc_parseText = function(text, options) {
		return AscCommon.parseText(text, options, true);
	}

	baseEditorsApi.prototype.asc_setVisiblePasteButton = function(val)
	{
		if (AscCommon.g_specialPasteHelper)
		{
			AscCommon.g_specialPasteHelper.setVisiblePasteButton(val);
		}
	};
	/**
	 * Return default array for Math AutoCorrect symbols for menu
	 * @returns {Array.<String, Number || Array.<Number>>}
	 */
	baseEditorsApi.prototype.asc_getAutoCorrectMathSymbols = function()
	{
        return window['AscCommonWord'].g_AutoCorrectMathsList.DefaultAutoCorrectMathSymbolsList;
	};
	/**
	 * Return default array for Math AutoCorrect functions for menu
	 * @returns {Array.<String>}
	 */
	baseEditorsApi.prototype.asc_getAutoCorrectMathFunctions = function()
	{
        return window['AscCommonWord'].g_AutoCorrectMathsList.DefaultAutoCorrectMathFuncs;
	};
	/**
	 * Reset to defaul math autocorrect symbols list
	 */
	baseEditorsApi.prototype.asc_resetToDefaultAutoCorrectMathSymbols = function()
	{
		window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathSymbols = JSON.parse(JSON.stringify(window['AscCommonWord'].g_AutoCorrectMathsList.DefaultAutoCorrectMathSymbolsList));
		AscMath.UpdateAutoCorrection();
	};
	/**
	 * Reset to default version math autocorrect functions list
	 */
	baseEditorsApi.prototype.asc_resetToDefaultAutoCorrectMathFunctions = function()
	{
		window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathFuncs = JSON.parse(JSON.stringify(window['AscCommonWord'].g_AutoCorrectMathsList.DefaultAutoCorrectMathFuncs));
		AscMath.UpdateFuncCorrection();
	};
	/**
	 * Delete item from g_AutoCorrectMathSymbols
	 * @param {string} element
	 */
	baseEditorsApi.prototype.asc_deleteFromAutoCorrectMathSymbols = function(element)
	{
        var remInd = window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathSymbols.findIndex(function(val, index){
			if (val[0] === element){
				return true;
			}
		});
		window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathSymbols.splice(remInd, 1);
		AscMath.UpdateAutoCorrection();
	};
	/**
	 * Delete item from g_AutoCorrectMathFuncs
	 * @param {string} element
	 */
	baseEditorsApi.prototype.asc_deleteFromAutoCorrectMathFunctions = function(element)
	{
        var remInd = window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathFuncs.findIndex(function(val, index){
			if (val === element){
				return true;
			}
		});
		window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathFuncs.splice(remInd, 1);
		AscMath.UpdateFuncCorrection();
	};
	/**
	 * Add or edit item from g_AutoCorrectMathSymbols
	 * @param {string} element
	 * @param {Array.<number> || number || string} repVal
	 */
	baseEditorsApi.prototype.asc_AddOrEditFromAutoCorrectMathSymbols = function(element, repVal)
	{
		if (typeof repVal === 'string') {
			repVal = AscCommon.convertUTF16toUnicode(repVal);
		}
		var changeInd = window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathSymbols.findIndex(function(val, index){
			if (val[0] === element){
				return true;
			}
		});
		if (changeInd >= 0) {
			window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathSymbols[changeInd][1] = repVal;
		} else {
			window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathSymbols.push([element, repVal]);
		}

		AscMath.UpdateAutoCorrection();
	};
	/**
	 * Add item from g_AutoCorrectMathFuncs
	 * @param {string} newEl
	 */
	baseEditorsApi.prototype.asc_AddFromAutoCorrectMathFunctions = function(newEl)
	{
		window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathFuncs.push(newEl);
		AscMath.UpdateFuncCorrection();
	};
	/**
	 * Refresh g_AutoCorrectMathSymbols on start
	 * @param {Array.<string>} remItems
	 * @param {Array.<string, Array.<number> || number || string>} addItems
	 * @param {boolean} flag
	 */
	baseEditorsApi.prototype.asc_refreshOnStartAutoCorrectMathSymbols = function(remItems, addItems, flag)
	{
		var me = this;
		this.asc_resetToDefaultAutoCorrectMathSymbols();
		if (remItems) {
			remItems.forEach(function(el) {
				me.asc_deleteFromAutoCorrectMathSymbols(el);
			});
		}
		if (addItems) {
			addItems.forEach(function(el) {
				me.asc_AddOrEditFromAutoCorrectMathSymbols(el[0], el[1]);
			});
		}
		this.asc_updateFlagAutoCorrectMathSymbols(flag);
	};
	/**
	 * Refresh g_AutoCorrectMathFuncs on start
	 * @param {Array.<string>} remItems
	 * @param {Array.<string>} addItems
	 */
	baseEditorsApi.prototype.asc_refreshOnStartAutoCorrectMathFunctions = function(remItems, addItems)
	{
		var me = this;
		this.asc_resetToDefaultAutoCorrectMathFunctions();
		if (remItems) {
			remItems.forEach(function(el) {
				me.asc_deleteFromAutoCorrectMathFunctions(el);
			});
		}
		if (addItems) {
			addItems.forEach(function(el) {
				me.asc_AddFromAutoCorrectMathFunctions(el);
			});
		}
	};
	baseEditorsApi.prototype.asc_updateFlagAutoCorrectMathSymbols = function(flag)
	{
		window['AscCommonWord'].b_DoAutoCorrectMathSymbols = flag;
	};
	baseEditorsApi.prototype.asc_AddMath = function(type)
	{};
	baseEditorsApi.prototype.asc_ConvertMathView = function(isToLinear, isAll)
	{
	};
	baseEditorsApi.prototype.getMathInputType = function()
	{
		return this.mathInputType;
	};
	baseEditorsApi.prototype.asc_GetMathInputType = function()
	{
		return this.getMathInputType();
	};
	baseEditorsApi.prototype.asc_SetMathInputType = function(type)
	{
		this.mathInputType = type;
	};

	baseEditorsApi.prototype.getFileAsFromChanges = function()
	{
		var func_before = null;
		var func_after = null;
		if (this.editorId === AscCommon.c_oEditorId.Word)
		{
			if (this.WordControl && this.WordControl.m_oLogicDocument && this.WordControl.m_oLogicDocument.IsViewModeInReview())
			{
				var isFinal = (this.WordControl.m_oLogicDocument.ViewModeInReview.mode === 1) ? true : false;

				func_before = function(api) {
					api.WordControl.m_oLogicDocument.Start_SilentMode();
					api.asc_EndViewModeInReview();
				};
				func_after = function(api) {
					api.asc_BeginViewModeInReview(isFinal);
					api.WordControl.m_oLogicDocument.End_SilentMode(false);
				};
			}
		}

		func_before && func_before(this);
		var ret = this.asc_nativeGetFile3();
		func_after && func_after(this);
		return ret;
	};

	baseEditorsApi.prototype.initShortcuts = function(arrShortcuts, isRemoveBeforeAdd)
	{
		// Массив
		// [[ActionType, KeyCode, Ctrl, Shift, Alt]]
		for (var nIndex = 0, nCount = arrShortcuts.length; nIndex < nCount; ++nIndex)
		{
			var s = arrShortcuts[nIndex];

			if (true === isRemoveBeforeAdd)
				this.Shortcuts.RemoveByType(s[0]);

			this.Shortcuts.Add(s[0], s[1], s[2], s[3], s[4]);
		}
	};
	baseEditorsApi.prototype.initDefaultShortcuts = function()
	{
	};
	baseEditorsApi.prototype.getShortcut = function(e)
	{
		if (e.GetKeyCode)
			return this.Shortcuts.Get(e.GetKeyCode(), e.IsCtrl(), e.IsShift(), e.IsAlt());
		else
			return this.Shortcuts.Get(e.KeyCode, e.CtrlKey, e.ShiftKey, e.AltKey);
	};
	baseEditorsApi.prototype.executeShortcut = function(type)
	{
		
	};
	baseEditorsApi.prototype.getCustomShortcutAction = function(nActionType)
	{
		return this.Shortcuts.GetCustomAction(nActionType);
	};
	baseEditorsApi.prototype.asc_initShortcuts = baseEditorsApi.prototype.initShortcuts;
	baseEditorsApi.prototype.asc_getShortcutAction = function(nKeyCode, isCtrl, isShift, isAlt)
	{
		return this.Shortcuts.Get(nKeyCode, isCtrl, isShift, isAlt);
	};
	baseEditorsApi.prototype.asc_removeShortcuts = function(arrShortcuts, arrActionTypes)
	{
		if (arrShortcuts)
		{
			for (var nIndex = 0, nCount = arrShortcuts.length; nIndex < nCount; ++nIndex)
			{
				var s = arrShortcuts[nIndex];
				this.Shortcuts.Remove(s[0], s[1], s[2], s[3]);
			}
		}

		if (arrActionTypes)
		{
			for (var nIndex = 0, nCount = arrActionTypes.length; nIndex < nCount; ++nIndex)
			{
				this.Shortcuts.RemoveByType(arrActionTypes[nIndex]);
			}
		}
	};
	baseEditorsApi.prototype.asc_addCustomShortcutInsertSymbol = function(nCharCode, sFont, sShortcut)
	{
		var nActionType = this.Shortcuts.AddCustomActionSymbol(nCharCode, sFont);
		this.Shortcuts.Add(nActionType, sShortcut[0], sShortcut[1], sShortcut[2], sShortcut[3]);
		return nActionType;
	};
	baseEditorsApi.prototype.asc_setSkin = baseEditorsApi.prototype["asc_setSkin"] = function(skin)
	{
		AscCommon.updateGlobalSkin(skin);
		this.updateSkin(skin);
	};
	baseEditorsApi.prototype.updateSkin = function()
	{
	};
	baseEditorsApi.prototype.isLocalMode = function()
	{
		if (window["AscDesktopEditor"])
		{
			if (window["AscDesktopEditor"]["IsLocalFile"]())
				return true;
			if (AscCommon.EncryptionWorker && AscCommon.EncryptionWorker.isNeedCrypt())
				return true;
		}
		return false;
	};
	baseEditorsApi.prototype.isCloudModeCrypt = function()
	{
		if (window["AscDesktopEditor"])
		{
			if (window["AscDesktopEditor"]["IsLocalFile"]())
				return false;
			if (AscCommon.EncryptionWorker && AscCommon.EncryptionWorker.isNeedCrypt())
				return true;
		}
		return false;
	};
	baseEditorsApi.prototype.asc_initPrintPreview                     = function()
	{
	};
	baseEditorsApi.prototype.asc_drawPrintPreview                     = function()
	{
	};
	baseEditorsApi.prototype.asc_EditSelectAll = function()
	{
	};
	baseEditorsApi.prototype.asc_enterText = function(value)
	{
	};
	baseEditorsApi.prototype.asc_correctEnterText = function(oldValue, newValue)
	{
	};
	baseEditorsApi.prototype.asc_setContentDarkMode = function(isDarkMode)
	{
		if (this.isDarkMode === isDarkMode)
			return;

		this.isDarkMode = isDarkMode;

		this.updateDarkMode();
	};
	baseEditorsApi.prototype.canEnterText = function()
	{
		return this.canEdit();
	};
	baseEditorsApi.prototype.updateDarkMode = function()
	{
	};
	//---------------------------------------------------------statistics-----------------------------------------------
	baseEditorsApi.prototype.startGetDocInfo = function()
	{
		this.sync_GetDocInfoStartCallback();
		this.sync_GetDocInfoEndCallback();
	};
	baseEditorsApi.prototype.stopGetDocInfo = function()
	{
		this.sync_GetDocInfoStopCallback();
	};
	baseEditorsApi.prototype.sync_DocInfoCallback = function(obj)
	{
		this.sendEvent("asc_onDocInfo", new AscCommon.CDocInfoProp(obj));
	};
	baseEditorsApi.prototype.sync_GetDocInfoStartCallback = function()
	{
		this.sendEvent("asc_onGetDocInfoStart");
	};
	baseEditorsApi.prototype.sync_GetDocInfoStopCallback = function()
	{
		this.sendEvent("asc_onGetDocInfoStop");
	};
	baseEditorsApi.prototype.sync_GetDocInfoEndCallback = function()
	{
		this.sendEvent("asc_onGetDocInfoEnd");
	};
	//---------------------------------------------------------search-----------------------------------------------------
	baseEditorsApi.prototype.asc_searchEnabled = function(isEnabled)
	{
	};
	baseEditorsApi.prototype.asc_findText = function(oProps, isNext, callback)
	{
		return 0;
	};
	baseEditorsApi.prototype.asc_endFindText = function()
	{
	};
	baseEditorsApi.prototype.asc_selectSearchingResults = function(isShow)
	{
		if (this.selectSearchingResults === isShow)
			return;
		
		this.selectSearchingResults = isShow;
		
		this._selectSearchingResults(isShow);
	};
	baseEditorsApi.prototype.asc_isSelectSearchingResults = function()
	{
		return this.selectSearchingResults;
	};
	baseEditorsApi.prototype._selectSearchingResults = function()
	{
	};
	baseEditorsApi.prototype.asc_StartTextAroundSearch = function()
	{
	};
	baseEditorsApi.prototype.sync_setSearchCurrent = function(nCurrent, nOverallCount)
	{
		this.sendEvent("asc_onSetSearchCurrent", nCurrent, nOverallCount);
	};
	baseEditorsApi.prototype.sync_startTextAroundSearch = function()
	{
		this.sendEvent("asc_onStartTextAroundSearch");
	};
	baseEditorsApi.prototype.sync_endTextAroundSearch = function()
	{
		this.sendEvent("asc_onEndTextAroundSearch");
	};
	baseEditorsApi.prototype.sync_getTextAroundSearchPack = function(arrElements)
	{
		this.sendEvent("asc_onGetTextAroundSearchPack", arrElements);
	};
	baseEditorsApi.prototype.sync_removeTextAroundSearch = function(sId)
	{
		this.sendEvent("asc_onRemoveTextAroundSearch", [sId]);
	};
	//---------------------------------------------------------version----------------------------------------------------
	baseEditorsApi.prototype["GetVersion"] = baseEditorsApi.prototype.GetVersion = function()
	{
		this.versionSdk = AscCommon.g_cProductVersion;
		return (this.versionSdk === "0.0.0" || this.versionSdk.substr(2) === "Version") ? "develop" : this.versionSdk;
	};
	//----------------------------------------------------------addons----------------------------------------------------
	baseEditorsApi.prototype["asc_isSupportFeature"] = function(type)
	{
		return (window["Asc"] && window["Asc"]["Addons"] && window["Asc"]["Addons"][type] === true) ? true : false;
	};

	baseEditorsApi.prototype["asc_setDefaultBlitMode"] = function(value)
	{
		AscFonts.setDefaultBlitting(value);
	};

    // ---------------------------------------------------- internal events ----------------------------------------------
    baseEditorsApi.prototype.attachEvent = function(name, callback, listenerId)
    {
    	if (!this.internalEvents.hasOwnProperty(name))
            this.internalEvents[name] = {};
        this.internalEvents[name]["" + ((undefined === listenerId) ? 0 : listenerId)] = callback;
    };
    baseEditorsApi.prototype.detachEvent = function(name, listenerId)
    {
        if (!this.internalEvents.hasOwnProperty(name))
        	return;
        var obj = this.internalEvents[name];
        var prop = "" + ((undefined === listenerId) ? 0 : listenerId);
        if (obj[prop])
        	delete obj[prop];
        if (0 === Object.getOwnPropertyNames(obj).length)
        	delete this.internalEvents[name];
    };
    baseEditorsApi.prototype.sendInternalEvent = function()
	{
        var name = arguments[0];
        if (this.internalEvents.hasOwnProperty(name))
        {
            var obj = this.internalEvents[name];
            for (var prop in obj)
			{
				obj[prop].apply(this || window, Array.prototype.slice.call(arguments, 1));
			}
        }
        return false;
	};

    // это для отложенных действий на клике (диалоги в мобильной версии)
	baseEditorsApi.prototype.setHandlerOnClick = function(handler)
	{
		this._handlerOnClick = handler;
	};
	baseEditorsApi.prototype.getHandlerOnClick = function()
	{
		return this._handlerOnClick;
	};
	// ---------------------------------------------------- interface events ---------------------------------------------
	baseEditorsApi.prototype["asc_onShowPopupWindow"] = function()
	{
		if(this.mediaData)
		{
			this.callMediaPlayerCommand("hideMediaControl", null);
		}
	};


	baseEditorsApi.prototype.getPluginContextMenuInfo = function(e)
	{
		return new AscCommon.CPluginCtxMenuInfo();
	};

	// context menu items
	baseEditorsApi.prototype["onPluginContextMenuShow"] = function(e)
	{
		let contextMenuInfo = this.getPluginContextMenuInfo(e);
		let plugins = window.g_asc_plugins.onPluginEvent("onContextMenuShow", contextMenuInfo);
		if (0 === plugins.length)
		{
			if (this.contextMenuPlugins)
				delete this.contextMenuPlugins;
			return true;
		}

		if (!this.contextMenuPlugins)
		{
			this.contextMenuPlugins = {
				items : {},
				itemsCount : 0,
				processItems : {},
				processItemsCount : 0
			};
		}

		for (let i = 0, len = plugins.length; i < len; i++)
		{
			if (!this.contextMenuPlugins.processItems[plugins[i]])
			{
				this.contextMenuPlugins.processItems[plugins[i]] = 0;
				this.contextMenuPlugins.processItemsCount++;
			}
			++this.contextMenuPlugins.processItems[plugins[i]];
		}

		return false;
	};
	baseEditorsApi.prototype["onPluginContextMenuItemClick"] = function(guid, itemId)
	{
		let guids = {}; guids[guid] = true;
		window.g_asc_plugins.onPluginEvent2("onContextMenuClick", itemId, guids);
	};
	baseEditorsApi.prototype["onPluginToolbarMenuItemClick"] = function(guid, itemId)
	{
		let guids = {}; guids[guid] = true;
		window.g_asc_plugins.onPluginEvent2("onToolbarMenuClick", itemId, guids);
	};
	baseEditorsApi.prototype.onPluginCloseContextMenuItem = function(guid)
	{
		if (!this.contextMenuPlugins)
			return;

		let isUpdate = false;
		if (this.contextMenuPlugins.processItems[guid])
		{
			delete this.contextMenuPlugins.processItems[guid];
			this.contextMenuPlugins.processItemsCount--;
			isUpdate = true;
		}

		if (this.contextMenuPlugins.items[guid])
		{
			delete this.contextMenuPlugins.items[guid];
			this.contextMenuPlugins.itemsCount--;
			isUpdate = true;
		}

		if (isUpdate)
			this.onPluginCheckContextMenuItems();
	};
	baseEditorsApi.prototype.onPluginAddContextMenuItem = function(items)
	{
		if (!this.contextMenuPlugins)
			return;

		let guid = items["guid"];
		if (this.contextMenuPlugins.processItems[guid])
		{
			this.contextMenuPlugins.processItems[guid]--;
			// не копим.
			this.contextMenuPlugins.processItems[guid] = 0;
			if (this.contextMenuPlugins.processItems[guid] === 0)
			{
				delete this.contextMenuPlugins.processItems[guid];
				this.contextMenuPlugins.processItemsCount--;
			}
		}

		if (!this.contextMenuPlugins.items[guid])
			this.contextMenuPlugins.itemsCount++;

		this.contextMenuPlugins.items[guid] = items;

		this.onPluginCheckContextMenuItems();
	};
	baseEditorsApi.prototype.onPluginCheckContextMenuItems = function()
	{
		if (0 !== this.contextMenuPlugins.processItemsCount)
			return;

		let items = [];
		for (let item in this.contextMenuPlugins.items)
		{
			if (this.contextMenuPlugins.items.hasOwnProperty(item))
				items.push(this.contextMenuPlugins.items[item]);
		}

		delete this.contextMenuPlugins;
		this.sendEvent("onPluginContextMenu", items);
	};
	baseEditorsApi.prototype.onPluginUpdateContextMenuItem = function(items)
	{
		this.sendEvent("onPluginContextMenu", items);
	};

	baseEditorsApi.prototype.onPluginCloseToolbarMenuItem = function(guid)
	{
		this.sendEvent("onPluginToolbarMenu", [{ "guid" : guid, "tabs" : [] }]);
	};

	// ---------------------------------------------------- wopi ---------------------------------------------
	baseEditorsApi.prototype.asc_wopi_renameFile = function(name) {
		var t = this;
		var callback = function(isTimeout, response) {
			if (response) {
				t.CoAuthoringApi.onMeta({'title': response['Name'] + '.' + AscCommon.GetFileExtension(t.documentTitle)});
			} else {
				t.sendEvent("asc_onError", c_oAscError.ID.Unknown, c_oAscError.Level.NoCritical);
			}
		};
		if (!this.CoAuthoringApi.callPRC({'type': 'wopi_RenameFile', 'name': name}, Asc.c_nCommonRequestTime, callback)) {
			callback(false, undefined);
		}
	};

	baseEditorsApi.prototype.setOpenedAt = function(val)
	{
		this.openedAt = val;
	};

	baseEditorsApi.prototype.getImageDataFromSelection = function ()
	{
		return null;
	};

	baseEditorsApi.prototype.putImageToSelection = function (sImageSrc, nWidth, nHeight, replaceMode)
	{
	};

	// ---------------------------------------------------- oform ---------------------------------------------
	baseEditorsApi.prototype.signOform = function()
	{
		// TODO:
		// 1) делаем архив oform
		// 2) прогоняем архив через модуль для подписи. считаем хэши и делаем архив - и отдаем хмл для подписи
		// 3) вызываем плагин для подписи
		// 4) получаем подпись и информацию о подписи.
		// 5) добавляем эти данные в архив

		// TODO: проверить, есть ли плагин для подписи

		let plugin = window.g_asc_plugins ? window.g_asc_plugins.getSign() : null;
		if (!plugin)
		{
			this.sendEvent('asc_onError', c_oAscError.ID.Unknown, c_oAscError.Level.NoCritical);
			return;
		}

		let startData = new Asc.CPluginData();
		startData.setAttribute("data", "test_sign_data");

		this.asc_pluginRun(plugin.guid, 0, startData);
	};


	baseEditorsApi.prototype.retrieveFormatPainterData = function() {
		return null;
	};
	baseEditorsApi.prototype.getFormatPainter = function() {
		return this.formatPainter;
	};
	baseEditorsApi.prototype.getFormatPainterState = function() {
		return this.formatPainter.getState();
	};
	baseEditorsApi.prototype.isFormatPainterOn = function() {
		return this.formatPainter.isOn();
	};
	baseEditorsApi.prototype.isFormatPainterMultiple = function() {
		return this.formatPainter.isMultiple();
	};
	baseEditorsApi.prototype.canTurnOffFormatPainter = function() {
		return this.isFormatPainterOn() && !this.isFormatPainterMultiple();
	};
	baseEditorsApi.prototype.checkFormatPainterData = function() {
		return this.formatPainter.checkData();
	};
	baseEditorsApi.prototype.getFormatPainterData = function() {
		return this.formatPainter.data;
	};
	baseEditorsApi.prototype.clearFormatPainterData = function() {
		return this.formatPainter.clearData();
	};
	baseEditorsApi.prototype.sendPaintFormatEvent = function(_value)
	{
		let value = ( true === _value ? AscCommon.c_oAscFormatPainterState.kOn : ( false === _value ? AscCommon.c_oAscFormatPainterState.kOff : _value ) );
		this.formatPainter.putState(value);
		this.sendEvent("asc_onPaintFormatChanged", value);
		if(value === AscCommon.c_oAscFormatPainterState.kOff)
		{
			this.sendEvent('asc_onStopFormatPainter');
		}
	};
	baseEditorsApi.prototype.getEyedropperImgData = function()
	{
		return null;
	};
	baseEditorsApi.prototype.clearEyedropperImgData = function()
	{
		this.eyedropper.clearImageData();
	};
	baseEditorsApi.prototype.asc_startEyedropper = function(fEndCallback)
	{
		this.eyedropper.start(fEndCallback);
		this.stopInkDrawer()
	};
	baseEditorsApi.prototype.finishEyedropper = function()
	{
		this.eyedropper.finish();
	};
	baseEditorsApi.prototype.asc_finishEyedropper = function()
	{
		this.finishEyedropper();
	};
	baseEditorsApi.prototype.cancelEyedropper = function()
	{
		this.eyedropper.cancel();
	};
	baseEditorsApi.prototype.asc_cancelEyedropper = function()
	{
		this.cancelEyedropper();
	};
	baseEditorsApi.prototype.isEyedropperStarted = function()
	{
		return this.eyedropper.isStarted();
	};
	baseEditorsApi.prototype.getEyedropperColor = function()
	{
		return this.eyedropper.getColor();
	};
	baseEditorsApi.prototype.checkEyedropperColor = function(nX, nY)
	{
		this.eyedropper.checkColor(nX, nY);
	};
	baseEditorsApi.prototype.asc_StartDrawInk = function(oAscPen) {
		this.inkDrawer.startDraw(oAscPen);
		if(this.formatPainter.isOn()) {
			this.formatPainter.toggleState();
		}
		if(this.eyedropper.isStarted()) {
			this.eyedropper.end();
		}
	};
	baseEditorsApi.prototype.asc_StartInkEraser = function() {
		this.inkDrawer.startErase();
		if(this.formatPainter.isOn()) {
			this.formatPainter.toggleState();
		}
		if(this.eyedropper.isStarted()) {
			this.eyedropper.end();
		}
	};
	baseEditorsApi.prototype.asc_StopInkDrawer = function() {
		this.stopInkDrawer();
	};
	baseEditorsApi.prototype.asc_RemoveAllInks = function() {
		this.removeAllInks();
	};
	baseEditorsApi.prototype.removeAllInks = function() {
	};
	baseEditorsApi.prototype.asc_HaveInks = function() {
        return this.haveInks();
	};
	baseEditorsApi.prototype.haveInks = function() {
        return true;
	};
	baseEditorsApi.prototype.asc_CanRemoveAllInks = function() {
        return this.canRemoveAllInks();
	};
	baseEditorsApi.prototype.canRemoveAllInks = function() {
        return this.haveInks();
	};
	baseEditorsApi.prototype.stopInkDrawer = function() {
		this.inkDrawer.turnOff();
	};
	baseEditorsApi.prototype.onInkDrawerChangeState = function() {
	};
	baseEditorsApi.prototype.isInkDrawerOn = function() {
		return this.inkDrawer.isOn();
	};
	baseEditorsApi.prototype.isDrawInkMode = function() {
		return this.inkDrawer.isDraw();
	};
	baseEditorsApi.prototype.isEraseInkMode = function() {
		return this.inkDrawer.isErase();
	};
	baseEditorsApi.prototype.getInkPen = function() {
		return this.inkDrawer.getPen();
	};
	baseEditorsApi.prototype.getInkCursorType = function() {
		return this.inkDrawer.getCursorType();
	};
	baseEditorsApi.prototype.getAnnotations = function() {
		return null;
	};
	baseEditorsApi.prototype.isMasterMode = function(){
		return false;
	};
	baseEditorsApi.prototype.getSelectionState = function() {
	};
	baseEditorsApi.prototype.getSpeechDescription = function(prevState, action) {
		return null;
	};

	// methods for desktop:
	baseEditorsApi.prototype.isCloudSaveAsLocalToDrawingFormat = function(actionType, fileType) {
		if (!window["AscDesktopEditor"])
			return false;
		if (this.isLocalMode())
			return false;
		if (c_oAscAsyncAction.DownloadAs !== actionType)
			return false;

		switch (fileType)
		{
			case Asc.c_oAscFileType.PDF:
			case Asc.c_oAscFileType.PDFA:
			case Asc.c_oAscFileType.IMG:
			case Asc.c_oAscFileType.JPG:
			case Asc.c_oAscFileType.TIFF:
			case Asc.c_oAscFileType.TGA:
			case Asc.c_oAscFileType.GIF:
			case Asc.c_oAscFileType.PNG:
			case Asc.c_oAscFileType.EMF:
			case Asc.c_oAscFileType.WMF:
			case Asc.c_oAscFileType.BMP:
			case Asc.c_oAscFileType.CR2:
			case Asc.c_oAscFileType.PCX:
			case Asc.c_oAscFileType.RAS:
			case Asc.c_oAscFileType.PSD:
			case Asc.c_oAscFileType.ICO:
				window["AscDesktopEditor"]["emulateCloudPrinting"](true);
				return true;
			default:
				break;
		}
		return false;
	};

	baseEditorsApi.prototype.localSaveToDrawingFormat = function(base64Data, fileType) {
		this.sync_StartAction(Asc.c_oAscAsyncActionType.BlockInteraction, Asc.c_oAscAsyncAction.Save);

		let documentUrl = this.DocumentUrl;
		if (this.editorId === c_oEditorId.Spreadsheet)
			documentUrl = this.documentId + "/";
		window["AscDesktopEditor"]["localSaveToDrawingFormat"](this.documentTitle, documentUrl || "", this.ThemeLoader ? this.ThemeLoader.ThemesUrl : "", base64Data, fileType);
	};

	baseEditorsApi.prototype["onLocalSaveToDrawingFormat"] = function(error) {
		window["AscDesktopEditor"]["emulateCloudPrinting"](false);
		this.sync_EndAction(Asc.c_oAscAsyncActionType.BlockInteraction, Asc.c_oAscAsyncAction.Save);
		this.sync_EndAction(Asc.c_oAscAsyncActionType.BlockInteraction, Asc.c_oAscAsyncAction.DownloadAs);
		if (0 !== error)
			this.sendEvent("asc_onError", c_oAscError.ID.ConvertationSaveError, c_oAscError.Level.NoCritical);
	};

	// speech
	baseEditorsApi.prototype["setSpeechEnabled"] = function(isEnabled) {
		if (!AscCommon.EditorActionSpeaker)
		{
			AscCommon.EditorActionSpeakerInitData = { isEnabled : isEnabled };
			return;
		}
		if (isEnabled)
			AscCommon.EditorActionSpeaker.run();
		else
			AscCommon.EditorActionSpeaker.stop();
	};

	baseEditorsApi.prototype.asc_getFilePath = function(callback)
	{
		if (window["AscDesktopEditor"]) {
			window["AscDesktopEditor"]["OpenFilenameDialog"]("any", false, function(_file) {
				var file = _file;
				if (Array.isArray(file)) {
					file = file[0];
				}
				callback(file);
			});
		} else {
			callback(null);
		}
	};
	
	baseEditorsApi.prototype["asc_getUserColorById"] = function(id)
	{
		return AscCommon.getUserColorById(id, null, false, true);
	};

	baseEditorsApi.prototype.asc_openDocumentFromBytes = function(data)
	{
		let file = new AscCommon.OpenFileResult();
		file.data = data;
		file.bSerFormat = AscCommon.checkStreamSignature(file.data, AscCommon.c_oSerFormat.Signature);
		this.onEndLoadFile(file);
	};

	// for native editors
	baseEditorsApi.prototype.wrapFunction = function(name, types) 
	{
		this["native_" + name] = function() 
		{
			for (let i = 0, len = arguments.length; i < len; i++) 
			{
				if (types && types[i] && types[i].prototype && types[i].prototype.fromCValue)
					arguments[i] = types[i].prototype.fromCValue(arguments[i]);
			}
			if (!this[name])
				console.log("Wrap unexisted function: " + name);
			let result = this[name].apply(this, arguments);
			if (result && result.toCValue)
				result = result.toCValue();
			return result;
		}
	};

	baseEditorsApi.prototype.wrapEvent = function(name)
	{
		var wrapArray = function(args) {
			let arrayResult = new Array(args.length);
			for (let i = 0, len = args.length; i < len; i++)
			{
				arrayResult[i] = args[i];
				if (!args[i])
					continue;
				if (args[i].toCValue)
					arrayResult[i] = args[i].toCValue();
				else if (Array.isArray(args[i]))
					arrayResult[i] = wrapArray(args[i]);
			}
			return arrayResult;
		};

		this.asc_registerCallback(name, function()
		{
			window["native"]["onJsEvent"](name, wrapArray(arguments));
		});
	};

	baseEditorsApi.prototype.wrapShortcut = function(methodName, shortcutType)
	{
		this[methodName] = function() {
			this.executeShortcut.call(this, shortcutType);
		};
		this.wrapFunction(methodName);
	};

	baseEditorsApi.prototype.setPluginsOptions = function(options)
	{
		this.externalPluginsOptions = options;

		if (window.g_asc_plugins)
			window.g_asc_plugins.onUpdateOptions();
	};

	baseEditorsApi.prototype.getCustomProperties = function() {
		return null;
	};

	baseEditorsApi.prototype.asc_getAllCustomProperties = function() {
		let oCustomProperties = this.getCustomProperties();
		if(!oCustomProperties) return [];
		return oCustomProperties.getAllProperties();
	};
	
	baseEditorsApi.prototype.asc_addCustomProperty = function(name, type, value) {
		this.addCustomProperty(name, type, value);
	};

	baseEditorsApi.prototype.asc_modifyCustomProperty = function(idx, name, type, value) {
		this.modifyCustomProperty(idx, name, type, value);
	};

	
	baseEditorsApi.prototype.asc_removeCustomProperty = function(idx) {
		this.removeCustomProperty(idx);
	};
	
	baseEditorsApi.prototype.addCustomProperty = function(name, type, value) {
	};

	baseEditorsApi.prototype.modifyCustomProperty = function(idx, name, type, value) {
	};

	baseEditorsApi.prototype.removeCustomProperty = function(idx) {
	};
	
	baseEditorsApi.prototype.asc_setPdfViewer = function(isPdfViewer) {
	};

	// internal analog for plugins
	baseEditorsApi.prototype.callCommand = function(value, isRecalculate, callback) {
		let plugins = window.g_asc_plugins;
		if (!plugins)
			return;

		let isRecalc = isRecalculate !== false;
		if (typeof value === "string")
		{
			plugins.internalCallbacks.push(callback);
			plugins.callCommand(plugins.internalGuid, value, false, false, isRecalc, false);
		}
		else
		{
			let scope = {};
			if (window["Asc"] && window["Asc"]["scope"])
				scope = window["Asc"]["scope"];
			let txtValue = "var Asc = {}; Asc.scope = " + JSON.stringify(scope) + "; var scope = Asc.scope; (" + value.toString() + ")();";
			plugins.internalCallbacks.push(callback);
			plugins.callCommand(plugins.internalGuid, txtValue, false, false, isRecalc, false);
		}
	};

	baseEditorsApi.prototype.callMethod = function(name, params, callback) {
		let plugins = window.g_asc_plugins;
		if (!plugins)
			return

		plugins.internalCallbacks.push(callback);
		plugins.callMethod(plugins.internalGuid, name, params);
	};


	baseEditorsApi.prototype.asc_mergeSelectedShapes = function(operation) {
		if(AscCommon['PathBoolean']) {
			this.asc_mergeSelectedShapesAction(operation);
			return;
		}
		let oThis = this;
		AscCommon.loadPathBoolean(function () {
			oThis.asc_mergeSelectedShapesAction(operation);
		}, function () {
			oThis.sendEvent("asc_onError", Asc.c_oAscError.ID.LoadingScriptError, c_oAscError.Level.NoCritical)
		})
	};

	baseEditorsApi.prototype.asc_mergeSelectedShapesAction = function(operation) {

	};
	baseEditorsApi.prototype.asc_setRtlTextDirection = function(isRtl) {
	};
	baseEditorsApi.prototype.asc_isRtlTextDirection = function() {
		return false;
	};
	
	baseEditorsApi.prototype.asc_CheckCopy = function(data, format) {
	};
	baseEditorsApi.prototype.getSelectedContent = function(format) {
		let text_data = {
			data     : "",
			pushData : function(format, value) {
				this.data = value;
			}
		};
		
		this.asc_CheckCopy(text_data, format);
		if (text_data.data == null)
			text_data.data = "";
		
		return text_data.data;
	};

	//----------------------------------------------------------export----------------------------------------------------
	window['AscCommon']                = window['AscCommon'] || {};
	window['AscCommon'].baseEditorsApi = baseEditorsApi;

	prot = baseEditorsApi.prototype;
	prot['asc_loadFontsFromServer'] = prot.asc_loadFontsFromServer;
	prot['asc_setRestriction'] = prot.asc_setRestriction;
	prot['asc_addRestriction'] = prot.asc_addRestriction;
	prot['asc_removeRestriction'] = prot.asc_removeRestriction;
	prot['asc_setCanSendChanges'] = prot.asc_setCanSendChanges;
	prot['asc_selectSearchingResults'] = prot.asc_selectSearchingResults;
	prot['asc_isSelectSearchingResults'] = prot.asc_isSelectSearchingResults;
	prot['asc_showRevision'] = prot.asc_showRevision;
	prot['asc_refreshFile'] = prot.asc_refreshFile;
	prot['asc_getAdvancedOptions'] = prot.asc_getAdvancedOptions;
	prot['asc_Print'] = prot.asc_Print;
	prot['asc_GetCurrentColorSchemeName'] = prot.asc_GetCurrentColorSchemeName;
	prot['asc_GetCurrentColorSchemeIndex'] = prot.asc_GetCurrentColorSchemeIndex;
	prot['asc_runAutostartMacroses'] = prot.asc_runAutostartMacroses;
	prot['asc_runMacros'] = prot.asc_runMacros;
	prot['asc_getAllMacrosNames'] = prot.asc_getAllMacrosNames;
	prot['asc_parseText'] = prot.asc_parseText;
	prot['asc_setVisiblePasteButton'] = prot.asc_setVisiblePasteButton;
	prot['asc_getAutoCorrectMathSymbols'] = prot.asc_getAutoCorrectMathSymbols;
	prot['asc_getAutoCorrectMathFunctions'] = prot.asc_getAutoCorrectMathFunctions;
	prot['asc_resetToDefaultAutoCorrectMathSymbols'] = prot.asc_resetToDefaultAutoCorrectMathSymbols;
	prot['asc_resetToDefaultAutoCorrectMathFunctions'] = prot.asc_resetToDefaultAutoCorrectMathFunctions;
	prot['asc_deleteFromAutoCorrectMathSymbols'] = prot.asc_deleteFromAutoCorrectMathSymbols;
	prot['asc_deleteFromAutoCorrectMathFunctions'] = prot.asc_deleteFromAutoCorrectMathFunctions;
	prot['asc_AddOrEditFromAutoCorrectMathSymbols'] = prot.asc_AddOrEditFromAutoCorrectMathSymbols;
	prot['asc_AddFromAutoCorrectMathFunctions'] = prot.asc_AddFromAutoCorrectMathFunctions;
	prot['asc_refreshOnStartAutoCorrectMathSymbols'] = prot.asc_refreshOnStartAutoCorrectMathSymbols;
	prot['asc_refreshOnStartAutoCorrectMathFunctions'] = prot.asc_refreshOnStartAutoCorrectMathFunctions;
	prot['asc_updateFlagAutoCorrectMathSymbols'] = prot.asc_updateFlagAutoCorrectMathSymbols;
	prot['asc_AddMath'] = prot.asc_AddMath;
	prot['asc_ConvertMathView'] = prot.asc_ConvertMathView;
	prot['asc_GetMathInputType'] = prot.asc_GetMathInputType;
	prot['asc_SetMathInputType'] = prot.asc_SetMathInputType;
	prot['asc_initShortcuts'] = prot.asc_initShortcuts;
	prot['asc_getShortcutAction'] = prot.asc_getShortcutAction;
	prot['asc_removeShortcuts'] = prot.asc_removeShortcuts;
	prot['asc_addCustomShortcutInsertSymbol'] = prot.asc_addCustomShortcutInsertSymbol;
	prot['asc_wopi_renameFile'] = prot.asc_wopi_renameFile;
	prot['asc_getInformationBetweenFrameAndGeneralEditor'] = prot.asc_getInformationBetweenFrameAndGeneralEditor;
	prot['asc_setShapeNames'] = prot.asc_setShapeNames;
	prot['asc_generateChartPreviews'] = prot.asc_generateChartPreviews;
	prot['asc_createSmartArt'] = prot.asc_createSmartArt;
	prot['asc_generateSmartArtPreviews'] = prot.asc_generateSmartArtPreviews;
	prot['asc_addTableOleObject'] = prot.asc_addTableOleObject;
	prot['asc_editTableOleObject'] = prot.asc_editTableOleObject;
	prot['asc_canEditTableOleObject'] = prot.asc_canEditTableOleObject;
	prot['asc_EditSelectAll'] = prot.asc_EditSelectAll;
	prot['setOpenedAt'] = prot.setOpenedAt;
	prot['asc_SaveDrawingAsPicture'] = prot.asc_SaveDrawingAsPicture;
	prot['AddImageUrl'] = prot.AddImageUrl;
	prot['asc_SetDrawImagePreviewBulletForMenu'] = prot['SetDrawImagePreviewBulletForMenu'] = prot.SetDrawImagePreviewBulletForMenu;
	prot['asc_GetPossibleNumberingLanguage'] = prot.asc_GetPossibleNumberingLanguage;
	prot['asc_isCrypto'] = prot.asc_isCrypto;
	prot['asc_startEyedropper'] = prot.asc_startEyedropper;
	prot['asc_finishEyedropper'] = prot.asc_finishEyedropper;
	prot['asc_cancelEyedropper'] = prot.asc_cancelEyedropper;
	prot['asc_StartDrawInk'] = prot.asc_StartDrawInk;
	prot['asc_StartInkEraser'] = prot.asc_StartInkEraser;
	prot['asc_StopInkDrawer'] = prot.asc_StopInkDrawer;
	prot['asc_RemoveAllInks'] = prot.asc_RemoveAllInks;
	prot['asc_HaveInks'] = prot.asc_HaveInks;
	prot['asc_CanRemoveAllInks'] = prot.asc_CanRemoveAllInks;
	prot['startGetDocInfo'] = prot.startGetDocInfo;
	prot['stopGetDocInfo'] = prot.stopGetDocInfo;
	prot["can_CopyCut"] = prot.can_CopyCut;
	prot["asc_searchEnabled"] = prot.asc_searchEnabled;
	prot['asc_findText'] = prot.asc_findText;
	prot['asc_endFindText'] = prot.asc_endFindText;
	prot['asc_setContentDarkMode'] = prot.asc_setContentDarkMode;
	prot['asc_getFilePath'] = prot.asc_getFilePath;
	prot['asc_openDocumentFromBytes'] = prot.asc_openDocumentFromBytes;
	prot['asc_onMediaPlayerEvent'] = prot.asc_onMediaPlayerEvent;
	prot['asc_hideMediaControl'] = prot.asc_hideMediaControl;
	prot['asc_getInputLanguage'] = prot.asc_getInputLanguage;

	prot['setPluginsOptions'] = prot.setPluginsOptions;
	prot['asc_pluginButtonDockChanged'] = prot.asc_pluginButtonDockChanged;

	// passwords
	prot["asc_setCurrentPassword"] = prot.asc_setCurrentPassword;
	prot["asc_resetPassword"] = prot.asc_resetPassword;

	// NATIVE INITIALIZER (need be in min version)
	window["InitNativeEditors"] = function()
	{
		AscFonts.checkAllFonts();

		let loader = AscCommon.g_font_loader;
		loader.fontFiles = AscFonts.g_font_files;
		loader.fontInfos = AscFonts.g_font_infos;
		loader.map_font_index = AscFonts.g_map_font_index;

		window["InitNativeObject"]();
		if (window["InitNativeTextMeasurer"]) // fonts_ie.js
			window["InitNativeTextMeasurer"]();
		window["InitNativeZLib"]();
	};

	//custom properties
	prot["asc_getAllCustomProperties"] = prot.asc_getAllCustomProperties;
	prot["asc_addCustomProperty"] = prot.asc_addCustomProperty;
	prot["asc_modifyCustomProperty"] = prot.asc_modifyCustomProperty;
	prot["asc_removeCustomProperty"] = prot.asc_removeCustomProperty;
	
	prot["asc_setPdfViewer"] = prot.asc_setPdfViewer;
	prot["asc_mergeSelectedShapes"] = prot.asc_mergeSelectedShapes;

	prot["callCommand"] = prot.callCommand;
	prot["callMethod"] = prot.callMethod;

})(window);